Ejemplos de vp9_filter_block_plane en C++ (Cpp)

Ejemplo n.º 1

Archivo: vp9_dthread.c Proyecto: DoubangoTelecom/libvpx_fast

// Implement row loopfiltering for each thread.
static void loop_filter_rows_mt(const YV12_BUFFER_CONFIG *const frame_buffer,
                                VP9_COMMON *const cm, MACROBLOCKD *const xd,
                                int start, int stop, int y_only,
                                VP9LfSync *const lf_sync, int num_lf_workers) {
  const int num_planes = y_only ? 1 : MAX_MB_PLANE;
  int r, c;  // SB row and col
  const int sb_cols = mi_cols_aligned_to_sb(cm->mi_cols) >> MI_BLOCK_SIZE_LOG2;

  for (r = start; r < stop; r += num_lf_workers) {
    const int mi_row = r << MI_BLOCK_SIZE_LOG2;
    MODE_INFO **const mi = cm->mi_grid_visible + mi_row * cm->mi_stride;

    for (c = 0; c < sb_cols; ++c) {
      const int mi_col = c << MI_BLOCK_SIZE_LOG2;
      LOOP_FILTER_MASK lfm;
      int plane;

      sync_read(lf_sync, r, c);

      vp9_setup_dst_planes(xd, frame_buffer, mi_row, mi_col);
      vp9_setup_mask(cm, mi_row, mi_col, mi + mi_col, cm->mi_stride, &lfm);

      for (plane = 0; plane < num_planes; ++plane) {
        vp9_filter_block_plane(cm, &xd->plane[plane], mi_row, &lfm);
      }

      sync_write(lf_sync, r, c, sb_cols);
    }
  }
}

Ejemplo n.º 2

Archivo: vp9_ethread.c Proyecto: awatry/libvpx.vp9_opencl

// Row-based multi-threaded loopfilter hook
static int loop_filter_row_worker(thread_context *const thread_ctxt,
                                  void *unused) {
  VP9_COMP *const cpi = thread_ctxt->cpi;
  VP9_COMMON *const cm = &cpi->common;
  MACROBLOCKD *const xd = &cpi->mb.e_mbd;
  const YV12_BUFFER_CONFIG *const frame_buffer = cm->frame_to_show;
  struct macroblockd_plane planes[MAX_MB_PLANE];
  const int num_planes = thread_ctxt->y_only ? 1 : MAX_MB_PLANE;
  int mi_row, mi_col;

  (void)unused;
  vp9_copy(planes, xd->plane);
  for (mi_row = thread_ctxt->mi_row_start; mi_row < thread_ctxt->mi_row_end;
       mi_row += thread_ctxt->mi_row_step) {
    const int sb_row = mi_row >> MI_BLOCK_SIZE_LOG2;
    MODE_INFO **const mi = cm->mi_grid_visible + mi_row * cm->mi_stride;

    for (mi_col = 0; mi_col < cm->mi_cols; mi_col += MI_BLOCK_SIZE) {
      const int sb_col = mi_col >> MI_BLOCK_SIZE_LOG2;
      LOOP_FILTER_MASK lfm;
      int plane;

      vp9_enc_sync_read(cpi, sb_row, sb_col);

      vp9_setup_dst_planes(planes, frame_buffer, mi_row, mi_col);
      vp9_setup_mask(cm, mi_row, mi_col, mi + mi_col, cm->mi_stride, &lfm);

      for (plane = 0; plane < num_planes; ++plane) {
        vp9_filter_block_plane(cm, &planes[plane], mi_row, &lfm);
      }

      vp9_enc_sync_write(cpi, sb_row);
    }
  }

  return 1;
}