#include "vp10/common/entropymv.h"
#include "vp10/common/onyxc_int.h"
-void vp10_set_mb_mi(VP9_COMMON *cm, int width, int height) {
+void vp10_set_mb_mi(VP10_COMMON *cm, int width, int height) {
const int aligned_width = ALIGN_POWER_OF_TWO(width, MI_SIZE_LOG2);
const int aligned_height = ALIGN_POWER_OF_TWO(height, MI_SIZE_LOG2);
cm->MBs = cm->mb_rows * cm->mb_cols;
}
-static int alloc_seg_map(VP9_COMMON *cm, int seg_map_size) {
+static int alloc_seg_map(VP10_COMMON *cm, int seg_map_size) {
int i;
for (i = 0; i < NUM_PING_PONG_BUFFERS; ++i) {
return 0;
}
-static void free_seg_map(VP9_COMMON *cm) {
+static void free_seg_map(VP10_COMMON *cm) {
int i;
for (i = 0; i < NUM_PING_PONG_BUFFERS; ++i) {
}
}
-void vp10_free_postproc_buffers(VP9_COMMON *cm) {
+void vp10_free_postproc_buffers(VP10_COMMON *cm) {
#if CONFIG_VP9_POSTPROC
vp9_free_frame_buffer(&cm->post_proc_buffer);
vp9_free_frame_buffer(&cm->post_proc_buffer_int);
#endif
}
-void vp10_free_context_buffers(VP9_COMMON *cm) {
+void vp10_free_context_buffers(VP10_COMMON *cm) {
cm->free_mi(cm);
free_seg_map(cm);
vpx_free(cm->above_context);
cm->above_seg_context = NULL;
}
-int vp10_alloc_context_buffers(VP9_COMMON *cm, int width, int height) {
+int vp10_alloc_context_buffers(VP10_COMMON *cm, int width, int height) {
int new_mi_size;
vp10_set_mb_mi(cm, width, height);
return 1;
}
-void vp10_remove_common(VP9_COMMON *cm) {
+void vp10_remove_common(VP10_COMMON *cm) {
vp10_free_context_buffers(cm);
vpx_free(cm->fc);
cm->frame_contexts = NULL;
}
-void vp10_init_context_buffers(VP9_COMMON *cm) {
+void vp10_init_context_buffers(VP10_COMMON *cm) {
cm->setup_mi(cm);
if (cm->last_frame_seg_map && !cm->frame_parallel_decode)
memset(cm->last_frame_seg_map, 0, cm->mi_rows * cm->mi_cols);
}
-void vp10_swap_current_and_last_seg_map(VP9_COMMON *cm) {
+void vp10_swap_current_and_last_seg_map(VP10_COMMON *cm) {
// Swap indices.
const int tmp = cm->seg_map_idx;
cm->seg_map_idx = cm->prev_seg_map_idx;
#include "vp10/common/blockd.h"
#include "vp10/common/onyxc_int.h"
-static void log_frame_info(VP9_COMMON *cm, const char *str, FILE *f) {
+static void log_frame_info(VP10_COMMON *cm, const char *str, FILE *f) {
fprintf(f, "%s", str);
fprintf(f, "(Frame %d, Show:%d, Q:%d): \n", cm->current_video_frame,
cm->show_frame, cm->base_qindex);
* and uses the passed in member offset to print out the value of an integer
* for each mbmi member value in the mi structure.
*/
-static void print_mi_data(VP9_COMMON *cm, FILE *file, const char *descriptor,
+static void print_mi_data(VP10_COMMON *cm, FILE *file, const char *descriptor,
size_t member_offset) {
int mi_row, mi_col;
MODE_INFO **mi = cm->mi_grid_visible;
fprintf(file, "\n");
}
-void vp10_print_modes_and_motion_vectors(VP9_COMMON *cm, const char *file) {
+void vp10_print_modes_and_motion_vectors(VP10_COMMON *cm, const char *file) {
int mi_row;
int mi_col;
FILE *mvs = fopen(file, "a");
extend_to_full_distribution(&full[UNCONSTRAINED_NODES], model[PIVOT_NODE]);
}
-void vp10_default_coef_probs(VP9_COMMON *cm) {
+void vp10_default_coef_probs(VP10_COMMON *cm) {
vp10_copy(cm->fc->coef_probs[TX_4X4], default_coef_probs_4x4);
vp10_copy(cm->fc->coef_probs[TX_8X8], default_coef_probs_8x8);
vp10_copy(cm->fc->coef_probs[TX_16X16], default_coef_probs_16x16);
#define COEF_COUNT_SAT_AFTER_KEY 24
#define COEF_MAX_UPDATE_FACTOR_AFTER_KEY 128
-static void adapt_coef_probs(VP9_COMMON *cm, TX_SIZE tx_size,
+static void adapt_coef_probs(VP10_COMMON *cm, TX_SIZE tx_size,
unsigned int count_sat,
unsigned int update_factor) {
const FRAME_CONTEXT *pre_fc = &cm->frame_contexts[cm->frame_context_idx];
}
}
-void vp10_adapt_coef_probs(VP9_COMMON *cm) {
+void vp10_adapt_coef_probs(VP10_COMMON *cm) {
TX_SIZE t;
unsigned int count_sat, update_factor;
-EIGHTTAP_SMOOTH, -EIGHTTAP_SHARP
};
-void vp10_adapt_mode_probs(VP9_COMMON *cm) {
+void vp10_adapt_mode_probs(VP10_COMMON *cm) {
int i, j;
FRAME_CONTEXT *fc = cm->fc;
const FRAME_CONTEXT *pre_fc = &cm->frame_contexts[cm->frame_context_idx];
lf->mode_deltas[1] = 0;
}
-void vp10_setup_past_independence(VP9_COMMON *cm) {
+void vp10_setup_past_independence(VP10_COMMON *cm) {
// Reset the segment feature data to the default stats:
// Features disabled, 0, with delta coding (Default state).
struct loopfilter *const lf = &cm->lf;
}
}
-void vp10_adapt_mv_probs(VP9_COMMON *cm, int allow_hp) {
+void vp10_adapt_mv_probs(VP10_COMMON *cm, int allow_hp) {
int i, j;
nmv_context *fc = &cm->fc->nmvc;
}
}
-void vp10_init_mv_probs(VP9_COMMON *cm) {
+void vp10_init_mv_probs(VP10_COMMON *cm) {
cm->fc->nmvc = default_nmv_context;
}
[mode_lf_lut[mbmi->mode]];
}
-void vp10_loop_filter_init(VP9_COMMON *cm) {
+void vp10_loop_filter_init(VP10_COMMON *cm) {
loop_filter_info_n *lfi = &cm->lf_info;
struct loopfilter *lf = &cm->lf;
int lvl;
memset(lfi->lfthr[lvl].hev_thr, (lvl >> 4), SIMD_WIDTH);
}
-void vp10_loop_filter_frame_init(VP9_COMMON *cm, int default_filt_lvl) {
+void vp10_loop_filter_frame_init(VP10_COMMON *cm, int default_filt_lvl) {
int seg_id;
// n_shift is the multiplier for lf_deltas
// the multiplier is 1 for when filter_lvl is between 0 and 31;
// This function sets up the bit masks for the entire 64x64 region represented
// by mi_row, mi_col.
// TODO(JBB): This function only works for yv12.
-void vp10_setup_mask(VP9_COMMON *const cm, const int mi_row, const int mi_col,
+void vp10_setup_mask(VP10_COMMON *const cm, const int mi_row, const int mi_col,
MODE_INFO **mi, const int mode_info_stride,
LOOP_FILTER_MASK *lfm) {
int idx_32, idx_16, idx_8;
}
#endif // CONFIG_VP9_HIGHBITDEPTH
-void vp10_filter_block_plane_non420(VP9_COMMON *cm,
+void vp10_filter_block_plane_non420(VP10_COMMON *cm,
struct macroblockd_plane *plane,
MODE_INFO **mi_8x8,
int mi_row, int mi_col) {
}
}
-void vp10_filter_block_plane_ss00(VP9_COMMON *const cm,
+void vp10_filter_block_plane_ss00(VP10_COMMON *const cm,
struct macroblockd_plane *const plane,
int mi_row,
LOOP_FILTER_MASK *lfm) {
}
}
-void vp10_filter_block_plane_ss11(VP9_COMMON *const cm,
+void vp10_filter_block_plane_ss11(VP10_COMMON *const cm,
struct macroblockd_plane *const plane,
int mi_row,
LOOP_FILTER_MASK *lfm) {
}
void vp10_loop_filter_rows(YV12_BUFFER_CONFIG *frame_buffer,
- VP9_COMMON *cm,
+ VP10_COMMON *cm,
struct macroblockd_plane planes[MAX_MB_PLANE],
int start, int stop, int y_only) {
const int num_planes = y_only ? 1 : MAX_MB_PLANE;
}
void vp10_loop_filter_frame(YV12_BUFFER_CONFIG *frame,
- VP9_COMMON *cm, MACROBLOCKD *xd,
+ VP10_COMMON *cm, MACROBLOCKD *xd,
int frame_filter_level,
int y_only, int partial_frame) {
int start_mi_row, end_mi_row, mi_rows_to_filter;
}
// Process each partiton in a super block, recursively.
-static void mfqe_partition(VP9_COMMON *cm, MODE_INFO *mi, BLOCK_SIZE bs,
+static void mfqe_partition(VP10_COMMON *cm, MODE_INFO *mi, BLOCK_SIZE bs,
const uint8_t *y, const uint8_t *u,
const uint8_t *v, int y_stride, int uv_stride,
uint8_t *yd, uint8_t *ud, uint8_t *vd,
}
}
-void vp10_mfqe(VP9_COMMON *cm) {
+void vp10_mfqe(VP10_COMMON *cm) {
int mi_row, mi_col;
// Current decoded frame.
const YV12_BUFFER_CONFIG *show = cm->frame_to_show;
// This function searches the neighbourhood of a given MB/SB
// to try and find candidate reference vectors.
-static void find_mv_refs_idx(const VP9_COMMON *cm, const MACROBLOCKD *xd,
+static void find_mv_refs_idx(const VP10_COMMON *cm, const MACROBLOCKD *xd,
MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
int_mv *mv_ref_list,
int block, int mi_row, int mi_col,
clamp_mv_ref(&mv_ref_list[i].as_mv, xd);
}
-void vp10_find_mv_refs(const VP9_COMMON *cm, const MACROBLOCKD *xd,
+void vp10_find_mv_refs(const VP10_COMMON *cm, const MACROBLOCKD *xd,
MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
int_mv *mv_ref_list,
int mi_row, int mi_col,
*near_mv = mvlist[1];
}
-void vp10_append_sub8x8_mvs_for_idx(VP9_COMMON *cm, MACROBLOCKD *xd,
+void vp10_append_sub8x8_mvs_for_idx(VP10_COMMON *cm, MACROBLOCKD *xd,
int block, int ref, int mi_row, int mi_col,
int_mv *nearest_mv, int_mv *near_mv,
uint8_t *mode_context) {
}
typedef void (*find_mv_refs_sync)(void *const data, int mi_row);
-void vp10_find_mv_refs(const VP9_COMMON *cm, const MACROBLOCKD *xd,
+void vp10_find_mv_refs(const VP10_COMMON *cm, const MACROBLOCKD *xd,
MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
int_mv *mv_ref_list, int mi_row, int mi_col,
find_mv_refs_sync sync, void *const data,
void vp10_find_best_ref_mvs(MACROBLOCKD *xd, int allow_hp,
int_mv *mvlist, int_mv *nearest_mv, int_mv *near_mv);
-void vp10_append_sub8x8_mvs_for_idx(VP9_COMMON *cm, MACROBLOCKD *xd,
+void vp10_append_sub8x8_mvs_for_idx(VP10_COMMON *cm, MACROBLOCKD *xd,
int block, int ref, int mi_row, int mi_col,
int_mv *nearest_mv, int_mv *near_mv,
uint8_t *mode_context);
PARTITION_CONTEXT *above_seg_context;
ENTROPY_CONTEXT *above_context;
int above_context_alloc_cols;
-} VP9_COMMON;
+} VP10_COMMON;
// TODO(hkuang): Don't need to lock the whole pool after implementing atomic
// frame reference count.
#endif
}
-static INLINE YV12_BUFFER_CONFIG *get_ref_frame(VP9_COMMON *cm, int index) {
+static INLINE YV12_BUFFER_CONFIG *get_ref_frame(VP10_COMMON *cm, int index) {
if (index < 0 || index >= REF_FRAMES)
return NULL;
if (cm->ref_frame_map[index] < 0)
return &cm->buffer_pool->frame_bufs[cm->ref_frame_map[index]].buf;
}
-static INLINE YV12_BUFFER_CONFIG *get_frame_new_buffer(VP9_COMMON *cm) {
+static INLINE YV12_BUFFER_CONFIG *get_frame_new_buffer(VP10_COMMON *cm) {
return &cm->buffer_pool->frame_bufs[cm->new_fb_idx].buf;
}
-static INLINE int get_free_fb(VP9_COMMON *cm) {
+static INLINE int get_free_fb(VP10_COMMON *cm) {
RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
int i;
return ALIGN_POWER_OF_TWO(n_mis, MI_BLOCK_SIZE_LOG2);
}
-static INLINE int frame_is_intra_only(const VP9_COMMON *const cm) {
+static INLINE int frame_is_intra_only(const VP10_COMMON *const cm) {
return cm->frame_type == KEY_FRAME || cm->intra_only;
}
-static INLINE void set_partition_probs(const VP9_COMMON *const cm,
+static INLINE void set_partition_probs(const VP10_COMMON *const cm,
MACROBLOCKD *const xd) {
xd->partition_probs =
frame_is_intra_only(cm) ?
(const vpx_prob (*)[PARTITION_TYPES - 1])cm->fc->partition_prob;
}
-static INLINE void vp10_init_macroblockd(VP9_COMMON *cm, MACROBLOCKD *xd,
+static INLINE void vp10_init_macroblockd(VP10_COMMON *cm, MACROBLOCKD *xd,
tran_low_t *dqcoeff) {
int i;
}
}
-static void swap_mi_and_prev_mi(VP9_COMMON *cm) {
+static void swap_mi_and_prev_mi(VP10_COMMON *cm) {
// Current mip will be the prev_mip for the next frame.
MODE_INFO *temp = cm->postproc_state.prev_mip;
cm->postproc_state.prev_mip = cm->mip;
}
}
-int vp10_get_reference_mode_context(const VP9_COMMON *cm,
+int vp10_get_reference_mode_context(const VP10_COMMON *cm,
const MACROBLOCKD *xd) {
int ctx;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
}
// Returns a context number for the given MB prediction signal
-int vp10_get_pred_context_comp_ref_p(const VP9_COMMON *cm,
+int vp10_get_pred_context_comp_ref_p(const VP10_COMMON *cm,
const MACROBLOCKD *xd) {
int pred_context;
const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
extern "C" {
#endif
-static INLINE int get_segment_id(const VP9_COMMON *cm,
+static INLINE int get_segment_id(const VP10_COMMON *cm,
const uint8_t *segment_ids,
BLOCK_SIZE bsize, int mi_row, int mi_col) {
const int mi_offset = mi_row * cm->mi_cols + mi_col;
return above_skip + left_skip;
}
-static INLINE vpx_prob vp10_get_skip_prob(const VP9_COMMON *cm,
+static INLINE vpx_prob vp10_get_skip_prob(const VP10_COMMON *cm,
const MACROBLOCKD *xd) {
return cm->fc->skip_probs[vp10_get_skip_context(xd)];
}
int vp10_get_intra_inter_context(const MACROBLOCKD *xd);
-static INLINE vpx_prob vp10_get_intra_inter_prob(const VP9_COMMON *cm,
+static INLINE vpx_prob vp10_get_intra_inter_prob(const VP10_COMMON *cm,
const MACROBLOCKD *xd) {
return cm->fc->intra_inter_prob[vp10_get_intra_inter_context(xd)];
}
-int vp10_get_reference_mode_context(const VP9_COMMON *cm, const MACROBLOCKD *xd);
+int vp10_get_reference_mode_context(const VP10_COMMON *cm,
+ const MACROBLOCKD *xd);
-static INLINE vpx_prob vp10_get_reference_mode_prob(const VP9_COMMON *cm,
+static INLINE vpx_prob vp10_get_reference_mode_prob(const VP10_COMMON *cm,
const MACROBLOCKD *xd) {
return cm->fc->comp_inter_prob[vp10_get_reference_mode_context(cm, xd)];
}
-int vp10_get_pred_context_comp_ref_p(const VP9_COMMON *cm,
+int vp10_get_pred_context_comp_ref_p(const VP10_COMMON *cm,
const MACROBLOCKD *xd);
-static INLINE vpx_prob vp10_get_pred_prob_comp_ref_p(const VP9_COMMON *cm,
+static INLINE vpx_prob vp10_get_pred_prob_comp_ref_p(const VP10_COMMON *cm,
const MACROBLOCKD *xd) {
const int pred_context = vp10_get_pred_context_comp_ref_p(cm, xd);
return cm->fc->comp_ref_prob[pred_context];
int vp10_get_pred_context_single_ref_p1(const MACROBLOCKD *xd);
-static INLINE vpx_prob vp10_get_pred_prob_single_ref_p1(const VP9_COMMON *cm,
+static INLINE vpx_prob vp10_get_pred_prob_single_ref_p1(const VP10_COMMON *cm,
const MACROBLOCKD *xd) {
return cm->fc->single_ref_prob[vp10_get_pred_context_single_ref_p1(xd)][0];
}
int vp10_get_pred_context_single_ref_p2(const MACROBLOCKD *xd);
-static INLINE vpx_prob vp10_get_pred_prob_single_ref_p2(const VP9_COMMON *cm,
+static INLINE vpx_prob vp10_get_pred_prob_single_ref_p2(const VP10_COMMON *cm,
const MACROBLOCKD *xd) {
return cm->fc->single_ref_prob[vp10_get_pred_context_single_ref_p2(xd)][1];
}
// Implement row loopfiltering for each thread.
static INLINE
void thread_loop_filter_rows(const YV12_BUFFER_CONFIG *const frame_buffer,
- VP9_COMMON *const cm,
+ VP10_COMMON *const cm,
struct macroblockd_plane planes[MAX_MB_PLANE],
int start, int stop, int y_only,
VP9LfSync *const lf_sync) {
}
static void loop_filter_rows_mt(YV12_BUFFER_CONFIG *frame,
- VP9_COMMON *cm,
+ VP10_COMMON *cm,
struct macroblockd_plane planes[MAX_MB_PLANE],
int start, int stop, int y_only,
VPxWorker *workers, int nworkers,
}
void vp10_loop_filter_frame_mt(YV12_BUFFER_CONFIG *frame,
- VP9_COMMON *cm,
+ VP10_COMMON *cm,
struct macroblockd_plane planes[MAX_MB_PLANE],
int frame_filter_level,
int y_only, int partial_frame,
}
// Allocate memory for lf row synchronization
-void vp10_loop_filter_alloc(VP9LfSync *lf_sync, VP9_COMMON *cm, int rows,
+void vp10_loop_filter_alloc(VP9LfSync *lf_sync, VP10_COMMON *cm, int rows,
int width, int num_workers) {
lf_sync->rows = rows;
#if CONFIG_MULTITHREAD
}
// Accumulate frame counts.
-void vp10_accumulate_frame_counts(VP9_COMMON *cm, FRAME_COUNTS *counts,
+void vp10_accumulate_frame_counts(VP10_COMMON *cm, FRAME_COUNTS *counts,
int is_dec) {
int i, j, k, l, m;
return MIN(offset, mis);
}
-void vp10_tile_set_row(TileInfo *tile, const VP9_COMMON *cm, int row) {
+void vp10_tile_set_row(TileInfo *tile, const VP10_COMMON *cm, int row) {
tile->mi_row_start = get_tile_offset(row, cm->mi_rows, cm->log2_tile_rows);
tile->mi_row_end = get_tile_offset(row + 1, cm->mi_rows, cm->log2_tile_rows);
}
-void vp10_tile_set_col(TileInfo *tile, const VP9_COMMON *cm, int col) {
+void vp10_tile_set_col(TileInfo *tile, const VP10_COMMON *cm, int col) {
tile->mi_col_start = get_tile_offset(col, cm->mi_cols, cm->log2_tile_cols);
tile->mi_col_end = get_tile_offset(col + 1, cm->mi_cols, cm->log2_tile_cols);
}
-void vp10_tile_init(TileInfo *tile, const VP9_COMMON *cm, int row, int col) {
+void vp10_tile_init(TileInfo *tile, const VP10_COMMON *cm, int row, int col) {
vp10_tile_set_row(tile, cm, row);
vp10_tile_set_col(tile, cm, col);
}
#define MAX_VP9_HEADER_SIZE 80
-static int is_compound_reference_allowed(const VP9_COMMON *cm) {
+static int is_compound_reference_allowed(const VP10_COMMON *cm) {
int i;
for (i = 1; i < REFS_PER_FRAME; ++i)
if (cm->ref_frame_sign_bias[i + 1] != cm->ref_frame_sign_bias[1])
return 0;
}
-static void setup_compound_reference_mode(VP9_COMMON *cm) {
+static void setup_compound_reference_mode(VP10_COMMON *cm) {
if (cm->ref_frame_sign_bias[LAST_FRAME] ==
cm->ref_frame_sign_bias[GOLDEN_FRAME]) {
cm->comp_fixed_ref = ALTREF_FRAME;
vp10_diff_update_prob(r, &fc->inter_mode_probs[i][j]);
}
-static REFERENCE_MODE read_frame_reference_mode(const VP9_COMMON *cm,
+static REFERENCE_MODE read_frame_reference_mode(const VP10_COMMON *cm,
vpx_reader *r) {
if (is_compound_reference_allowed(cm)) {
return vpx_read_bit(r) ? (vpx_read_bit(r) ? REFERENCE_MODE_SELECT
}
}
-static void read_frame_reference_mode_probs(VP9_COMMON *cm, vpx_reader *r) {
+static void read_frame_reference_mode_probs(VP10_COMMON *cm, vpx_reader *r) {
FRAME_CONTEXT *const fc = cm->fc;
int i;
}
}
-static MB_MODE_INFO *set_offsets(VP9_COMMON *const cm, MACROBLOCKD *const xd,
+static MB_MODE_INFO *set_offsets(VP10_COMMON *const cm, MACROBLOCKD *const xd,
BLOCK_SIZE bsize, int mi_row, int mi_col,
int bw, int bh, int x_mis, int y_mis,
int bwl, int bhl) {
int mi_row, int mi_col,
vpx_reader *r, BLOCK_SIZE bsize,
int bwl, int bhl) {
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
const int less8x8 = bsize < BLOCK_8X8;
const int bw = 1 << (bwl - 1);
const int bh = 1 << (bhl - 1);
static void decode_partition(VP9Decoder *const pbi, MACROBLOCKD *const xd,
int mi_row, int mi_col,
vpx_reader* r, BLOCK_SIZE bsize, int n4x4_l2) {
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
const int n8x8_l2 = n4x4_l2 - 1;
const int num_8x8_wh = 1 << n8x8_l2;
const int hbs = num_8x8_wh >> 1;
return vpx_rb_read_bit(rb) ? vpx_rb_read_signed_literal(rb, 4) : 0;
}
-static void setup_quantization(VP9_COMMON *const cm, MACROBLOCKD *const xd,
+static void setup_quantization(VP10_COMMON *const cm, MACROBLOCKD *const xd,
struct vpx_read_bit_buffer *rb) {
cm->base_qindex = vpx_rb_read_literal(rb, QINDEX_BITS);
cm->y_dc_delta_q = read_delta_q(rb);
#endif
}
-static void setup_segmentation_dequant(VP9_COMMON *const cm) {
+static void setup_segmentation_dequant(VP10_COMMON *const cm) {
// Build y/uv dequant values based on segmentation.
if (cm->seg.enabled) {
int i;
: literal_to_filter[vpx_rb_read_literal(rb, 2)];
}
-static void setup_display_size(VP9_COMMON *cm, struct vpx_read_bit_buffer *rb) {
+static void setup_display_size(VP10_COMMON *cm,
+ struct vpx_read_bit_buffer *rb) {
cm->display_width = cm->width;
cm->display_height = cm->height;
if (vpx_rb_read_bit(rb))
vp10_read_frame_size(rb, &cm->display_width, &cm->display_height);
}
-static void resize_mv_buffer(VP9_COMMON *cm) {
+static void resize_mv_buffer(VP10_COMMON *cm) {
vpx_free(cm->cur_frame->mvs);
cm->cur_frame->mi_rows = cm->mi_rows;
cm->cur_frame->mi_cols = cm->mi_cols;
sizeof(*cm->cur_frame->mvs));
}
-static void resize_context_buffers(VP9_COMMON *cm, int width, int height) {
+static void resize_context_buffers(VP10_COMMON *cm, int width, int height) {
#if CONFIG_SIZE_LIMIT
if (width > DECODE_WIDTH_LIMIT || height > DECODE_HEIGHT_LIMIT)
vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME,
}
}
-static void setup_frame_size(VP9_COMMON *cm, struct vpx_read_bit_buffer *rb) {
+static void setup_frame_size(VP10_COMMON *cm, struct vpx_read_bit_buffer *rb) {
int width, height;
BufferPool *const pool = cm->buffer_pool;
vp10_read_frame_size(rb, &width, &height);
ref_yss == this_yss;
}
-static void setup_frame_size_with_refs(VP9_COMMON *cm,
+static void setup_frame_size_with_refs(VP10_COMMON *cm,
struct vpx_read_bit_buffer *rb) {
int width, height;
int found = 0, i;
pool->frame_bufs[cm->new_fb_idx].buf.color_space = cm->color_space;
}
-static void setup_tile_info(VP9_COMMON *cm, struct vpx_read_bit_buffer *rb) {
+static void setup_tile_info(VP10_COMMON *cm, struct vpx_read_bit_buffer *rb) {
int min_log2_tile_cols, max_log2_tile_cols, max_ones;
vp10_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
static const uint8_t *decode_tiles(VP9Decoder *pbi,
const uint8_t *data,
const uint8_t *data_end) {
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
const VPxWorkerInterface *const winterface = vpx_get_worker_interface();
const int aligned_cols = mi_cols_aligned_to_sb(cm->mi_cols);
const int tile_cols = 1 << cm->log2_tile_cols;
static const uint8_t *decode_tiles_mt(VP9Decoder *pbi,
const uint8_t *data,
const uint8_t *data_end) {
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
const VPxWorkerInterface *const winterface = vpx_get_worker_interface();
const uint8_t *bit_reader_end = NULL;
const int aligned_mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
}
static void error_handler(void *data) {
- VP9_COMMON *const cm = (VP9_COMMON *)data;
+ VP10_COMMON *const cm = (VP10_COMMON *)data;
vpx_internal_error(&cm->error, VPX_CODEC_CORRUPT_FRAME, "Truncated packet");
}
static void read_bitdepth_colorspace_sampling(
- VP9_COMMON *cm, struct vpx_read_bit_buffer *rb) {
+ VP10_COMMON *cm, struct vpx_read_bit_buffer *rb) {
if (cm->profile >= PROFILE_2) {
cm->bit_depth = vpx_rb_read_bit(rb) ? VPX_BITS_12 : VPX_BITS_10;
#if CONFIG_VP9_HIGHBITDEPTH
static size_t read_uncompressed_header(VP9Decoder *pbi,
struct vpx_read_bit_buffer *rb) {
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
BufferPool *const pool = cm->buffer_pool;
RefCntBuffer *const frame_bufs = pool->frame_bufs;
int i, mask, ref_index = 0;
static int read_compressed_header(VP9Decoder *pbi, const uint8_t *data,
size_t partition_size) {
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
MACROBLOCKD *const xd = &pbi->mb;
FRAME_CONTEXT *const fc = cm->fc;
vpx_reader r;
#else // !NDEBUG
// Counts should only be incremented when frame_parallel_decoding_mode and
// error_resilient_mode are disabled.
-static void debug_check_frame_counts(const VP9_COMMON *const cm) {
+static void debug_check_frame_counts(const VP10_COMMON *const cm) {
FRAME_COUNTS zero_counts;
vp10_zero(zero_counts);
assert(cm->frame_parallel_decoding_mode || cm->error_resilient_mode);
void vp10_decode_frame(VP9Decoder *pbi,
const uint8_t *data, const uint8_t *data_end,
const uint8_t **p_data_end) {
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
MACROBLOCKD *const xd = &pbi->mb;
struct vpx_read_bit_buffer rb;
int context_updated = 0;
return (PREDICTION_MODE)vpx_read_tree(r, vp10_intra_mode_tree, p);
}
-static PREDICTION_MODE read_intra_mode_y(VP9_COMMON *cm, MACROBLOCKD *xd,
+static PREDICTION_MODE read_intra_mode_y(VP10_COMMON *cm, MACROBLOCKD *xd,
vpx_reader *r, int size_group) {
const PREDICTION_MODE y_mode =
read_intra_mode(r, cm->fc->y_mode_prob[size_group]);
return y_mode;
}
-static PREDICTION_MODE read_intra_mode_uv(VP9_COMMON *cm, MACROBLOCKD *xd,
+static PREDICTION_MODE read_intra_mode_uv(VP10_COMMON *cm, MACROBLOCKD *xd,
vpx_reader *r,
PREDICTION_MODE y_mode) {
const PREDICTION_MODE uv_mode = read_intra_mode(r,
return uv_mode;
}
-static PREDICTION_MODE read_inter_mode(VP9_COMMON *cm, MACROBLOCKD *xd,
+static PREDICTION_MODE read_inter_mode(VP10_COMMON *cm, MACROBLOCKD *xd,
vpx_reader *r, int ctx) {
const int mode = vpx_read_tree(r, vp10_inter_mode_tree,
cm->fc->inter_mode_probs[ctx]);
return vpx_read_tree(r, vp10_segment_tree, seg->tree_probs);
}
-static TX_SIZE read_selected_tx_size(VP9_COMMON *cm, MACROBLOCKD *xd,
+static TX_SIZE read_selected_tx_size(VP10_COMMON *cm, MACROBLOCKD *xd,
TX_SIZE max_tx_size, vpx_reader *r) {
FRAME_COUNTS *counts = xd->counts;
const int ctx = get_tx_size_context(xd);
return (TX_SIZE)tx_size;
}
-static TX_SIZE read_tx_size(VP9_COMMON *cm, MACROBLOCKD *xd,
+static TX_SIZE read_tx_size(VP10_COMMON *cm, MACROBLOCKD *xd,
int allow_select, vpx_reader *r) {
TX_MODE tx_mode = cm->tx_mode;
BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
return MIN(max_tx_size, tx_mode_to_biggest_tx_size[tx_mode]);
}
-static int dec_get_segment_id(const VP9_COMMON *cm, const uint8_t *segment_ids,
+static int dec_get_segment_id(const VP10_COMMON *cm, const uint8_t *segment_ids,
int mi_offset, int x_mis, int y_mis) {
int x, y, segment_id = INT_MAX;
return segment_id;
}
-static void set_segment_id(VP9_COMMON *cm, int mi_offset,
+static void set_segment_id(VP10_COMMON *cm, int mi_offset,
int x_mis, int y_mis, int segment_id) {
int x, y;
cm->current_frame_seg_map[mi_offset + y * cm->mi_cols + x] = segment_id;
}
-static void copy_segment_id(const VP9_COMMON *cm,
+static void copy_segment_id(const VP10_COMMON *cm,
const uint8_t *last_segment_ids,
uint8_t *current_segment_ids,
int mi_offset, int x_mis, int y_mis) {
last_segment_ids[mi_offset + y * cm->mi_cols + x] : 0;
}
-static int read_intra_segment_id(VP9_COMMON *const cm, int mi_offset,
+static int read_intra_segment_id(VP10_COMMON *const cm, int mi_offset,
int x_mis, int y_mis,
vpx_reader *r) {
struct segmentation *const seg = &cm->seg;
return segment_id;
}
-static int read_inter_segment_id(VP9_COMMON *const cm, MACROBLOCKD *const xd,
+static int read_inter_segment_id(VP10_COMMON *const cm, MACROBLOCKD *const xd,
int mi_row, int mi_col, vpx_reader *r) {
struct segmentation *const seg = &cm->seg;
MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
return segment_id;
}
-static int read_skip(VP9_COMMON *cm, const MACROBLOCKD *xd,
+static int read_skip(VP10_COMMON *cm, const MACROBLOCKD *xd,
int segment_id, vpx_reader *r) {
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
return 1;
}
}
-static void read_intra_frame_mode_info(VP9_COMMON *const cm,
+static void read_intra_frame_mode_info(VP10_COMMON *const cm,
MACROBLOCKD *const xd,
int mi_row, int mi_col, vpx_reader *r) {
MODE_INFO *const mi = xd->mi[0];
mv->col = ref->col + diff.col;
}
-static REFERENCE_MODE read_block_reference_mode(VP9_COMMON *cm,
+static REFERENCE_MODE read_block_reference_mode(VP10_COMMON *cm,
const MACROBLOCKD *xd,
vpx_reader *r) {
if (cm->reference_mode == REFERENCE_MODE_SELECT) {
}
// Read the referncence frame
-static void read_ref_frames(VP9_COMMON *const cm, MACROBLOCKD *const xd,
+static void read_ref_frames(VP10_COMMON *const cm, MACROBLOCKD *const xd,
vpx_reader *r,
int segment_id, MV_REFERENCE_FRAME ref_frame[2]) {
FRAME_CONTEXT *const fc = cm->fc;
static INLINE INTERP_FILTER read_switchable_interp_filter(
- VP9_COMMON *const cm, MACROBLOCKD *const xd,
+ VP10_COMMON *const cm, MACROBLOCKD *const xd,
vpx_reader *r) {
const int ctx = vp10_get_pred_context_switchable_interp(xd);
const INTERP_FILTER type =
return type;
}
-static void read_intra_block_mode_info(VP9_COMMON *const cm,
+static void read_intra_block_mode_info(VP10_COMMON *const cm,
MACROBLOCKD *const xd, MODE_INFO *mi,
vpx_reader *r) {
MB_MODE_INFO *const mbmi = &mi->mbmi;
mv->col > MV_LOW && mv->col < MV_UPP;
}
-static INLINE int assign_mv(VP9_COMMON *cm, MACROBLOCKD *xd,
+static INLINE int assign_mv(VP10_COMMON *cm, MACROBLOCKD *xd,
PREDICTION_MODE mode,
int_mv mv[2], int_mv ref_mv[2],
int_mv nearest_mv[2], int_mv near_mv[2],
return ret;
}
-static int read_is_inter_block(VP9_COMMON *const cm, MACROBLOCKD *const xd,
+static int read_is_inter_block(VP10_COMMON *const cm, MACROBLOCKD *const xd,
int segment_id, vpx_reader *r) {
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
return get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME) != INTRA_FRAME;
MACROBLOCKD *const xd,
MODE_INFO *const mi,
int mi_row, int mi_col, vpx_reader *r) {
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
MB_MODE_INFO *const mbmi = &mi->mbmi;
const BLOCK_SIZE bsize = mbmi->sb_type;
const int allow_hp = cm->allow_high_precision_mv;
static void read_inter_frame_mode_info(VP9Decoder *const pbi,
MACROBLOCKD *const xd,
int mi_row, int mi_col, vpx_reader *r) {
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
MODE_INFO *const mi = xd->mi[0];
MB_MODE_INFO *const mbmi = &mi->mbmi;
int inter_block;
void vp10_read_mode_info(VP9Decoder *const pbi, MACROBLOCKD *xd,
int mi_row, int mi_col, vpx_reader *r,
int x_mis, int y_mis) {
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
MODE_INFO *const mi = xd->mi[0];
MV_REF* frame_mvs = cm->cur_frame->mvs + mi_row * cm->mi_cols + mi_col;
int w, h;
}
}
-static void vp10_dec_setup_mi(VP9_COMMON *cm) {
+static void vp10_dec_setup_mi(VP10_COMMON *cm) {
cm->mi = cm->mip + cm->mi_stride + 1;
cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1;
memset(cm->mi_grid_base, 0,
cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mi_grid_base));
}
-static int vp10_dec_alloc_mi(VP9_COMMON *cm, int mi_size) {
+static int vp10_dec_alloc_mi(VP10_COMMON *cm, int mi_size) {
cm->mip = vpx_calloc(mi_size, sizeof(*cm->mip));
if (!cm->mip)
return 1;
return 0;
}
-static void vp10_dec_free_mi(VP9_COMMON *cm) {
+static void vp10_dec_free_mi(VP10_COMMON *cm) {
vpx_free(cm->mip);
cm->mip = NULL;
vpx_free(cm->mi_grid_base);
VP9Decoder *vp10_decoder_create(BufferPool *const pool) {
VP9Decoder *volatile const pbi = vpx_memalign(32, sizeof(*pbi));
- VP9_COMMON *volatile const cm = pbi ? &pbi->common : NULL;
+ VP10_COMMON *volatile const cm = pbi ? &pbi->common : NULL;
if (!cm)
return NULL;
vpx_codec_err_t vp10_copy_reference_dec(VP9Decoder *pbi,
VP9_REFFRAME ref_frame_flag,
YV12_BUFFER_CONFIG *sd) {
- VP9_COMMON *cm = &pbi->common;
+ VP10_COMMON *cm = &pbi->common;
/* TODO(jkoleszar): The decoder doesn't have any real knowledge of what the
* encoder is using the frame buffers for. This is just a stub to keep the
}
-vpx_codec_err_t vp10_set_reference_dec(VP9_COMMON *cm,
+vpx_codec_err_t vp10_set_reference_dec(VP10_COMMON *cm,
VP9_REFFRAME ref_frame_flag,
YV12_BUFFER_CONFIG *sd) {
RefBuffer *ref_buf = NULL;
/* If any buffer updating is signaled it should be done here. */
static void swap_frame_buffers(VP9Decoder *pbi) {
int ref_index = 0, mask;
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
BufferPool *const pool = cm->buffer_pool;
RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
int vp10_receive_compressed_data(VP9Decoder *pbi,
size_t size, const uint8_t **psource) {
- VP9_COMMON *volatile const cm = &pbi->common;
+ VP10_COMMON *volatile const cm = &pbi->common;
BufferPool *volatile const pool = cm->buffer_pool;
RefCntBuffer *volatile const frame_bufs = cm->buffer_pool->frame_bufs;
const uint8_t *source = *psource;
int vp10_get_raw_frame(VP9Decoder *pbi, YV12_BUFFER_CONFIG *sd,
vp10_ppflags_t *flags) {
- VP9_COMMON *const cm = &pbi->common;
+ VP10_COMMON *const cm = &pbi->common;
int ret = -1;
#if !CONFIG_VP9_POSTPROC
(void)*flags;
// TODO(hkuang): combine this with TileWorkerData.
typedef struct TileData {
- VP9_COMMON *cm;
+ VP10_COMMON *cm;
vpx_reader bit_reader;
DECLARE_ALIGNED(16, MACROBLOCKD, xd);
/* dqcoeff are shared by all the planes. So planes must be decoded serially */
typedef struct VP9Decoder {
DECLARE_ALIGNED(16, MACROBLOCKD, mb);
- DECLARE_ALIGNED(16, VP9_COMMON, common);
+ DECLARE_ALIGNED(16, VP10_COMMON, common);
int ready_for_new_data;
VP9_REFFRAME ref_frame_flag,
YV12_BUFFER_CONFIG *sd);
-vpx_codec_err_t vp10_set_reference_dec(VP9_COMMON *cm,
+vpx_codec_err_t vp10_set_reference_dec(VP10_COMMON *cm,
VP9_REFFRAME ref_frame_flag,
YV12_BUFFER_CONFIG *sd);
#if CONFIG_MULTITHREAD
FrameWorkerData *const src_worker_data = (FrameWorkerData *)src_worker->data1;
FrameWorkerData *const dst_worker_data = (FrameWorkerData *)dst_worker->data1;
- VP9_COMMON *const src_cm = &src_worker_data->pbi->common;
- VP9_COMMON *const dst_cm = &dst_worker_data->pbi->common;
+ VP10_COMMON *const src_cm = &src_worker_data->pbi->common;
+ VP10_COMMON *const dst_cm = &dst_worker_data->pbi->common;
int i;
// Wait until source frame's context is ready.
}
void vp10_setup_in_frame_q_adj(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
struct segmentation *const seg = &cm->seg;
// Make SURE use of floating point in this function is safe.
// bits for the block vs a target average and its spatial complexity.
void vp10_caq_select_segment(VP9_COMP *cpi, MACROBLOCK *mb, BLOCK_SIZE bs,
int mi_row, int mi_col, int projected_rate) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const int mi_offset = mi_row * cm->mi_cols + mi_col;
const int bw = num_8x8_blocks_wide_lookup[BLOCK_64X64];
}
// Check if we should turn off cyclic refresh based on bitrate condition.
-static int apply_cyclic_refresh_bitrate(const VP9_COMMON *cm,
+static int apply_cyclic_refresh_bitrate(const VP10_COMMON *cm,
const RATE_CONTROL *rc) {
// Turn off cyclic refresh if bits available per frame is not sufficiently
// larger than bit cost of segmentation. Segment map bit cost should scale
// (called from rc_update_rate_correction_factors()).
int vp10_cyclic_refresh_estimate_bits_at_q(const VP9_COMP *cpi,
double correction_factor) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
int estimated_bits;
int mbs = cm->MBs;
// to 1/CR_SEGMENT_ID_BOOST1 (refresh) for each superblock, prior to encoding.
int vp10_cyclic_refresh_rc_bits_per_mb(const VP9_COMP *cpi, int i,
double correction_factor) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
int bits_per_mb;
int num8x8bl = cm->MBs << 2;
int64_t rate,
int64_t dist,
int skip) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
const int bw = num_8x8_blocks_wide_lookup[bsize];
const int bh = num_8x8_blocks_high_lookup[bsize];
// Update the actual number of blocks that were applied the segment delta q.
void vp10_cyclic_refresh_postencode(VP9_COMP *const cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
unsigned char *const seg_map = cpi->segmentation_map;
int mi_row, mi_col;
// golden reference is to be updated check if we should NOT update the golden
// ref.
void vp10_cyclic_refresh_check_golden_update(VP9_COMP *const cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
int mi_row, mi_col;
double fraction_low = 0.0;
// Blocks labeled as BOOST1 may later get set to BOOST2 (during the
// encoding of the superblock).
static void cyclic_refresh_update_map(VP9_COMP *const cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
unsigned char *const seg_map = cpi->segmentation_map;
int i, block_count, bl_index, sb_rows, sb_cols, sbs_in_frame;
// Set cyclic refresh parameters.
void vp10_cyclic_refresh_update_parameters(VP9_COMP *const cpi) {
const RATE_CONTROL *const rc = &cpi->rc;
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
cr->percent_refresh = 10;
cr->max_qdelta_perc = 50;
// Setup cyclic background refresh: set delta q and segmentation map.
void vp10_cyclic_refresh_setup(VP9_COMP *const cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const RATE_CONTROL *const rc = &cpi->rc;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
struct segmentation *const seg = &cm->seg;
}
void vp10_cyclic_refresh_reset_resize(VP9_COMP *const cpi) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
memset(cr->map, 0, cm->mi_rows * cm->mi_cols);
cr->sb_index = 0;
}
void vp10_vaq_frame_setup(VP9_COMP *cpi) {
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
struct segmentation *seg = &cm->seg;
int i;
vp10_cond_prob_diff_update(w, &probs[i], branch_ct[i]);
}
-static void write_selected_tx_size(const VP9_COMMON *cm,
+static void write_selected_tx_size(const VP10_COMMON *cm,
const MACROBLOCKD *xd, vpx_writer *w) {
TX_SIZE tx_size = xd->mi[0]->mbmi.tx_size;
BLOCK_SIZE bsize = xd->mi[0]->mbmi.sb_type;
}
}
-static int write_skip(const VP9_COMMON *cm, const MACROBLOCKD *xd,
+static int write_skip(const VP10_COMMON *cm, const MACROBLOCKD *xd,
int segment_id, const MODE_INFO *mi, vpx_writer *w) {
if (segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
return 1;
}
}
-static void update_skip_probs(VP9_COMMON *cm, vpx_writer *w,
+static void update_skip_probs(VP10_COMMON *cm, vpx_writer *w,
FRAME_COUNTS *counts) {
int k;
vp10_cond_prob_diff_update(w, &cm->fc->skip_probs[k], counts->skip[k]);
}
-static void update_switchable_interp_probs(VP9_COMMON *cm, vpx_writer *w,
+static void update_switchable_interp_probs(VP10_COMMON *cm, vpx_writer *w,
FRAME_COUNTS *counts) {
int j;
for (j = 0; j < SWITCHABLE_FILTER_CONTEXTS; ++j)
}
// This function encodes the reference frame
-static void write_ref_frames(const VP9_COMMON *cm, const MACROBLOCKD *xd,
+static void write_ref_frames(const VP10_COMMON *cm, const MACROBLOCKD *xd,
vpx_writer *w) {
const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
const int is_compound = has_second_ref(mbmi);
static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
vpx_writer *w) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const nmv_context *nmvc = &cm->fc->nmvc;
const MACROBLOCK *const x = &cpi->td.mb;
const MACROBLOCKD *const xd = &x->e_mbd;
}
}
-static void write_mb_modes_kf(const VP9_COMMON *cm, const MACROBLOCKD *xd,
+static void write_mb_modes_kf(const VP10_COMMON *cm, const MACROBLOCKD *xd,
MODE_INFO **mi_8x8, vpx_writer *w) {
const struct segmentation *const seg = &cm->seg;
const MODE_INFO *const mi = mi_8x8[0];
vpx_writer *w, TOKENEXTRA **tok,
const TOKENEXTRA *const tok_end,
int mi_row, int mi_col) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
MODE_INFO *m;
pack_mb_tokens(w, tok, tok_end, cm->bit_depth);
}
-static void write_partition(const VP9_COMMON *const cm,
+static void write_partition(const VP10_COMMON *const cm,
const MACROBLOCKD *const xd,
int hbs, int mi_row, int mi_col,
PARTITION_TYPE p, BLOCK_SIZE bsize, vpx_writer *w) {
const TileInfo *const tile, vpx_writer *w,
TOKENEXTRA **tok, const TOKENEXTRA *const tok_end,
int mi_row, int mi_col, BLOCK_SIZE bsize) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
const int bsl = b_width_log2_lookup[bsize];
static void write_modes(VP9_COMP *cpi,
const TileInfo *const tile, vpx_writer *w,
TOKENEXTRA **tok, const TOKENEXTRA *const tok_end) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
int mi_row, mi_col;
}
}
-static void encode_quantization(const VP9_COMMON *const cm,
+static void encode_quantization(const VP10_COMMON *const cm,
struct vpx_write_bit_buffer *wb) {
vpx_wb_write_literal(wb, cm->base_qindex, QINDEX_BITS);
write_delta_q(wb, cm->y_dc_delta_q);
write_delta_q(wb, cm->uv_ac_delta_q);
}
-static void encode_segmentation(VP9_COMMON *cm, MACROBLOCKD *xd,
+static void encode_segmentation(VP10_COMMON *cm, MACROBLOCKD *xd,
struct vpx_write_bit_buffer *wb) {
int i, j;
}
}
-static void encode_txfm_probs(VP9_COMMON *cm, vpx_writer *w,
+static void encode_txfm_probs(VP10_COMMON *cm, vpx_writer *w,
FRAME_COUNTS *counts) {
// Mode
vpx_write_literal(w, MIN(cm->tx_mode, ALLOW_32X32), 2);
vpx_wb_write_literal(wb, filter_to_literal[filter], 2);
}
-static void fix_interp_filter(VP9_COMMON *cm, FRAME_COUNTS *counts) {
+static void fix_interp_filter(VP10_COMMON *cm, FRAME_COUNTS *counts) {
if (cm->interp_filter == SWITCHABLE) {
// Check to see if only one of the filters is actually used
int count[SWITCHABLE_FILTERS];
}
}
-static void write_tile_info(const VP9_COMMON *const cm,
+static void write_tile_info(const VP10_COMMON *const cm,
struct vpx_write_bit_buffer *wb) {
int min_log2_tile_cols, max_log2_tile_cols, ones;
vp10_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
}
static size_t encode_tiles(VP9_COMP *cpi, uint8_t *data_ptr) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
vpx_writer residual_bc;
int tile_row, tile_col;
TOKENEXTRA *tok_end;
return total_size;
}
-static void write_display_size(const VP9_COMMON *cm,
+static void write_display_size(const VP10_COMMON *cm,
struct vpx_write_bit_buffer *wb) {
const int scaling_active = cm->width != cm->display_width ||
cm->height != cm->display_height;
}
}
-static void write_frame_size(const VP9_COMMON *cm,
+static void write_frame_size(const VP10_COMMON *cm,
struct vpx_write_bit_buffer *wb) {
vpx_wb_write_literal(wb, cm->width - 1, 16);
vpx_wb_write_literal(wb, cm->height - 1, 16);
static void write_frame_size_with_refs(VP9_COMP *cpi,
struct vpx_write_bit_buffer *wb) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
int found = 0;
MV_REFERENCE_FRAME ref_frame;
}
static void write_bitdepth_colorspace_sampling(
- VP9_COMMON *const cm, struct vpx_write_bit_buffer *wb) {
+ VP10_COMMON *const cm, struct vpx_write_bit_buffer *wb) {
if (cm->profile >= PROFILE_2) {
assert(cm->bit_depth > VPX_BITS_8);
vpx_wb_write_bit(wb, cm->bit_depth == VPX_BITS_10 ? 0 : 1);
static void write_uncompressed_header(VP9_COMP *cpi,
struct vpx_write_bit_buffer *wb) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
vpx_wb_write_literal(wb, VP9_FRAME_MARKER, 2);
}
static size_t write_compressed_header(VP9_COMP *cpi, uint8_t *data) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
FRAME_CONTEXT *const fc = cm->fc;
FRAME_COUNTS *counts = cpi->td.counts;
BLOCK_64X64,
};
-static void alloc_mode_context(VP9_COMMON *cm, int num_4x4_blk,
+static void alloc_mode_context(VP10_COMMON *cm, int num_4x4_blk,
PICK_MODE_CONTEXT *ctx) {
const int num_blk = (num_4x4_blk < 4 ? 4 : num_4x4_blk);
const int num_pix = num_blk << 4;
}
}
-static void alloc_tree_contexts(VP9_COMMON *cm, PC_TREE *tree,
+static void alloc_tree_contexts(VP10_COMMON *cm, PC_TREE *tree,
int num_4x4_blk) {
alloc_mode_context(cm, num_4x4_blk, &tree->none);
alloc_mode_context(cm, num_4x4_blk/2, &tree->horizontal[0]);
// partition level. There are contexts for none, horizontal, vertical, and
// split. Along with a block_size value and a selected block_size which
// represents the state of our search.
-void vp10_setup_pc_tree(VP9_COMMON *cm, ThreadData *td) {
+void vp10_setup_pc_tree(VP10_COMMON *cm, ThreadData *td) {
int i, j;
const int leaf_nodes = 64;
const int tree_nodes = 64 + 16 + 4 + 1;
// Lighter version of set_offsets that only sets the mode info
// pointers.
-static INLINE void set_mode_info_offsets(VP9_COMMON *const cm,
+static INLINE void set_mode_info_offsets(VP10_COMMON *const cm,
MACROBLOCK *const x,
MACROBLOCKD *const xd,
int mi_row,
static void set_offsets(VP9_COMP *cpi, const TileInfo *const tile,
MACROBLOCK *const x, int mi_row, int mi_col,
BLOCK_SIZE bsize) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *mbmi;
const int mi_width = num_8x8_blocks_wide_lookup[bsize];
xd->tile = *tile;
}
-static void duplicate_mode_info_in_sb(VP9_COMMON *cm, MACROBLOCKD *xd,
+static void duplicate_mode_info_in_sb(VP10_COMMON *cm, MACROBLOCKD *xd,
int mi_row, int mi_col,
BLOCK_SIZE bsize) {
const int block_width = num_8x8_blocks_wide_lookup[bsize];
int64_t threshold,
BLOCK_SIZE bsize_min,
int force_split) {
- VP9_COMMON * const cm = &cpi->common;
+ VP10_COMMON * const cm = &cpi->common;
variance_node vt;
const int block_width = num_8x8_blocks_wide_lookup[bsize];
const int block_height = num_8x8_blocks_high_lookup[bsize];
// 3 - vbp_threshold_8x8. vbp_threshold_8x8 (to split to 4x4 partition) is
// currently only used on key frame.
static void set_vbp_thresholds(VP9_COMP *cpi, int64_t thresholds[], int q) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const int is_key_frame = (cm->frame_type == KEY_FRAME);
const int threshold_multiplier = is_key_frame ? 20 : 1;
const int64_t threshold_base = (int64_t)(threshold_multiplier *
}
void vp10_set_variance_partition_thresholds(VP9_COMP *cpi, int q) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
SPEED_FEATURES *const sf = &cpi->sf;
const int is_key_frame = (cm->frame_type == KEY_FRAME);
if (sf->partition_search_type != VAR_BASED_PARTITION &&
const TileInfo *const tile,
MACROBLOCK *x,
int mi_row, int mi_col) {
- VP9_COMMON * const cm = &cpi->common;
+ VP10_COMMON * const cm = &cpi->common;
MACROBLOCKD *xd = &x->e_mbd;
int i, j, k, m;
v64x64 vt;
int mi_row, int mi_col, BLOCK_SIZE bsize,
int output_enabled) {
int i, x_idx, y;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
RD_COUNTS *const rdc = &td->rd_counts;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
MACROBLOCK *const x,
int8_t segment_id) {
int segment_qindex;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
vp10_init_plane_quantizers(cpi, x);
vpx_clear_system_state();
segment_qindex = vp10_get_qindex(&cm->seg, segment_id,
int mi_row, int mi_col, RD_COST *rd_cost,
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx,
int64_t best_rd) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
TileInfo *const tile_info = &tile_data->tile_info;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *mbmi;
ctx->dist = rd_cost->dist;
}
-static void update_stats(VP9_COMMON *cm, ThreadData *td) {
+static void update_stats(VP10_COMMON *cm, ThreadData *td) {
const MACROBLOCK *x = &td->mb;
const MACROBLOCKD *const xd = &x->e_mbd;
const MODE_INFO *const mi = xd->mi[0];
TOKENEXTRA **tp, int mi_row, int mi_col,
int output_enabled, BLOCK_SIZE bsize,
PC_TREE *pc_tree) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
static void set_fixed_partitioning(VP9_COMP *cpi, const TileInfo *const tile,
MODE_INFO **mi_8x8, int mi_row, int mi_col,
BLOCK_SIZE bsize) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const int mis = cm->mi_stride;
const int row8x8_remaining = tile->mi_row_end - mi_row;
const int col8x8_remaining = tile->mi_col_end - mi_col;
MACROBLOCK *const x,
MODE_INFO **mi_8x8,
int mi_row, int mi_col) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const int mis = cm->mi_stride;
const int row8x8_remaining = tile->mi_row_end - mi_row;
const int col8x8_remaining = tile->mi_col_end - mi_col;
static void update_state_rt(VP9_COMP *cpi, ThreadData *td,
PICK_MODE_CONTEXT *ctx,
int mi_row, int mi_col, int bsize) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
MODE_INFO *const mi = xd->mi[0];
TOKENEXTRA **tp, int mi_row, int mi_col,
int output_enabled, BLOCK_SIZE bsize,
PC_TREE *pc_tree) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
BLOCK_SIZE bsize,
int *rate, int64_t *dist,
int do_recon, PC_TREE *pc_tree) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
TileInfo *const tile_info = &tile_data->tile_info;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
int mi_row, int mi_col,
BLOCK_SIZE *min_block_size,
BLOCK_SIZE *max_block_size) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MODE_INFO **mi = xd->mi;
const int left_in_image = xd->left_available && mi[-1];
const int above_in_image = xd->up_available && mi[-xd->mi_stride];
}
// TODO(jingning) refactor functions setting partition search range
-static void set_partition_range(VP9_COMMON *cm, MACROBLOCKD *xd,
+static void set_partition_range(VP10_COMMON *cm, MACROBLOCKD *xd,
int mi_row, int mi_col, BLOCK_SIZE bsize,
BLOCK_SIZE *min_bs, BLOCK_SIZE *max_bs) {
int mi_width = num_8x8_blocks_wide_lookup[bsize];
TOKENEXTRA **tp, int mi_row, int mi_col,
BLOCK_SIZE bsize, RD_COST *rd_cost,
int64_t best_rd, PC_TREE *pc_tree) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
TileInfo *const tile_info = &tile_data->tile_info;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
TileDataEnc *tile_data,
int mi_row,
TOKENEXTRA **tp) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
TileInfo *const tile_info = &tile_data->tile_info;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
static void init_encode_frame_mb_context(VP9_COMP *cpi) {
MACROBLOCK *const x = &cpi->td.mb;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
const int aligned_mi_cols = mi_cols_aligned_to_sb(cm->mi_cols);
}
}
-static void reset_skip_tx_size(VP9_COMMON *cm, TX_SIZE max_tx_size) {
+static void reset_skip_tx_size(VP10_COMMON *cm, TX_SIZE max_tx_size) {
int mi_row, mi_col;
const int mis = cm->mi_stride;
MODE_INFO **mi_ptr = cm->mi_grid_visible;
TileDataEnc *tile_data, MACROBLOCK *const x,
int mi_row, int mi_col, RD_COST *rd_cost,
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
TileInfo *const tile_info = &tile_data->tile_info;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *mbmi;
ctx->dist = rd_cost->dist;
}
-static void fill_mode_info_sb(VP9_COMMON *cm, MACROBLOCK *x,
+static void fill_mode_info_sb(VP10_COMMON *cm, MACROBLOCK *x,
int mi_row, int mi_col,
BLOCK_SIZE bsize,
PC_TREE *pc_tree) {
int do_recon, int64_t best_rd,
PC_TREE *pc_tree) {
const SPEED_FEATURES *const sf = &cpi->sf;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
TileInfo *const tile_info = &tile_data->tile_info;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
int mi_row, int mi_col,
BLOCK_SIZE bsize, int output_enabled,
RD_COST *rd_cost, PC_TREE *pc_tree) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
TileInfo *const tile_info = &tile_data->tile_info;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
int mi_row, int mi_col,
BLOCK_SIZE bsize, int output_enabled,
RD_COST *dummy_cost, PC_TREE *pc_tree) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
TileInfo *tile_info = &tile_data->tile_info;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
int mi_row,
TOKENEXTRA **tp) {
SPEED_FEATURES *const sf = &cpi->sf;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
TileInfo *const tile_info = &tile_data->tile_info;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
static int set_var_thresh_from_histogram(VP9_COMP *cpi) {
const SPEED_FEATURES *const sf = &cpi->sf;
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const uint8_t *src = cpi->Source->y_buffer;
const uint8_t *last_src = cpi->Last_Source->y_buffer;
}
static void source_var_based_partition_search_method(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
SPEED_FEATURES *const sf = &cpi->sf;
if (cm->frame_type == KEY_FRAME) {
}
}
-static int get_skip_encode_frame(const VP9_COMMON *cm, ThreadData *const td) {
+static int get_skip_encode_frame(const VP10_COMMON *cm, ThreadData *const td) {
unsigned int intra_count = 0, inter_count = 0;
int j;
}
void vp10_init_tile_data(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const int tile_cols = 1 << cm->log2_tile_cols;
const int tile_rows = 1 << cm->log2_tile_rows;
int tile_col, tile_row;
void vp10_encode_tile(VP9_COMP *cpi, ThreadData *td,
int tile_row, int tile_col) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const int tile_cols = 1 << cm->log2_tile_cols;
TileDataEnc *this_tile =
&cpi->tile_data[tile_row * tile_cols + tile_col];
}
static void encode_tiles(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const int tile_cols = 1 << cm->log2_tile_cols;
const int tile_rows = 1 << cm->log2_tile_rows;
int tile_col, tile_row;
#if CONFIG_FP_MB_STATS
static int input_fpmb_stats(FIRSTPASS_MB_STATS *firstpass_mb_stats,
- VP9_COMMON *cm, uint8_t **this_frame_mb_stats) {
+ VP10_COMMON *cm, uint8_t **this_frame_mb_stats) {
uint8_t *mb_stats_in = firstpass_mb_stats->mb_stats_start +
cm->current_video_frame * cm->MBs * sizeof(uint8_t);
SPEED_FEATURES *const sf = &cpi->sf;
ThreadData *const td = &cpi->td;
MACROBLOCK *const x = &td->mb;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
RD_COUNTS *const rdc = &cpi->td.rd_counts;
}
void vp10_encode_frame(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
// In the longer term the encoder should be generalized to match the
// decoder such that we allow compound where one of the 3 buffers has a
TOKENEXTRA **t, int output_enabled,
int mi_row, int mi_col, BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
MODE_INFO **mi_8x8 = xd->mi;
update_mv(w, branch_ct[i], &probs[i], MV_UPDATE_PROB);
}
-void vp10_write_nmv_probs(VP9_COMMON *cm, int usehp, vpx_writer *w,
+void vp10_write_nmv_probs(VP10_COMMON *cm, int usehp, vpx_writer *w,
nmv_context_counts *const counts) {
int i, j;
nmv_context *const mvc = &cm->fc->nmvc;
void vp10_entropy_mv_init(void);
-void vp10_write_nmv_probs(VP9_COMMON *cm, int usehp, vpx_writer *w,
+void vp10_write_nmv_probs(VP10_COMMON *cm, int usehp, vpx_writer *w,
nmv_context_counts *const counts);
void vp10_encode_mv(VP9_COMP *cpi, vpx_writer* w, const MV* mv, const MV* ref,
}
static void setup_frame(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
// Set up entropy context depending on frame type. The decoder mandates
// the use of the default context, index 0, for keyframes and inter
// frames where the error_resilient_mode or intra_only flag is set. For
}
}
-static void vp10_enc_setup_mi(VP9_COMMON *cm) {
+static void vp10_enc_setup_mi(VP10_COMMON *cm) {
int i;
cm->mi = cm->mip + cm->mi_stride + 1;
memset(cm->mip, 0, cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mip));
cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mi_grid_base));
}
-static int vp10_enc_alloc_mi(VP9_COMMON *cm, int mi_size) {
+static int vp10_enc_alloc_mi(VP10_COMMON *cm, int mi_size) {
cm->mip = vpx_calloc(mi_size, sizeof(*cm->mip));
if (!cm->mip)
return 1;
return 0;
}
-static void vp10_enc_free_mi(VP9_COMMON *cm) {
+static void vp10_enc_free_mi(VP10_COMMON *cm) {
vpx_free(cm->mip);
cm->mip = NULL;
vpx_free(cm->prev_mip);
cm->prev_mi_grid_base = NULL;
}
-static void vp10_swap_mi_and_prev_mi(VP9_COMMON *cm) {
+static void vp10_swap_mi_and_prev_mi(VP10_COMMON *cm) {
// Current mip will be the prev_mip for the next frame.
MODE_INFO **temp_base = cm->prev_mi_grid_base;
MODE_INFO *temp = cm->prev_mip;
}
static void dealloc_compressor_data(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
int i;
vpx_free(cpi->mbmi_ext_base);
static void save_coding_context(VP9_COMP *cpi) {
CODING_CONTEXT *const cc = &cpi->coding_context;
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
// Stores a snapshot of key state variables which can subsequently be
// restored with a call to vp10_restore_coding_context. These functions are
static void restore_coding_context(VP9_COMP *cpi) {
CODING_CONTEXT *const cc = &cpi->coding_context;
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
// Restore key state variables to the snapshot state stored in the
// previous call to vp10_save_coding_context.
}
static void configure_static_seg_features(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const RATE_CONTROL *const rc = &cpi->rc;
struct segmentation *const seg = &cm->seg;
}
static void update_reference_segmentation_map(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MODE_INFO **mi_8x8_ptr = cm->mi_grid_visible;
uint8_t *cache_ptr = cm->last_frame_seg_map;
int row, col;
}
static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
const VP9EncoderConfig *oxcf = &cpi->oxcf;
if (!cpi->lookahead)
}
static void alloc_util_frame_buffers(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
if (vp9_realloc_frame_buffer(&cpi->last_frame_uf,
cm->width, cm->height,
cm->subsampling_x, cm->subsampling_y,
static int alloc_context_buffers_ext(VP9_COMP *cpi) {
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
int mi_size = cm->mi_cols * cm->mi_rows;
cpi->mbmi_ext_base = vpx_calloc(mi_size, sizeof(*cpi->mbmi_ext_base));
}
void vp10_alloc_compressor_data(VP9_COMP *cpi) {
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
vp10_alloc_context_buffers(cm, cm->width, cm->height);
}
static void set_tile_limits(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
int min_log2_tile_cols, max_log2_tile_cols;
vp10_get_tile_n_bits(cm->mi_cols, &min_log2_tile_cols, &max_log2_tile_cols);
}
static void update_frame_size(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
vp10_set_mb_mi(cm, cm->width, cm->height);
}
static void init_config(struct VP9_COMP *cpi, VP9EncoderConfig *oxcf) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
cpi->oxcf = *oxcf;
cpi->framerate = oxcf->init_framerate;
MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad4x4x4d)
static void highbd_set_var_fns(VP9_COMP *const cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
if (cm->use_highbitdepth) {
switch (cm->bit_depth) {
case VPX_BITS_8:
#endif // CONFIG_VP9_HIGHBITDEPTH
static void realloc_segmentation_maps(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
// Create the encoder segmentation map and set all entries to 0
vpx_free(cpi->segmentation_map);
}
void vp10_change_config(struct VP9_COMP *cpi, const VP9EncoderConfig *oxcf) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
if (cm->profile != oxcf->profile)
BufferPool *const pool) {
unsigned int i;
VP9_COMP *volatile const cpi = vpx_memalign(32, sizeof(VP9_COMP));
- VP9_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL;
+ VP10_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL;
if (!cm)
return NULL;
snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V))
void vp10_remove_compressor(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
unsigned int i;
int t;
#endif
#ifdef OUTPUT_YUV_REC
-void vp10_write_yuv_rec_frame(VP9_COMMON *cm) {
+void vp10_write_yuv_rec_frame(VP10_COMMON *cm) {
YV12_BUFFER_CONFIG *s = cm->frame_to_show;
uint8_t *src = s->y_buffer;
int h = cm->height;
}
void vp10_update_reference_frames(VP9_COMP *cpi) {
- VP9_COMMON * const cm = &cpi->common;
+ VP10_COMMON * const cm = &cpi->common;
BufferPool *const pool = cm->buffer_pool;
// At this point the new frame has been encoded.
#endif
}
-static void loopfilter_frame(VP9_COMP *cpi, VP9_COMMON *cm) {
+static void loopfilter_frame(VP9_COMP *cpi, VP10_COMMON *cm) {
MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
struct loopfilter *lf = &cm->lf;
if (xd->lossless) {
vp9_extend_frame_inner_borders(cm->frame_to_show);
}
-static INLINE void alloc_frame_mvs(const VP9_COMMON *cm,
+static INLINE void alloc_frame_mvs(const VP10_COMMON *cm,
int buffer_idx) {
RefCntBuffer *const new_fb_ptr = &cm->buffer_pool->frame_bufs[buffer_idx];
if (new_fb_ptr->mvs == NULL ||
}
void vp10_scale_references(VP9_COMP *cpi) {
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
MV_REFERENCE_FRAME ref_frame;
const VP9_REFFRAME ref_mask[3] = {VP9_LAST_FLAG, VP9_GOLD_FLAG, VP9_ALT_FLAG};
}
static void release_scaled_references(VP9_COMP *cpi) {
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
int i;
if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
// Only release scaled references under certain conditions:
#if 0 && CONFIG_INTERNAL_STATS
static void output_frame_level_debug_stats(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
FILE *const f = fopen("tmp.stt", cm->current_video_frame ? "a" : "w");
int64_t recon_err;
#endif
static void set_mv_search_params(VP9_COMP *cpi) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const unsigned int max_mv_def = MIN(cm->width, cm->height);
// Default based on max resolution.
static void set_size_dependent_vars(VP9_COMP *cpi, int *q,
int *bottom_index, int *top_index) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
// Setup variables that depend on the dimensions of the frame.
static void set_frame_size(VP9_COMP *cpi) {
int ref_frame;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
VP9EncoderConfig *const oxcf = &cpi->oxcf;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
}
static void encode_without_recode_loop(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
int q = 0, bottom_index = 0, top_index = 0; // Dummy variables.
vpx_clear_system_state();
static void encode_with_recode_loop(VP9_COMP *cpi,
size_t *size,
uint8_t *dest) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
int bottom_index, top_index;
int loop_count = 0;
}
}
-YV12_BUFFER_CONFIG *vp10_scale_if_required_fast(VP9_COMMON *cm,
+YV12_BUFFER_CONFIG *vp10_scale_if_required_fast(VP10_COMMON *cm,
YV12_BUFFER_CONFIG *unscaled,
YV12_BUFFER_CONFIG *scaled) {
if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
}
}
-YV12_BUFFER_CONFIG *vp10_scale_if_required(VP9_COMMON *cm,
+YV12_BUFFER_CONFIG *vp10_scale_if_required(VP10_COMMON *cm,
YV12_BUFFER_CONFIG *unscaled,
YV12_BUFFER_CONFIG *scaled) {
if (cm->mi_cols * MI_SIZE != unscaled->y_width ||
}
static void set_arf_sign_bias(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
int arf_sign_bias;
if ((cpi->oxcf.pass == 2) && cpi->multi_arf_allowed) {
size_t *size,
uint8_t *dest,
unsigned int *frame_flags) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
struct segmentation *const seg = &cm->seg;
TX_SIZE t;
vp10_twopass_postencode_update(cpi);
}
-static void init_ref_frame_bufs(VP9_COMMON *cm) {
+static void init_ref_frame_bufs(VP10_COMMON *cm) {
int i;
BufferPool *const pool = cm->buffer_pool;
cm->new_fb_idx = INVALID_IDX;
int use_highbitdepth,
#endif
int subsampling_x, int subsampling_y) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
if (!cpi->initial_width ||
#if CONFIG_VP9_HIGHBITDEPTH
#if CONFIG_VP9_TEMPORAL_DENOISING
static void setup_denoiser_buffer(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
if (cpi->oxcf.noise_sensitivity > 0 &&
!cpi->denoiser.frame_buffer_initialized) {
vp10_denoiser_alloc(&(cpi->denoiser), cm->width, cm->height,
int vp10_receive_raw_frame(VP9_COMP *cpi, unsigned int frame_flags,
YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
int64_t end_time) {
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
struct vpx_usec_timer timer;
int res = 0;
const int subsampling_x = sd->subsampling_x;
static int frame_is_reference(const VP9_COMP *cpi) {
- const VP9_COMMON *cm = &cpi->common;
+ const VP10_COMMON *cm = &cpi->common;
return cm->frame_type == KEY_FRAME ||
cpi->refresh_last_frame ||
size_t *size, uint8_t *dest,
int64_t *time_stamp, int64_t *time_end, int flush) {
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
BufferPool *const pool = cm->buffer_pool;
RATE_CONTROL *const rc = &cpi->rc;
struct vpx_usec_timer cmptimer;
int vp10_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
vp10_ppflags_t *flags) {
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
#if !CONFIG_VP9_POSTPROC
(void)flags;
#endif
int vp10_set_internal_size(VP9_COMP *cpi,
VPX_SCALING horiz_mode, VPX_SCALING vert_mode) {
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
int hr = 0, hs = 0, vr = 0, vs = 0;
if (horiz_mode > ONETWO || vert_mode > ONETWO)
int vp10_set_size_literal(VP9_COMP *cpi, unsigned int width,
unsigned int height) {
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
#if CONFIG_VP9_HIGHBITDEPTH
check_initial_width(cpi, cm->use_highbitdepth, 1, 1);
#else
MB_MODE_INFO_EXT *mbmi_ext_base;
DECLARE_ALIGNED(16, int16_t, y_dequant[QINDEX_RANGE][8]);
DECLARE_ALIGNED(16, int16_t, uv_dequant[QINDEX_RANGE][8]);
- VP9_COMMON common;
+ VP10_COMMON common;
VP9EncoderConfig oxcf;
struct lookahead_ctx *lookahead;
struct lookahead_entry *alt_ref_source;
static INLINE int get_ref_frame_buf_idx(const VP9_COMP *const cpi,
int ref_frame) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const int map_idx = get_ref_frame_map_idx(cpi, ref_frame);
return (map_idx != INVALID_IDX) ? cm->ref_frame_map[map_idx] : INVALID_IDX;
}
static INLINE YV12_BUFFER_CONFIG *get_ref_frame_buffer(
VP9_COMP *cpi, MV_REFERENCE_FRAME ref_frame) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
return
buf_idx != INVALID_IDX ? &cm->buffer_pool->frame_bufs[buf_idx].buf : NULL;
void vp10_set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv);
-YV12_BUFFER_CONFIG *vp10_scale_if_required_fast(VP9_COMMON *cm,
+YV12_BUFFER_CONFIG *vp10_scale_if_required_fast(VP10_COMMON *cm,
YV12_BUFFER_CONFIG *unscaled,
YV12_BUFFER_CONFIG *scaled);
-YV12_BUFFER_CONFIG *vp10_scale_if_required(VP9_COMMON *cm,
+YV12_BUFFER_CONFIG *vp10_scale_if_required(VP10_COMMON *cm,
YV12_BUFFER_CONFIG *unscaled,
YV12_BUFFER_CONFIG *scaled);
cpi->oxcf.ss_enable_auto_arf[cpi->svc.spatial_layer_id]));
}
-static INLINE void set_ref_ptrs(VP9_COMMON *cm, MACROBLOCKD *xd,
+static INLINE void set_ref_ptrs(VP10_COMMON *cm, MACROBLOCKD *xd,
MV_REFERENCE_FRAME ref0,
MV_REFERENCE_FRAME ref1) {
xd->block_refs[0] = &cm->frame_refs[ref0 >= LAST_FRAME ? ref0 - LAST_FRAME
static int enc_worker_hook(EncWorkerData *const thread_data, void *unused) {
VP9_COMP *const cpi = thread_data->cpi;
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const int tile_cols = 1 << cm->log2_tile_cols;
const int tile_rows = 1 << cm->log2_tile_rows;
int t;
}
void vp10_encode_tiles_mt(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const int tile_cols = 1 << cm->log2_tile_cols;
const VPxWorkerInterface *const winterface = vpx_get_worker_interface();
const int num_workers = MIN(cpi->oxcf.max_threads, tile_cols);
}
#if CONFIG_FP_MB_STATS
-static void output_fpmb_stats(uint8_t *this_frame_mb_stats, VP9_COMMON *cm,
+static void output_fpmb_stats(uint8_t *this_frame_mb_stats, VP10_COMMON *cm,
struct vpx_codec_pkt_list *pktlist) {
struct vpx_codec_cx_pkt pkt;
pkt.kind = VPX_CODEC_FPMB_STATS_PKT;
}
}
-static BLOCK_SIZE get_bsize(const VP9_COMMON *cm, int mb_row, int mb_col) {
+static BLOCK_SIZE get_bsize(const VP10_COMMON *cm, int mb_row, int mb_col) {
if (2 * mb_col + 1 < cm->mi_cols) {
return 2 * mb_row + 1 < cm->mi_rows ? BLOCK_16X16
: BLOCK_16X8;
}
static void set_first_pass_params(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
if (!cpi->refresh_alt_ref_frame &&
(cm->current_video_frame == 0 ||
(cpi->frame_flags & FRAMEFLAGS_KEY))) {
void vp10_first_pass(VP9_COMP *cpi, const struct lookahead_entry *source) {
int mb_row, mb_col;
MACROBLOCK *const x = &cpi->td.mb;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
TileInfo tile;
struct macroblock_plane *const p = x->plane;
}
void vp10_init_subsampling(VP9_COMP *cpi) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
const int w = cm->width;
const int h = cm->height;
// Analyse and define a gf/arf group.
static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
VP9EncoderConfig *const oxcf = &cpi->oxcf;
TWO_PASS *const twopass = &cpi->twopass;
}
void vp10_rc_get_second_pass_params(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
TWO_PASS *const twopass = &cpi->twopass;
GF_GROUP *const gf_group = &twopass->gf_group;
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
int intra_error;
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
// FIXME in practice we're completely ignoring chroma here
x->plane[0].src.buf = buf->y_buffer + mb_y_offset;
YV12_BUFFER_CONFIG *alt_ref) {
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
int mb_col, mb_row, offset = 0;
int mb_y_offset = 0, arf_y_offset = 0, gld_y_offset = 0;
// void separate_arf_mbs_byzz
static void separate_arf_mbs(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
int mb_col, mb_row, offset, i;
int mi_row, mi_col;
int ncnt[4] = { 0 };
}
void vp10_update_mbgraph_stats(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
int i, n_frames = vp10_lookahead_depth(cpi->lookahead);
YV12_BUFFER_CONFIG *golden_ref = get_ref_frame_buffer(cpi, GOLDEN_FRAME);
static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd,
VP9_COMP *const cpi,
int filt_level, int partial_frame) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
int64_t filt_err;
if (cpi->num_workers > 1)
static int search_filter_level(const YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi,
int partial_frame) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const struct loopfilter *const lf = &cm->lf;
const int min_filter_level = 0;
const int max_filter_level = get_max_filter_level(cpi);
void vp10_pick_filter_level(const YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi,
LPF_PICK_METHOD method) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
struct loopfilter *const lf = &cm->lf;
lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0
int in_use;
} PRED_BUFFER;
-static int mv_refs_rt(const VP9_COMMON *cm, const MACROBLOCK *x,
+static int mv_refs_rt(const VP10_COMMON *cm, const MACROBLOCK *x,
const MACROBLOCKD *xd,
const TileInfo *const tile,
MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
*rd_cost = best_rdc;
}
-static void init_ref_frame_cost(VP9_COMMON *const cm,
+static void init_ref_frame_cost(VP10_COMMON *const cm,
MACROBLOCKD *const xd,
int ref_frame_cost[MAX_REF_FRAMES]) {
vpx_prob intra_inter_p = vp10_get_intra_inter_prob(cm, xd);
TileDataEnc *tile_data,
int mi_row, int mi_col, RD_COST *rd_cost,
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
SPEED_FEATURES *const sf = &cpi->sf;
TileInfo *const tile_info = &tile_data->tile_info;
MACROBLOCKD *const xd = &x->e_mbd;
void vp10_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
int mi_row, int mi_col, RD_COST *rd_cost,
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
SPEED_FEATURES *const sf = &cpi->sf;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
}
void vp10_init_quantizer(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
QUANTS *const quants = &cpi->quants;
int i, q, quant;
}
void vp10_init_plane_quantizers(VP9_COMP *cpi, MACROBLOCK *x) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
QUANTS *const quants = &cpi->quants;
const int segment_id = xd->mi[0]->mbmi.segment_id;
vp10_init_plane_quantizers(cpi, &cpi->td.mb);
}
-void vp10_set_quantizer(VP9_COMMON *cm, int q) {
+void vp10_set_quantizer(VP10_COMMON *cm, int q) {
// quantizer has to be reinitialized with vp10_init_quantizer() if any
// delta_q changes.
cm->base_qindex = q;
// Update the buffer level: leaky bucket model.
static void update_buffer_level(VP9_COMP *cpi, int encoded_frame_size) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
// Non-viewable frames are a special case and are treated as pure overhead.
}
void vp10_rc_update_rate_correction_factors(VP9_COMP *cpi) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
int correction_factor = 100;
double rate_correction_factor = get_rate_correction_factor(cpi);
double adjustment_limit;
int vp10_rc_regulate_q(const VP9_COMP *cpi, int target_bits_per_frame,
int active_best_quality, int active_worst_quality) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
int q = active_worst_quality;
int last_error = INT_MAX;
int i, target_bits_per_mb, bits_per_mb_at_this_q;
// If buffer is below the optimal level, let the active_worst_quality go from
// ambient Q (at buffer = optimal level) to worst_quality level
// (at buffer = critical level).
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const RATE_CONTROL *rc = &cpi->rc;
// Buffer level below which we push active_worst to worst_quality.
int64_t critical_level = rc->optimal_buffer_level >> 3;
static int rc_pick_q_and_bounds_one_pass_cbr(const VP9_COMP *cpi,
int *bottom_index,
int *top_index) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const RATE_CONTROL *const rc = &cpi->rc;
int active_best_quality;
int active_worst_quality = calc_active_worst_quality_one_pass_cbr(cpi);
static int rc_pick_q_and_bounds_one_pass_vbr(const VP9_COMP *cpi,
int *bottom_index,
int *top_index) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const RATE_CONTROL *const rc = &cpi->rc;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
const int cq_level = get_active_cq_level(rc, oxcf);
};
static const FRAME_TYPE frame_type[RATE_FACTOR_LEVELS] =
{INTER_FRAME, INTER_FRAME, INTER_FRAME, INTER_FRAME, KEY_FRAME};
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
int qdelta = vp10_compute_qdelta_by_rate(&cpi->rc, frame_type[rf_level],
q, rate_factor_deltas[rf_level],
cm->bit_depth);
static int rc_pick_q_and_bounds_two_pass(const VP9_COMP *cpi,
int *bottom_index,
int *top_index) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const RATE_CONTROL *const rc = &cpi->rc;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
const GF_GROUP *gf_group = &cpi->twopass.gf_group;
}
void vp10_rc_set_frame_target(VP9_COMP *cpi, int target) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
rc->this_frame_target = target;
}
void vp10_rc_postencode_update(VP9_COMP *cpi, uint64_t bytes_used) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
RATE_CONTROL *const rc = &cpi->rc;
const int qindex = cm->base_qindex;
}
void vp10_rc_get_one_pass_vbr_params(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
int target;
// TODO(yaowu): replace the "auto_key && 0" below with proper decision logic.
}
void vp10_rc_get_svc_params(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
int target = rc->avg_frame_bandwidth;
const int layer = LAYER_IDS_TO_IDX(cpi->svc.spatial_layer_id,
}
void vp10_rc_get_one_pass_cbr_params(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
int target;
// TODO(yaowu): replace the "auto_key && 0" below with proper decision logic.
}
void vp10_rc_update_framerate(VP9_COMP *cpi) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
RATE_CONTROL *const rc = &cpi->rc;
int vbr_max_bits;
// Check if we should resize, based on average QP from past x frames.
// Only allow for resize at most one scale down for now, scaling factor is 2.
int vp10_resize_one_pass_cbr(VP9_COMP *cpi) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
int resize_now = 0;
cpi->resize_scale_num = 1;
#endif // CONFIG_VP9_HIGHBITDEPTH
}
-static void set_block_thresholds(const VP9_COMMON *cm, RD_OPT *rd) {
+static void set_block_thresholds(const VP10_COMMON *cm, RD_OPT *rd) {
int i, bsize, segment_id;
for (segment_id = 0; segment_id < MAX_SEGMENTS; ++segment_id) {
}
void vp10_initialize_rd_consts(VP9_COMP *cpi) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
RD_OPT *const rd = &cpi->rd;
YV12_BUFFER_CONFIG *vp10_get_scaled_ref_frame(const VP9_COMP *cpi,
int ref_frame) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const int scaled_idx = cpi->scaled_ref_idx[ref_frame - 1];
const int ref_idx = get_ref_frame_buf_idx(cpi, ref_frame);
return
int64_t ref_best_rd,
BLOCK_SIZE bs) {
const TX_SIZE max_tx_size = max_txsize_lookup[bs];
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const TX_SIZE largest_tx_size = tx_mode_to_biggest_tx_size[cm->tx_mode];
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
int64_t ref_best_rd,
BLOCK_SIZE bs) {
const TX_SIZE max_tx_size = max_txsize_lookup[bs];
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
vpx_prob skip_prob = vp10_get_skip_prob(cm, xd);
int *rate, int *rate_tokenonly,
int64_t *distortion, int *skippable,
BLOCK_SIZE bsize) {
- const VP9_COMMON *cm = &cpi->common;
+ const VP10_COMMON *cm = &cpi->common;
int64_t unused;
x->e_mbd.mi[0]->mbmi.uv_mode = DC_PRED;
int mi_row, int mi_col,
int_mv single_newmv[MAX_REF_FRAMES],
int *rate_mv) {
- const VP9_COMMON *const cm = &cpi->common;
+ const VP10_COMMON *const cm = &cpi->common;
const int pw = 4 * num_4x4_blocks_wide_lookup[bsize];
const int ph = 4 * num_4x4_blocks_high_lookup[bsize];
MACROBLOCKD *xd = &x->e_mbd;
int k, br = 0, idx, idy;
int64_t bd = 0, block_sse = 0;
PREDICTION_MODE this_mode;
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
struct macroblock_plane *const p = &x->plane[0];
struct macroblockd_plane *const pd = &xd->plane[0];
const int label_count = 4;
return bsi->segment_rd;
}
-static void estimate_ref_frame_costs(const VP9_COMMON *cm,
+static void estimate_ref_frame_costs(const VP10_COMMON *cm,
const MACROBLOCKD *xd,
int segment_id,
unsigned int *ref_costs_single,
int_mv frame_nearest_mv[MAX_REF_FRAMES],
int_mv frame_near_mv[MAX_REF_FRAMES],
struct buf_2d yv12_mb[4][MAX_MB_PLANE]) {
- const VP9_COMMON *cm = &cpi->common;
+ const VP10_COMMON *cm = &cpi->common;
const YV12_BUFFER_CONFIG *yv12 = get_ref_frame_buffer(cpi, ref_frame);
MACROBLOCKD *const xd = &x->e_mbd;
MODE_INFO *const mi = xd->mi[0];
int mi_row, int mi_col,
int_mv *tmp_mv, int *rate_mv) {
MACROBLOCKD *xd = &x->e_mbd;
- const VP9_COMMON *cm = &cpi->common;
+ const VP10_COMMON *cm = &cpi->common;
MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
struct buf_2d backup_yv12[MAX_MB_PLANE] = {{0, 0}};
int bestsme = INT_MAX;
const int64_t ref_best_rd,
int64_t *mask_filter,
int64_t filter_cache[]) {
- VP9_COMMON *cm = &cpi->common;
+ VP10_COMMON *cm = &cpi->common;
MACROBLOCKD *xd = &x->e_mbd;
MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi;
MB_MODE_INFO_EXT *const mbmi_ext = x->mbmi_ext;
void vp10_rd_pick_intra_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
RD_COST *rd_cost, BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx, int64_t best_rd) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
struct macroblockd_plane *const pd = xd->plane;
int rate_y = 0, rate_uv = 0, rate_y_tokenonly = 0, rate_uv_tokenonly = 0;
RD_COST *rd_cost, BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx,
int64_t best_rd_so_far) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
TileInfo *const tile_info = &tile_data->tile_info;
RD_OPT *const rd_opt = &cpi->rd;
SPEED_FEATURES *const sf = &cpi->sf;
BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx,
int64_t best_rd_so_far) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
unsigned char segment_id = mbmi->segment_id;
BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx,
int64_t best_rd_so_far) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
RD_OPT *const rd_opt = &cpi->rd;
SPEED_FEATURES *const sf = &cpi->sf;
MACROBLOCKD *const xd = &x->e_mbd;
return cost;
}
-static void count_segs(const VP9_COMMON *cm, MACROBLOCKD *xd,
+static void count_segs(const VP10_COMMON *cm, MACROBLOCKD *xd,
const TileInfo *tile, MODE_INFO **mi,
int *no_pred_segcounts,
int (*temporal_predictor_count)[2],
}
}
-static void count_segs_sb(const VP9_COMMON *cm, MACROBLOCKD *xd,
+static void count_segs_sb(const VP10_COMMON *cm, MACROBLOCKD *xd,
const TileInfo *tile, MODE_INFO **mi,
int *no_pred_segcounts,
int (*temporal_predictor_count)[2],
}
}
-void vp10_choose_segmap_coding_method(VP9_COMMON *cm, MACROBLOCKD *xd) {
+void vp10_choose_segmap_coding_method(VP10_COMMON *cm, MACROBLOCKD *xd) {
struct segmentation *seg = &cm->seg;
int no_pred_cost;
void vp10_set_segment_data(struct segmentation *seg, signed char *feature_data,
unsigned char abs_delta);
-void vp10_choose_segmap_coding_method(VP9_COMMON *cm, MACROBLOCKD *xd);
+void vp10_choose_segmap_coding_method(VP10_COMMON *cm, MACROBLOCKD *xd);
void vp10_reset_segment_features(struct segmentation *seg);
// For viewing skin map on input source.
void vp10_compute_skin_map(VP9_COMP *const cpi, FILE *yuv_skinmap_file) {
int i, j, mi_row, mi_col;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
uint8_t *y;
const uint8_t *src_y = cpi->Source->y_buffer;
const uint8_t *src_u = cpi->Source->u_buffer;
// partly on the screen area that over which they propogate. Propogation is
// limited by transform block size but the screen area take up by a given block
// size will be larger for a small image format stretched to full screen.
-static BLOCK_SIZE set_partition_min_limit(VP9_COMMON *const cm) {
+static BLOCK_SIZE set_partition_min_limit(VP10_COMMON *const cm) {
unsigned int screen_area = (cm->width * cm->height);
// Select block size based on image format size.
static void set_good_speed_feature_framesize_dependent(VP9_COMP *cpi,
SPEED_FEATURES *sf,
int speed) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
if (speed >= 1) {
if (MIN(cm->width, cm->height) >= 720) {
}
}
-static void set_good_speed_feature(VP9_COMP *cpi, VP9_COMMON *cm,
+static void set_good_speed_feature(VP9_COMP *cpi, VP10_COMMON *cm,
SPEED_FEATURES *sf, int speed) {
const int boosted = frame_is_boosted(cpi);
static void set_rt_speed_feature_framesize_dependent(VP9_COMP *cpi,
SPEED_FEATURES *sf, int speed) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
if (speed >= 1) {
if (MIN(cm->width, cm->height) >= 720) {
static void set_rt_speed_feature(VP9_COMP *cpi, SPEED_FEATURES *sf,
int speed, vp9e_tune_content content) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
const int is_keyframe = cm->frame_type == KEY_FRAME;
const int frames_since_key = is_keyframe ? 0 : cpi->rc.frames_since_key;
sf->static_segmentation = 0;
void vp10_set_speed_features_framesize_independent(VP9_COMP *cpi) {
SPEED_FEATURES *const sf = &cpi->sf;
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->td.mb;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
int i;
}
void vp10_temporal_filter(VP9_COMP *cpi, int distance) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
int frame;
void vp10_tokenize_sb(VP9_COMP *cpi, ThreadData *td, TOKENEXTRA **t,
int dry_run, BLOCK_SIZE bsize) {
- VP9_COMMON *const cm = &cpi->common;
+ VP10_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
for (i = 0; i < ctx->num_frame_workers; ++i) {
VPxWorker *const worker = &ctx->frame_workers[i];
FrameWorkerData *const frame_worker_data = (FrameWorkerData *)worker->data1;
- VP9_COMMON *const cm = &frame_worker_data->pbi->common;
+ VP10_COMMON *const cm = &frame_worker_data->pbi->common;
BufferPool *const pool = cm->buffer_pool;
cm->new_fb_idx = INVALID_IDX;
check_resync(ctx, frame_worker_data->pbi);
if (vp10_get_raw_frame(frame_worker_data->pbi, &sd, &flags) == 0) {
- VP9_COMMON *const cm = &frame_worker_data->pbi->common;
+ VP10_COMMON *const cm = &frame_worker_data->pbi->common;
RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
ctx->frame_cache[ctx->frame_cache_write].fb_idx = cm->new_fb_idx;
yuvconfig2image(&ctx->frame_cache[ctx->frame_cache_write].img, &sd,
check_resync(ctx, frame_worker_data->pbi);
}
if (vp10_get_raw_frame(frame_worker_data->pbi, &sd, &flags) == 0) {
- VP9_COMMON *const cm = &frame_worker_data->pbi->common;
+ VP10_COMMON *const cm = &frame_worker_data->pbi->common;
RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
release_last_output_frame(ctx);
ctx->last_show_frame = frame_worker_data->pbi->common.new_fb_idx;
VPxWorker *const worker = ctx->frame_workers;
FrameWorkerData *const frame_worker_data =
(FrameWorkerData *)worker->data1;
- const VP9_COMMON *const cm = &frame_worker_data->pbi->common;
+ const VP10_COMMON *const cm = &frame_worker_data->pbi->common;
frame_size[0] = cm->width;
frame_size[1] = cm->height;
return VPX_CODEC_OK;
VPxWorker *const worker = ctx->frame_workers;
FrameWorkerData *const frame_worker_data =
(FrameWorkerData *)worker->data1;
- const VP9_COMMON *const cm = &frame_worker_data->pbi->common;
+ const VP10_COMMON *const cm = &frame_worker_data->pbi->common;
display_size[0] = cm->display_width;
display_size[1] = cm->display_height;
return VPX_CODEC_OK;
if (worker) {
FrameWorkerData *const frame_worker_data =
(FrameWorkerData *)worker->data1;
- const VP9_COMMON *const cm = &frame_worker_data->pbi->common;
+ const VP10_COMMON *const cm = &frame_worker_data->pbi->common;
*bit_depth = cm->bit_depth;
return VPX_CODEC_OK;
} else {
projects / platform / upstream / libvpx.git / commitdiff