346 lines
12 KiB
C
346 lines
12 KiB
C
/*
|
|
* Copyright (c) 2016, Alliance for Open Media. All rights reserved
|
|
*
|
|
* This source code is subject to the terms of the BSD 2 Clause License and
|
|
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
|
|
* was not distributed with this source code in the LICENSE file, you can
|
|
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
|
|
* Media Patent License 1.0 was not distributed with this source code in the
|
|
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
|
|
*/
|
|
|
|
#ifndef AOM_AV1_COMMON_THREAD_COMMON_H_
|
|
#define AOM_AV1_COMMON_THREAD_COMMON_H_
|
|
|
|
#include "config/aom_config.h"
|
|
|
|
#include "av1/common/av1_loopfilter.h"
|
|
#include "av1/common/cdef.h"
|
|
#include "aom_util/aom_pthread.h"
|
|
#include "aom_util/aom_thread.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
struct AV1Common;
|
|
|
|
typedef struct AV1LfMTInfo {
|
|
int mi_row;
|
|
int plane;
|
|
int dir;
|
|
int lpf_opt_level;
|
|
} AV1LfMTInfo;
|
|
|
|
// Loopfilter row synchronization
|
|
typedef struct AV1LfSyncData {
|
|
#if CONFIG_MULTITHREAD
|
|
pthread_mutex_t *mutex_[MAX_MB_PLANE];
|
|
pthread_cond_t *cond_[MAX_MB_PLANE];
|
|
#endif
|
|
// Allocate memory to store the loop-filtered superblock index in each row.
|
|
int *cur_sb_col[MAX_MB_PLANE];
|
|
// The optimal sync_range for different resolution and platform should be
|
|
// determined by testing. Currently, it is chosen to be a power-of-2 number.
|
|
int sync_range;
|
|
int rows;
|
|
|
|
// Row-based parallel loopfilter data
|
|
LFWorkerData *lfdata;
|
|
int num_workers;
|
|
|
|
#if CONFIG_MULTITHREAD
|
|
pthread_mutex_t *job_mutex;
|
|
#endif
|
|
AV1LfMTInfo *job_queue;
|
|
int jobs_enqueued;
|
|
int jobs_dequeued;
|
|
|
|
// Initialized to false, set to true by the worker thread that encounters an
|
|
// error in order to abort the processing of other worker threads.
|
|
bool lf_mt_exit;
|
|
} AV1LfSync;
|
|
|
|
typedef struct AV1LrMTInfo {
|
|
int v_start;
|
|
int v_end;
|
|
int lr_unit_row;
|
|
int plane;
|
|
int sync_mode;
|
|
int v_copy_start;
|
|
int v_copy_end;
|
|
} AV1LrMTInfo;
|
|
|
|
typedef struct LoopRestorationWorkerData {
|
|
int32_t *rst_tmpbuf;
|
|
void *rlbs;
|
|
void *lr_ctxt;
|
|
int do_extend_border;
|
|
struct aom_internal_error_info error_info;
|
|
} LRWorkerData;
|
|
|
|
// Looprestoration row synchronization
|
|
typedef struct AV1LrSyncData {
|
|
#if CONFIG_MULTITHREAD
|
|
pthread_mutex_t *mutex_[MAX_MB_PLANE];
|
|
pthread_cond_t *cond_[MAX_MB_PLANE];
|
|
#endif
|
|
// Allocate memory to store the loop-restoration block index in each row.
|
|
int *cur_sb_col[MAX_MB_PLANE];
|
|
// The optimal sync_range for different resolution and platform should be
|
|
// determined by testing. Currently, it is chosen to be a power-of-2 number.
|
|
int sync_range;
|
|
int rows;
|
|
int num_planes;
|
|
|
|
int num_workers;
|
|
|
|
#if CONFIG_MULTITHREAD
|
|
pthread_mutex_t *job_mutex;
|
|
#endif
|
|
// Row-based parallel loopfilter data
|
|
LRWorkerData *lrworkerdata;
|
|
|
|
AV1LrMTInfo *job_queue;
|
|
int jobs_enqueued;
|
|
int jobs_dequeued;
|
|
// Initialized to false, set to true by the worker thread that encounters
|
|
// an error in order to abort the processing of other worker threads.
|
|
bool lr_mt_exit;
|
|
} AV1LrSync;
|
|
|
|
typedef struct AV1CdefWorker {
|
|
AV1_COMMON *cm;
|
|
MACROBLOCKD *xd;
|
|
uint16_t *colbuf[MAX_MB_PLANE];
|
|
uint16_t *srcbuf;
|
|
uint16_t *linebuf[MAX_MB_PLANE];
|
|
cdef_init_fb_row_t cdef_init_fb_row_fn;
|
|
int do_extend_border;
|
|
struct aom_internal_error_info error_info;
|
|
} AV1CdefWorkerData;
|
|
|
|
typedef struct AV1CdefRowSync {
|
|
#if CONFIG_MULTITHREAD
|
|
pthread_mutex_t *row_mutex_;
|
|
pthread_cond_t *row_cond_;
|
|
#endif // CONFIG_MULTITHREAD
|
|
int is_row_done;
|
|
} AV1CdefRowSync;
|
|
|
|
// Data related to CDEF search multi-thread synchronization.
|
|
typedef struct AV1CdefSyncData {
|
|
#if CONFIG_MULTITHREAD
|
|
// Mutex lock used while dispatching jobs.
|
|
pthread_mutex_t *mutex_;
|
|
#endif // CONFIG_MULTITHREAD
|
|
// Data related to CDEF row mt sync information
|
|
AV1CdefRowSync *cdef_row_mt;
|
|
// Flag to indicate all blocks are processed and end of frame is reached
|
|
int end_of_frame;
|
|
// Row index in units of 64x64 block
|
|
int fbr;
|
|
// Column index in units of 64x64 block
|
|
int fbc;
|
|
// Initialized to false, set to true by the worker thread that encounters
|
|
// an error in order to abort the processing of other worker threads.
|
|
bool cdef_mt_exit;
|
|
} AV1CdefSync;
|
|
|
|
void av1_cdef_frame_mt(AV1_COMMON *const cm, MACROBLOCKD *const xd,
|
|
AV1CdefWorkerData *const cdef_worker,
|
|
AVxWorker *const workers, AV1CdefSync *const cdef_sync,
|
|
int num_workers, cdef_init_fb_row_t cdef_init_fb_row_fn,
|
|
int do_extend_border);
|
|
void av1_cdef_init_fb_row_mt(const AV1_COMMON *const cm,
|
|
const MACROBLOCKD *const xd,
|
|
CdefBlockInfo *const fb_info,
|
|
uint16_t **const linebuf, uint16_t *const src,
|
|
struct AV1CdefSyncData *const cdef_sync, int fbr);
|
|
void av1_cdef_copy_sb8_16(const AV1_COMMON *const cm, uint16_t *const dst,
|
|
int dstride, const uint8_t *src, int src_voffset,
|
|
int src_hoffset, int sstride, int vsize, int hsize);
|
|
void av1_cdef_copy_sb8_16_lowbd(uint16_t *const dst, int dstride,
|
|
const uint8_t *src, int src_voffset,
|
|
int src_hoffset, int sstride, int vsize,
|
|
int hsize);
|
|
void av1_cdef_copy_sb8_16_highbd(uint16_t *const dst, int dstride,
|
|
const uint8_t *src, int src_voffset,
|
|
int src_hoffset, int sstride, int vsize,
|
|
int hsize);
|
|
void av1_alloc_cdef_sync(AV1_COMMON *const cm, AV1CdefSync *cdef_sync,
|
|
int num_workers);
|
|
void av1_free_cdef_sync(AV1CdefSync *cdef_sync);
|
|
|
|
// Deallocate loopfilter synchronization related mutex and data.
|
|
void av1_loop_filter_dealloc(AV1LfSync *lf_sync);
|
|
void av1_loop_filter_alloc(AV1LfSync *lf_sync, AV1_COMMON *cm, int rows,
|
|
int width, int num_workers);
|
|
|
|
void av1_set_vert_loop_filter_done(AV1_COMMON *cm, AV1LfSync *lf_sync,
|
|
int num_mis_in_lpf_unit_height_log2);
|
|
|
|
void av1_loop_filter_frame_mt(YV12_BUFFER_CONFIG *frame, struct AV1Common *cm,
|
|
struct macroblockd *xd, int plane_start,
|
|
int plane_end, int partial_frame,
|
|
AVxWorker *workers, int num_workers,
|
|
AV1LfSync *lf_sync, int lpf_opt_level);
|
|
|
|
void av1_loop_restoration_filter_frame_mt(YV12_BUFFER_CONFIG *frame,
|
|
struct AV1Common *cm,
|
|
int optimized_lr, AVxWorker *workers,
|
|
int num_workers, AV1LrSync *lr_sync,
|
|
void *lr_ctxt, int do_extend_border);
|
|
void av1_loop_restoration_dealloc(AV1LrSync *lr_sync);
|
|
void av1_loop_restoration_alloc(AV1LrSync *lr_sync, AV1_COMMON *cm,
|
|
int num_workers, int num_rows_lr,
|
|
int num_planes, int width);
|
|
int av1_get_intrabc_extra_top_right_sb_delay(const AV1_COMMON *cm);
|
|
|
|
void av1_thread_loop_filter_rows(
|
|
const YV12_BUFFER_CONFIG *const frame_buffer, AV1_COMMON *const cm,
|
|
struct macroblockd_plane *planes, MACROBLOCKD *xd, int mi_row, int plane,
|
|
int dir, int lpf_opt_level, AV1LfSync *const lf_sync,
|
|
struct aom_internal_error_info *error_info,
|
|
AV1_DEBLOCKING_PARAMETERS *params_buf, TX_SIZE *tx_buf, int mib_size_log2);
|
|
|
|
static AOM_FORCE_INLINE bool skip_loop_filter_plane(
|
|
const int planes_to_lf[MAX_MB_PLANE], int plane, int lpf_opt_level) {
|
|
// If LPF_PICK_METHOD is LPF_PICK_FROM_Q, we have the option to filter both
|
|
// chroma planes together
|
|
if (lpf_opt_level == 2) {
|
|
if (plane == AOM_PLANE_Y) {
|
|
return !planes_to_lf[plane];
|
|
}
|
|
if (plane == AOM_PLANE_U) {
|
|
// U and V are handled together
|
|
return !planes_to_lf[1] && !planes_to_lf[2];
|
|
}
|
|
assert(plane == AOM_PLANE_V);
|
|
if (plane == AOM_PLANE_V) {
|
|
// V is handled when u is filtered
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// Normal operation mode
|
|
return !planes_to_lf[plane];
|
|
}
|
|
|
|
static AOM_INLINE void enqueue_lf_jobs(AV1LfSync *lf_sync, int start, int stop,
|
|
const int planes_to_lf[MAX_MB_PLANE],
|
|
int lpf_opt_level,
|
|
int num_mis_in_lpf_unit_height) {
|
|
int mi_row, plane, dir;
|
|
AV1LfMTInfo *lf_job_queue = lf_sync->job_queue;
|
|
lf_sync->jobs_enqueued = 0;
|
|
lf_sync->jobs_dequeued = 0;
|
|
|
|
// Launch all vertical jobs first, as they are blocking the horizontal ones.
|
|
// Launch top row jobs for all planes first, in case the output can be
|
|
// partially reconstructed row by row.
|
|
for (dir = 0; dir < 2; ++dir) {
|
|
for (mi_row = start; mi_row < stop; mi_row += num_mis_in_lpf_unit_height) {
|
|
for (plane = 0; plane < MAX_MB_PLANE; ++plane) {
|
|
if (skip_loop_filter_plane(planes_to_lf, plane, lpf_opt_level)) {
|
|
continue;
|
|
}
|
|
if (!planes_to_lf[plane]) continue;
|
|
lf_job_queue->mi_row = mi_row;
|
|
lf_job_queue->plane = plane;
|
|
lf_job_queue->dir = dir;
|
|
lf_job_queue->lpf_opt_level = lpf_opt_level;
|
|
lf_job_queue++;
|
|
lf_sync->jobs_enqueued++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static AOM_INLINE void loop_filter_frame_mt_init(
|
|
AV1_COMMON *cm, int start_mi_row, int end_mi_row,
|
|
const int planes_to_lf[MAX_MB_PLANE], int num_workers, AV1LfSync *lf_sync,
|
|
int lpf_opt_level, int num_mis_in_lpf_unit_height_log2) {
|
|
// Number of superblock rows
|
|
const int sb_rows =
|
|
CEIL_POWER_OF_TWO(cm->mi_params.mi_rows, num_mis_in_lpf_unit_height_log2);
|
|
|
|
if (!lf_sync->sync_range || sb_rows != lf_sync->rows ||
|
|
num_workers > lf_sync->num_workers) {
|
|
av1_loop_filter_dealloc(lf_sync);
|
|
av1_loop_filter_alloc(lf_sync, cm, sb_rows, cm->width, num_workers);
|
|
}
|
|
lf_sync->lf_mt_exit = false;
|
|
|
|
// Initialize cur_sb_col to -1 for all SB rows.
|
|
for (int i = 0; i < MAX_MB_PLANE; i++) {
|
|
memset(lf_sync->cur_sb_col[i], -1,
|
|
sizeof(*(lf_sync->cur_sb_col[i])) * sb_rows);
|
|
}
|
|
|
|
enqueue_lf_jobs(lf_sync, start_mi_row, end_mi_row, planes_to_lf,
|
|
lpf_opt_level, (1 << num_mis_in_lpf_unit_height_log2));
|
|
}
|
|
|
|
static AOM_INLINE AV1LfMTInfo *get_lf_job_info(AV1LfSync *lf_sync) {
|
|
AV1LfMTInfo *cur_job_info = NULL;
|
|
|
|
#if CONFIG_MULTITHREAD
|
|
pthread_mutex_lock(lf_sync->job_mutex);
|
|
|
|
if (!lf_sync->lf_mt_exit && lf_sync->jobs_dequeued < lf_sync->jobs_enqueued) {
|
|
cur_job_info = lf_sync->job_queue + lf_sync->jobs_dequeued;
|
|
lf_sync->jobs_dequeued++;
|
|
}
|
|
|
|
pthread_mutex_unlock(lf_sync->job_mutex);
|
|
#else
|
|
(void)lf_sync;
|
|
#endif
|
|
|
|
return cur_job_info;
|
|
}
|
|
|
|
static AOM_INLINE void loop_filter_data_reset(LFWorkerData *lf_data,
|
|
YV12_BUFFER_CONFIG *frame_buffer,
|
|
struct AV1Common *cm,
|
|
MACROBLOCKD *xd) {
|
|
struct macroblockd_plane *pd = xd->plane;
|
|
lf_data->frame_buffer = frame_buffer;
|
|
lf_data->cm = cm;
|
|
lf_data->xd = xd;
|
|
for (int i = 0; i < MAX_MB_PLANE; i++) {
|
|
memcpy(&lf_data->planes[i].dst, &pd[i].dst, sizeof(lf_data->planes[i].dst));
|
|
lf_data->planes[i].subsampling_x = pd[i].subsampling_x;
|
|
lf_data->planes[i].subsampling_y = pd[i].subsampling_y;
|
|
}
|
|
}
|
|
|
|
static AOM_INLINE void set_planes_to_loop_filter(const struct loopfilter *lf,
|
|
int planes_to_lf[MAX_MB_PLANE],
|
|
int plane_start,
|
|
int plane_end) {
|
|
// For each luma and chroma plane, whether to filter it or not.
|
|
planes_to_lf[0] = (lf->filter_level[0] || lf->filter_level[1]) &&
|
|
plane_start <= 0 && 0 < plane_end;
|
|
planes_to_lf[1] = lf->filter_level_u && plane_start <= 1 && 1 < plane_end;
|
|
planes_to_lf[2] = lf->filter_level_v && plane_start <= 2 && 2 < plane_end;
|
|
}
|
|
|
|
static AOM_INLINE int check_planes_to_loop_filter(
|
|
const struct loopfilter *lf, int planes_to_lf[MAX_MB_PLANE],
|
|
int plane_start, int plane_end) {
|
|
set_planes_to_loop_filter(lf, planes_to_lf, plane_start, plane_end);
|
|
// If the luma plane is purposely not filtered, neither are the chroma
|
|
// planes.
|
|
if (!planes_to_lf[0] && plane_start <= 0 && 0 < plane_end) return 0;
|
|
// Early exit.
|
|
if (!planes_to_lf[0] && !planes_to_lf[1] && !planes_to_lf[2]) return 0;
|
|
return 1;
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif
|
|
|
|
#endif // AOM_AV1_COMMON_THREAD_COMMON_H_
|