// VP9 decoder: Implement multi-threaded loopfilter that uses the tile // threads. void vp9_loop_filter_frame_mt(YV12_BUFFER_CONFIG *frame, VP9Decoder *pbi, VP9_COMMON *cm, int frame_filter_level, int y_only) { VP9LfSync *const lf_sync = &pbi->lf_row_sync; const VP9WorkerInterface *const winterface = vp9_get_worker_interface(); // Number of superblock rows and cols const int sb_rows = mi_cols_aligned_to_sb(cm->mi_rows) >> MI_BLOCK_SIZE_LOG2; const int tile_cols = 1 << cm->log2_tile_cols; const int num_workers = MIN(pbi->max_threads & ~1, tile_cols); int i; if (!frame_filter_level) return; if (!lf_sync->sync_range || cm->last_height != cm->height) { vp9_loop_filter_dealloc(lf_sync); vp9_loop_filter_alloc(lf_sync, cm, sb_rows, cm->width); } vp9_loop_filter_frame_init(cm, frame_filter_level); // Initialize cur_sb_col to -1 for all SB rows. vpx_memset(lf_sync->cur_sb_col, -1, sizeof(*lf_sync->cur_sb_col) * sb_rows); // Set up loopfilter thread data. // The decoder is using num_workers instead of pbi->num_tile_workers // because it has been observed that using more threads on the // loopfilter, than there are tile columns in the frame will hurt // performance on Android. This is because the system will only // schedule the tile decode workers on cores equal to the number // of tile columns. Then if the decoder tries to use more threads for the // loopfilter, it will hurt performance because of contention. If the // multithreading code changes in the future then the number of workers // used by the loopfilter should be revisited. for (i = 0; i < num_workers; ++i) { VP9Worker *const worker = &pbi->tile_workers[i]; TileWorkerData *const tile_data = (TileWorkerData*)worker->data1; LFWorkerData *const lf_data = &tile_data->lfdata; worker->hook = (VP9WorkerHook)loop_filter_row_worker; // Loopfilter data lf_data->frame_buffer = frame; lf_data->cm = cm; vp9_copy(lf_data->planes, pbi->mb.plane); lf_data->start = i; lf_data->stop = sb_rows; lf_data->y_only = y_only; // always do all planes in decoder lf_data->lf_sync = lf_sync; lf_data->num_lf_workers = num_workers; // Start loopfiltering if (i == num_workers - 1) { winterface->execute(worker); } else { winterface->launch(worker); } } // Wait till all rows are finished for (i = 0; i < num_workers; ++i) { winterface->sync(&pbi->tile_workers[i]); } }
// VP9 decoder: Implement multi-threaded loopfilter that uses the tile // threads. void vp9_loop_filter_frame_mt(VP9Decoder *pbi, VP9_COMMON *cm, int frame_filter_level, int y_only, int partial_frame) { VP9LfSync *const lf_sync = &pbi->lf_row_sync; // Number of superblock rows and cols const int sb_rows = mi_cols_aligned_to_sb(cm->mi_rows) >> MI_BLOCK_SIZE_LOG2; const int tile_cols = 1 << cm->log2_tile_cols; const int num_workers = MIN(pbi->oxcf.max_threads & ~1, tile_cols); int i; // Allocate memory used in thread synchronization. // This always needs to be done even if frame_filter_level is 0. if (!cm->current_video_frame || cm->last_height != cm->height) { if (cm->last_height != cm->height) { const int aligned_last_height = ALIGN_POWER_OF_TWO(cm->last_height, MI_SIZE_LOG2); const int last_sb_rows = mi_cols_aligned_to_sb(aligned_last_height >> MI_SIZE_LOG2) >> MI_BLOCK_SIZE_LOG2; vp9_loop_filter_dealloc(lf_sync, last_sb_rows); } vp9_loop_filter_alloc(cm, lf_sync, sb_rows, cm->width); } if (!frame_filter_level) return; vp9_loop_filter_frame_init(cm, frame_filter_level); // Initialize cur_sb_col to -1 for all SB rows. vpx_memset(lf_sync->cur_sb_col, -1, sizeof(*lf_sync->cur_sb_col) * sb_rows); // Set up loopfilter thread data. // The decoder is using num_workers instead of pbi->num_tile_workers // because it has been observed that using more threads on the // loopfilter, than there are tile columns in the frame will hurt // performance on Android. This is because the system will only // schedule the tile decode workers on cores equal to the number // of tile columns. Then if the decoder tries to use more threads for the // loopfilter, it will hurt performance because of contention. If the // multithreading code changes in the future then the number of workers // used by the loopfilter should be revisited. for (i = 0; i < num_workers; ++i) { VP9Worker *const worker = &pbi->tile_workers[i]; TileWorkerData *const tile_data = (TileWorkerData*)worker->data1; LFWorkerData *const lf_data = &tile_data->lfdata; worker->hook = (VP9WorkerHook)loop_filter_row_worker; // Loopfilter data lf_data->frame_buffer = get_frame_new_buffer(cm); lf_data->cm = cm; lf_data->xd = pbi->mb; lf_data->start = i; lf_data->stop = sb_rows; lf_data->y_only = y_only; // always do all planes in decoder lf_data->lf_sync = lf_sync; lf_data->num_lf_workers = num_workers; // Start loopfiltering if (i == num_workers - 1) { vp9_worker_execute(worker); } else { vp9_worker_launch(worker); } } // Wait till all rows are finished for (i = 0; i < num_workers; ++i) { vp9_worker_sync(&pbi->tile_workers[i]); } }
// VP9 decoder: Implement multi-threaded loopfilter that uses the tile // threads. void vp9_loop_filter_frame_mt(VP9LfSync *lf_sync, YV12_BUFFER_CONFIG *frame, struct macroblockd_plane planes[MAX_MB_PLANE], VP9_COMMON *cm, VP9Worker *workers, int nworkers, int frame_filter_level, int y_only) { const VP9WorkerInterface *const winterface = vp9_get_worker_interface(); // Number of superblock rows and cols const int sb_rows = mi_cols_aligned_to_sb(cm->mi_rows) >> MI_BLOCK_SIZE_LOG2; const int tile_cols = 1 << cm->log2_tile_cols; const int num_workers = MIN(nworkers, tile_cols); int i; if (!frame_filter_level) return; if (!lf_sync->sync_range || cm->last_height != cm->height || num_workers > lf_sync->num_workers) { vp9_loop_filter_dealloc(lf_sync); vp9_loop_filter_alloc(lf_sync, cm, sb_rows, cm->width, num_workers); } vp9_loop_filter_frame_init(cm, frame_filter_level); // Initialize cur_sb_col to -1 for all SB rows. vpx_memset(lf_sync->cur_sb_col, -1, sizeof(*lf_sync->cur_sb_col) * sb_rows); // Set up loopfilter thread data. // The decoder is capping num_workers because it has been observed that using // more threads on the loopfilter than there are cores will hurt performance // on Android. This is because the system will only schedule the tile decode // workers on cores equal to the number of tile columns. Then if the decoder // tries to use more threads for the loopfilter, it will hurt performance // because of contention. If the multithreading code changes in the future // then the number of workers used by the loopfilter should be revisited. for (i = 0; i < num_workers; ++i) { VP9Worker *const worker = &workers[i]; LFWorkerData *const lf_data = &lf_sync->lfdata[i]; worker->hook = (VP9WorkerHook)loop_filter_row_worker; worker->data1 = lf_sync; worker->data2 = lf_data; // Loopfilter data vp9_loop_filter_data_reset(lf_data, frame, cm, planes); lf_data->start = i; lf_data->stop = sb_rows; lf_data->y_only = y_only; // Start loopfiltering if (i == num_workers - 1) { winterface->execute(worker); } else { winterface->launch(worker); } } // Wait till all rows are finished for (i = 0; i < num_workers; ++i) { winterface->sync(&workers[i]); } }