return (base_quant > 10) + (base_quant > 25);
}
-void vp10_setup_in_frame_q_adj(VP9_COMP *cpi) {
+void vp10_setup_in_frame_q_adj(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
struct segmentation *const seg = &cm->seg;
// Select a segment for the current block.
// The choice of segment for a block depends on the ratio of the projected
// 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,
+void vp10_caq_select_segment(VP10_COMP *cpi, MACROBLOCK *mb, BLOCK_SIZE bs,
int mi_row, int mi_col, int projected_rate) {
VP10_COMMON *const cm = &cpi->common;
#include "vp10/common/enums.h"
-struct VP9_COMP;
+struct VP10_COMP;
struct macroblock;
// Select a segment for the current Block.
-void vp10_caq_select_segment(struct VP9_COMP *cpi, struct macroblock *,
+void vp10_caq_select_segment(struct VP10_COMP *cpi, struct macroblock *,
BLOCK_SIZE bs,
int mi_row, int mi_col, int projected_rate);
// This function sets up a set of segments with delta Q values around
// the baseline frame quantizer.
-void vp10_setup_in_frame_q_adj(struct VP9_COMP *cpi);
+void vp10_setup_in_frame_q_adj(struct VP10_COMP *cpi);
#ifdef __cplusplus
} // extern "C"
}
// Compute delta-q for the segment.
-static int compute_deltaq(const VP9_COMP *cpi, int q, double rate_factor) {
+static int compute_deltaq(const VP10_COMP *cpi, int q, double rate_factor) {
const CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
const RATE_CONTROL *const rc = &cpi->rc;
int deltaq = vp10_compute_qdelta_by_rate(rc, cpi->common.frame_type,
// from non-base segment. For now ignore effect of multiple segments
// (with different delta-q). Note this function is called in the postencode
// (called from rc_update_rate_correction_factors()).
-int vp10_cyclic_refresh_estimate_bits_at_q(const VP9_COMP *cpi,
+int vp10_cyclic_refresh_estimate_bits_at_q(const VP10_COMP *cpi,
double correction_factor) {
const VP10_COMMON *const cm = &cpi->common;
const CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
// rc_regulate_q() to set the base qp index.
// Note: the segment map is set to either 0/CR_SEGMENT_ID_BASE (no refresh) or
// 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,
+int vp10_cyclic_refresh_rc_bits_per_mb(const VP10_COMP *cpi, int i,
double correction_factor) {
const VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
// Prior to coding a given prediction block, of size bsize at (mi_row, mi_col),
// check if we should reset the segment_id, and update the cyclic_refresh map
// and segmentation map.
-void vp10_cyclic_refresh_update_segment(VP9_COMP *const cpi,
+void vp10_cyclic_refresh_update_segment(VP10_COMP *const cpi,
MB_MODE_INFO *const mbmi,
int mi_row, int mi_col,
BLOCK_SIZE bsize,
}
// Update the actual number of blocks that were applied the segment delta q.
-void vp10_cyclic_refresh_postencode(VP9_COMP *const cpi) {
+void vp10_cyclic_refresh_postencode(VP10_COMP *const cpi) {
VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
unsigned char *const seg_map = cpi->segmentation_map;
}
// Set golden frame update interval, for non-svc 1 pass CBR mode.
-void vp10_cyclic_refresh_set_golden_update(VP9_COMP *const cpi) {
+void vp10_cyclic_refresh_set_golden_update(VP10_COMP *const cpi) {
RATE_CONTROL *const rc = &cpi->rc;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
// Set minimum gf_interval for GF update to a multiple (== 2) of refresh
// background has high motion, refresh the golden frame. Otherwise, if the
// 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) {
+void vp10_cyclic_refresh_check_golden_update(VP10_COMP *const cpi) {
VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
int mi_row, mi_col;
// 1/CR_SEGMENT_ID_BOOST1 (refresh) for each superblock.
// 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) {
+static void cyclic_refresh_update_map(VP10_COMP *const cpi) {
VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
unsigned char *const seg_map = cpi->segmentation_map;
}
// Set cyclic refresh parameters.
-void vp10_cyclic_refresh_update_parameters(VP9_COMP *const cpi) {
+void vp10_cyclic_refresh_update_parameters(VP10_COMP *const cpi) {
const RATE_CONTROL *const rc = &cpi->rc;
const VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
}
// Setup cyclic background refresh: set delta q and segmentation map.
-void vp10_cyclic_refresh_setup(VP9_COMP *const cpi) {
+void vp10_cyclic_refresh_setup(VP10_COMP *const cpi) {
VP10_COMMON *const cm = &cpi->common;
const RATE_CONTROL *const rc = &cpi->rc;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
return cr->rdmult;
}
-void vp10_cyclic_refresh_reset_resize(VP9_COMP *const cpi) {
+void vp10_cyclic_refresh_reset_resize(VP10_COMP *const cpi) {
const VP10_COMMON *const cm = &cpi->common;
CYCLIC_REFRESH *const cr = cpi->cyclic_refresh;
memset(cr->map, 0, cm->mi_rows * cm->mi_cols);
// Maximum rate target ratio for setting segment delta-qp.
#define CR_MAX_RATE_TARGET_RATIO 4.0
-struct VP9_COMP;
+struct VP10_COMP;
struct CYCLIC_REFRESH;
typedef struct CYCLIC_REFRESH CYCLIC_REFRESH;
// Estimate the bits, incorporating the delta-q from segment 1, after encoding
// the frame.
-int vp10_cyclic_refresh_estimate_bits_at_q(const struct VP9_COMP *cpi,
+int vp10_cyclic_refresh_estimate_bits_at_q(const struct VP10_COMP *cpi,
double correction_factor);
// Estimate the bits per mb, for a given q = i and a corresponding delta-q
// (for segment 1), prior to encoding the frame.
-int vp10_cyclic_refresh_rc_bits_per_mb(const struct VP9_COMP *cpi, int i,
+int vp10_cyclic_refresh_rc_bits_per_mb(const struct VP10_COMP *cpi, int i,
double correction_factor);
// Prior to coding a given prediction block, of size bsize at (mi_row, mi_col),
// check if we should reset the segment_id, and update the cyclic_refresh map
// and segmentation map.
-void vp10_cyclic_refresh_update_segment(struct VP9_COMP *const cpi,
+void vp10_cyclic_refresh_update_segment(struct VP10_COMP *const cpi,
MB_MODE_INFO *const mbmi,
int mi_row, int mi_col, BLOCK_SIZE bsize,
int64_t rate, int64_t dist, int skip);
// Update the segmentation map, and related quantities: cyclic refresh map,
// refresh sb_index, and target number of blocks to be refreshed.
-void vp10_cyclic_refresh_update__map(struct VP9_COMP *const cpi);
+void vp10_cyclic_refresh_update__map(struct VP10_COMP *const cpi);
// Update the actual number of blocks that were applied the segment delta q.
-void vp10_cyclic_refresh_postencode(struct VP9_COMP *const cpi);
+void vp10_cyclic_refresh_postencode(struct VP10_COMP *const cpi);
// Set golden frame update interval, for non-svc 1 pass CBR mode.
-void vp10_cyclic_refresh_set_golden_update(struct VP9_COMP *const cpi);
+void vp10_cyclic_refresh_set_golden_update(struct VP10_COMP *const cpi);
// Check if we should not update golden reference, based on past refresh stats.
-void vp10_cyclic_refresh_check_golden_update(struct VP9_COMP *const cpi);
+void vp10_cyclic_refresh_check_golden_update(struct VP10_COMP *const cpi);
// Set/update global/frame level refresh parameters.
-void vp10_cyclic_refresh_update_parameters(struct VP9_COMP *const cpi);
+void vp10_cyclic_refresh_update_parameters(struct VP10_COMP *const cpi);
// Setup cyclic background refresh: set delta q and segmentation map.
-void vp10_cyclic_refresh_setup(struct VP9_COMP *const cpi);
+void vp10_cyclic_refresh_setup(struct VP10_COMP *const cpi);
int vp10_cyclic_refresh_get_rdmult(const CYCLIC_REFRESH *cr);
-void vp10_cyclic_refresh_reset_resize(struct VP9_COMP *const cpi);
+void vp10_cyclic_refresh_reset_resize(struct VP10_COMP *const cpi);
static INLINE int cyclic_refresh_segment_id_boosted(int segment_id) {
return segment_id == CR_SEGMENT_ID_BOOST1 ||
return SEGMENT_ID(energy);
}
-void vp10_vaq_frame_setup(VP9_COMP *cpi) {
+void vp10_vaq_frame_setup(VP10_COMP *cpi) {
VP10_COMMON *cm = &cpi->common;
struct segmentation *seg = &cm->seg;
int i;
}
#endif // CONFIG_VP9_HIGHBITDEPTH
-static unsigned int block_variance(VP9_COMP *cpi, MACROBLOCK *x,
+static unsigned int block_variance(VP10_COMP *cpi, MACROBLOCK *x,
BLOCK_SIZE bs) {
MACROBLOCKD *xd = &x->e_mbd;
unsigned int var, sse;
}
}
-double vp10_log_block_var(VP9_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bs) {
+double vp10_log_block_var(VP10_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bs) {
unsigned int var = block_variance(cpi, x, bs);
vpx_clear_system_state();
return log(var + 1.0);
}
#define DEFAULT_E_MIDPOINT 10.0
-int vp10_block_energy(VP9_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bs) {
+int vp10_block_energy(VP10_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bs) {
double energy;
double energy_midpoint;
vpx_clear_system_state();
#endif
unsigned int vp10_vaq_segment_id(int energy);
-void vp10_vaq_frame_setup(VP9_COMP *cpi);
+void vp10_vaq_frame_setup(VP10_COMP *cpi);
-int vp10_block_energy(VP9_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bs);
-double vp10_log_block_var(VP9_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bs);
+int vp10_block_energy(VP10_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bs);
+double vp10_log_block_var(VP10_COMP *cpi, MACROBLOCK *x, BLOCK_SIZE bs);
#ifdef __cplusplus
} // extern "C"
}
}
-static void pack_inter_mode_mvs(VP9_COMP *cpi, const MODE_INFO *mi,
+static void pack_inter_mode_mvs(VP10_COMP *cpi, const MODE_INFO *mi,
vpx_writer *w) {
VP10_COMMON *const cm = &cpi->common;
const nmv_context *nmvc = &cm->fc->nmvc;
write_intra_mode(w, mbmi->uv_mode, vp10_kf_uv_mode_prob[mbmi->mode]);
}
-static void write_modes_b(VP9_COMP *cpi, const TileInfo *const tile,
+static void write_modes_b(VP10_COMP *cpi, const TileInfo *const tile,
vpx_writer *w, TOKENEXTRA **tok,
const TOKENEXTRA *const tok_end,
int mi_row, int mi_col) {
}
}
-static void write_modes_sb(VP9_COMP *cpi,
+static void write_modes_sb(VP10_COMP *cpi,
const TileInfo *const tile, vpx_writer *w,
TOKENEXTRA **tok, const TOKENEXTRA *const tok_end,
int mi_row, int mi_col, BLOCK_SIZE bsize) {
update_partition_context(xd, mi_row, mi_col, subsize, bsize);
}
-static void write_modes(VP9_COMP *cpi,
+static void write_modes(VP10_COMP *cpi,
const TileInfo *const tile, vpx_writer *w,
TOKENEXTRA **tok, const TOKENEXTRA *const tok_end) {
const VP10_COMMON *const cm = &cpi->common;
}
}
-static void build_tree_distribution(VP9_COMP *cpi, TX_SIZE tx_size,
+static void build_tree_distribution(VP10_COMP *cpi, TX_SIZE tx_size,
vp10_coeff_stats *coef_branch_ct,
vp10_coeff_probs_model *coef_probs) {
vp10_coeff_count *coef_counts = cpi->td.rd_counts.coef_counts[tx_size];
}
}
-static void update_coef_probs_common(vpx_writer* const bc, VP9_COMP *cpi,
+static void update_coef_probs_common(vpx_writer* const bc, VP10_COMP *cpi,
TX_SIZE tx_size,
vp10_coeff_stats *frame_branch_ct,
vp10_coeff_probs_model *new_coef_probs) {
}
}
-static void update_coef_probs(VP9_COMP *cpi, vpx_writer* w) {
+static void update_coef_probs(VP10_COMP *cpi, vpx_writer* w) {
const TX_MODE tx_mode = cpi->common.tx_mode;
const TX_SIZE max_tx_size = tx_mode_to_biggest_tx_size[tx_mode];
TX_SIZE tx_size;
vpx_wb_write_bit(wb, cm->log2_tile_rows != 1);
}
-static int get_refresh_mask(VP9_COMP *cpi) {
+static int get_refresh_mask(VP10_COMP *cpi) {
if (vp10_preserve_existing_gf(cpi)) {
// We have decided to preserve the previously existing golden frame as our
// new ARF frame. However, in the short term we leave it in the GF slot and,
}
}
-static size_t encode_tiles(VP9_COMP *cpi, uint8_t *data_ptr) {
+static size_t encode_tiles(VP10_COMP *cpi, uint8_t *data_ptr) {
VP10_COMMON *const cm = &cpi->common;
vpx_writer residual_bc;
int tile_row, tile_col;
write_display_size(cm, wb);
}
-static void write_frame_size_with_refs(VP9_COMP *cpi,
+static void write_frame_size_with_refs(VP10_COMP *cpi,
struct vpx_write_bit_buffer *wb) {
VP10_COMMON *const cm = &cpi->common;
int found = 0;
}
}
-static void write_uncompressed_header(VP9_COMP *cpi,
+static void write_uncompressed_header(VP10_COMP *cpi,
struct vpx_write_bit_buffer *wb) {
VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
write_tile_info(cm, wb);
}
-static size_t write_compressed_header(VP9_COMP *cpi, uint8_t *data) {
+static size_t write_compressed_header(VP10_COMP *cpi, uint8_t *data) {
VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
FRAME_CONTEXT *const fc = cm->fc;
return header_bc.pos;
}
-void vp10_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, size_t *size) {
+void vp10_pack_bitstream(VP10_COMP *cpi, uint8_t *dest, size_t *size) {
uint8_t *data = dest;
size_t first_part_size, uncompressed_hdr_size;
struct vpx_write_bit_buffer wb = {data, 0};
#include "vp10/encoder/encoder.h"
-void vp10_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, size_t *size);
+void vp10_pack_bitstream(VP10_COMP *cpi, uint8_t *dest, size_t *size);
-static INLINE int vp10_preserve_existing_gf(VP9_COMP *cpi) {
+static INLINE int vp10_preserve_existing_gf(VP10_COMP *cpi) {
return !cpi->multi_arf_allowed && cpi->refresh_golden_frame &&
cpi->rc.is_src_frame_alt_ref &&
(!cpi->use_svc || // Add spatial svc base layer case here
#include "vp10/common/blockd.h"
#include "vp10/encoder/block.h"
-struct VP9_COMP;
+struct VP10_COMP;
struct VP9Common;
struct ThreadData;
#include "vp10/encoder/segmentation.h"
#include "vp10/encoder/tokenize.h"
-static void encode_superblock(VP9_COMP *cpi, ThreadData * td,
+static void encode_superblock(VP10_COMP *cpi, ThreadData * td,
TOKENEXTRA **t, int output_enabled,
int mi_row, int mi_col, BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx);
};
#endif // CONFIG_VP9_HIGHBITDEPTH
-unsigned int vp10_get_sby_perpixel_variance(VP9_COMP *cpi,
+unsigned int vp10_get_sby_perpixel_variance(VP10_COMP *cpi,
const struct buf_2d *ref,
BLOCK_SIZE bs) {
unsigned int sse;
#if CONFIG_VP9_HIGHBITDEPTH
unsigned int vp10_high_get_sby_perpixel_variance(
- VP9_COMP *cpi, const struct buf_2d *ref, BLOCK_SIZE bs, int bd) {
+ VP10_COMP *cpi, const struct buf_2d *ref, BLOCK_SIZE bs, int bd) {
unsigned int var, sse;
switch (bd) {
case 10:
}
#endif // CONFIG_VP9_HIGHBITDEPTH
-static unsigned int get_sby_perpixel_diff_variance(VP9_COMP *cpi,
+static unsigned int get_sby_perpixel_diff_variance(VP10_COMP *cpi,
const struct buf_2d *ref,
int mi_row, int mi_col,
BLOCK_SIZE bs) {
return ROUND_POWER_OF_TWO(var, num_pels_log2_lookup[bs]);
}
-static BLOCK_SIZE get_rd_var_based_fixed_partition(VP9_COMP *cpi, MACROBLOCK *x,
+static BLOCK_SIZE get_rd_var_based_fixed_partition(VP10_COMP *cpi,
+ MACROBLOCK *x,
int mi_row,
int mi_col) {
unsigned int var = get_sby_perpixel_diff_variance(cpi, &x->plane[0].src,
x->mbmi_ext = x->mbmi_ext_base + (mi_row * cm->mi_cols + mi_col);
}
-static void set_offsets(VP9_COMP *cpi, const TileInfo *const tile,
+static void set_offsets(VP10_COMP *cpi, const TileInfo *const tile,
MACROBLOCK *const x, int mi_row, int mi_col,
BLOCK_SIZE bsize) {
VP10_COMMON *const cm = &cpi->common;
}
}
-static void set_block_size(VP9_COMP * const cpi,
+static void set_block_size(VP10_COMP * const cpi,
MACROBLOCK *const x,
MACROBLOCKD *const xd,
int mi_row, int mi_col,
&node.part_variances->none);
}
-static int set_vt_partitioning(VP9_COMP *cpi,
+static int set_vt_partitioning(VP10_COMP *cpi,
MACROBLOCK *const x,
MACROBLOCKD *const xd,
void *data,
// 0 - threshold_64x64, 1 - threshold_32x32, 2 - threshold_16x16,
// 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) {
+static void set_vbp_thresholds(VP10_COMP *cpi, int64_t thresholds[], int q) {
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;
}
}
-void vp10_set_variance_partition_thresholds(VP9_COMP *cpi, int q) {
+void vp10_set_variance_partition_thresholds(VP10_COMP *cpi, int q) {
VP10_COMMON *const cm = &cpi->common;
SPEED_FEATURES *const sf = &cpi->sf;
const int is_key_frame = (cm->frame_type == KEY_FRAME);
// This function chooses partitioning based on the variance between source and
// reconstructed last, where variance is computed for down-sampled inputs.
-static int choose_partitioning(VP9_COMP *cpi,
+static int choose_partitioning(VP10_COMP *cpi,
const TileInfo *const tile,
MACROBLOCK *x,
int mi_row, int mi_col) {
return 0;
}
-static void update_state(VP9_COMP *cpi, ThreadData *td,
+static void update_state(VP10_COMP *cpi, ThreadData *td,
PICK_MODE_CONTEXT *ctx,
int mi_row, int mi_col, BLOCK_SIZE bsize,
int output_enabled) {
vp10_rd_cost_init(rd_cost);
}
-static int set_segment_rdmult(VP9_COMP *const cpi,
+static int set_segment_rdmult(VP10_COMP *const cpi,
MACROBLOCK *const x,
int8_t segment_id) {
int segment_qindex;
return vp10_compute_rd_mult(cpi, segment_qindex + cm->y_dc_delta_q);
}
-static void rd_pick_sb_modes(VP9_COMP *cpi,
+static void rd_pick_sb_modes(VP10_COMP *cpi,
TileDataEnc *tile_data,
MACROBLOCK *const x,
int mi_row, int mi_col, RD_COST *rd_cost,
sizeof(xd->left_seg_context[0]) * mi_height);
}
-static void encode_b(VP9_COMP *cpi, const TileInfo *const tile,
+static void encode_b(VP10_COMP *cpi, const TileInfo *const tile,
ThreadData *td,
TOKENEXTRA **tp, int mi_row, int mi_col,
int output_enabled, BLOCK_SIZE bsize,
}
}
-static void encode_sb(VP9_COMP *cpi, ThreadData *td,
+static void encode_sb(VP10_COMP *cpi, ThreadData *td,
const TileInfo *const tile,
TOKENEXTRA **tp, int mi_row, int mi_col,
int output_enabled, BLOCK_SIZE bsize,
// However, at the bottom and right borders of the image the requested size
// may not be allowed in which case this code attempts to choose the largest
// allowable partition.
-static void set_fixed_partitioning(VP9_COMP *cpi, const TileInfo *const tile,
+static void set_fixed_partitioning(VP10_COMP *cpi, const TileInfo *const tile,
MODE_INFO **mi_8x8, int mi_row, int mi_col,
BLOCK_SIZE bsize) {
VP10_COMMON *const cm = &cpi->common;
{4, 4}, {4, 6}, {6, 4}, {6, 6},
};
-static void set_source_var_based_partition(VP9_COMP *cpi,
+static void set_source_var_based_partition(VP10_COMP *cpi,
const TileInfo *const tile,
MACROBLOCK *const x,
MODE_INFO **mi_8x8,
}
}
-static void update_state_rt(VP9_COMP *cpi, ThreadData *td,
+static void update_state_rt(VP10_COMP *cpi, ThreadData *td,
PICK_MODE_CONTEXT *ctx,
int mi_row, int mi_col, int bsize) {
VP10_COMMON *const cm = &cpi->common;
x->skip_txfm[0] = mbmi->segment_id ? 0 : ctx->skip_txfm[0];
}
-static void encode_b_rt(VP9_COMP *cpi, ThreadData *td,
+static void encode_b_rt(VP10_COMP *cpi, ThreadData *td,
const TileInfo *const tile,
TOKENEXTRA **tp, int mi_row, int mi_col,
int output_enabled, BLOCK_SIZE bsize,
(*tp)++;
}
-static void encode_sb_rt(VP9_COMP *cpi, ThreadData *td,
+static void encode_sb_rt(VP10_COMP *cpi, ThreadData *td,
const TileInfo *const tile,
TOKENEXTRA **tp, int mi_row, int mi_col,
int output_enabled, BLOCK_SIZE bsize,
update_partition_context(xd, mi_row, mi_col, subsize, bsize);
}
-static void rd_use_partition(VP9_COMP *cpi,
+static void rd_use_partition(VP10_COMP *cpi,
ThreadData *td,
TileDataEnc *tile_data,
MODE_INFO **mi_8x8, TOKENEXTRA **tp,
// Look at neighboring blocks and set a min and max partition size based on
// what they chose.
-static void rd_auto_partition_range(VP9_COMP *cpi, const TileInfo *const tile,
+static void rd_auto_partition_range(VP10_COMP *cpi, const TileInfo *const tile,
MACROBLOCKD *const xd,
int mi_row, int mi_col,
BLOCK_SIZE *min_block_size,
// TODO(jingning,jimbankoski,rbultje): properly skip partition types that are
// unlikely to be selected depending on previous rate-distortion optimization
// results, for encoding speed-up.
-static void rd_pick_partition(VP9_COMP *cpi, ThreadData *td,
+static void rd_pick_partition(VP10_COMP *cpi, ThreadData *td,
TileDataEnc *tile_data,
TOKENEXTRA **tp, int mi_row, int mi_col,
BLOCK_SIZE bsize, RD_COST *rd_cost,
}
}
-static void encode_rd_sb_row(VP9_COMP *cpi,
+static void encode_rd_sb_row(VP10_COMP *cpi,
ThreadData *td,
TileDataEnc *tile_data,
int mi_row,
}
}
-static void init_encode_frame_mb_context(VP9_COMP *cpi) {
+static void init_encode_frame_mb_context(VP10_COMP *cpi) {
MACROBLOCK *const x = &cpi->td.mb;
VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
sizeof(*xd->above_seg_context) * aligned_mi_cols);
}
-static int check_dual_ref_flags(VP9_COMP *cpi) {
+static int check_dual_ref_flags(VP10_COMP *cpi) {
const int ref_flags = cpi->ref_frame_flags;
if (segfeature_active(&cpi->common.seg, 1, SEG_LVL_REF_FRAME)) {
}
}
-static MV_REFERENCE_FRAME get_frame_type(const VP9_COMP *cpi) {
+static MV_REFERENCE_FRAME get_frame_type(const VP10_COMP *cpi) {
if (frame_is_intra_only(&cpi->common))
return INTRA_FRAME;
else if (cpi->rc.is_src_frame_alt_ref && cpi->refresh_golden_frame)
return LAST_FRAME;
}
-static TX_MODE select_tx_mode(const VP9_COMP *cpi, MACROBLOCKD *const xd) {
+static TX_MODE select_tx_mode(const VP10_COMP *cpi, MACROBLOCKD *const xd) {
if (xd->lossless)
return ONLY_4X4;
if (cpi->common.frame_type == KEY_FRAME &&
return cpi->common.tx_mode;
}
-static void hybrid_intra_mode_search(VP9_COMP *cpi, MACROBLOCK *const x,
+static void hybrid_intra_mode_search(VP10_COMP *cpi, MACROBLOCK *const x,
RD_COST *rd_cost, BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx) {
if (bsize < BLOCK_16X16)
vp10_pick_intra_mode(cpi, x, rd_cost, bsize, ctx);
}
-static void nonrd_pick_sb_modes(VP9_COMP *cpi,
+static void nonrd_pick_sb_modes(VP10_COMP *cpi,
TileDataEnc *tile_data, MACROBLOCK *const x,
int mi_row, int mi_col, RD_COST *rd_cost,
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) {
}
}
-static void nonrd_pick_partition(VP9_COMP *cpi, ThreadData *td,
+static void nonrd_pick_partition(VP10_COMP *cpi, ThreadData *td,
TileDataEnc *tile_data,
TOKENEXTRA **tp, int mi_row,
int mi_col, BLOCK_SIZE bsize, RD_COST *rd_cost,
}
}
-static void nonrd_select_partition(VP9_COMP *cpi,
+static void nonrd_select_partition(VP10_COMP *cpi,
ThreadData *td,
TileDataEnc *tile_data,
MODE_INFO **mi,
}
-static void nonrd_use_partition(VP9_COMP *cpi,
+static void nonrd_use_partition(VP10_COMP *cpi,
ThreadData *td,
TileDataEnc *tile_data,
MODE_INFO **mi,
update_partition_context(xd, mi_row, mi_col, subsize, bsize);
}
-static void encode_nonrd_sb_row(VP9_COMP *cpi,
+static void encode_nonrd_sb_row(VP10_COMP *cpi,
ThreadData *td,
TileDataEnc *tile_data,
int mi_row,
}
// end RTC play code
-static int set_var_thresh_from_histogram(VP9_COMP *cpi) {
+static int set_var_thresh_from_histogram(VP10_COMP *cpi) {
const SPEED_FEATURES *const sf = &cpi->sf;
const VP10_COMMON *const cm = &cpi->common;
return sf->search_type_check_frequency;
}
-static void source_var_based_partition_search_method(VP9_COMP *cpi) {
+static void source_var_based_partition_search_method(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
SPEED_FEATURES *const sf = &cpi->sf;
cm->show_frame;
}
-void vp10_init_tile_data(VP9_COMP *cpi) {
+void vp10_init_tile_data(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
const int tile_cols = 1 << cm->log2_tile_cols;
const int tile_rows = 1 << cm->log2_tile_rows;
}
}
-void vp10_encode_tile(VP9_COMP *cpi, ThreadData *td,
+void vp10_encode_tile(VP10_COMP *cpi, ThreadData *td,
int tile_row, int tile_col) {
VP10_COMMON *const cm = &cpi->common;
const int tile_cols = 1 << cm->log2_tile_cols;
allocated_tokens(*tile_info));
}
-static void encode_tiles(VP9_COMP *cpi) {
+static void encode_tiles(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
const int tile_cols = 1 << cm->log2_tile_cols;
const int tile_rows = 1 << cm->log2_tile_rows;
}
#endif
-static void encode_frame_internal(VP9_COMP *cpi) {
+static void encode_frame_internal(VP10_COMP *cpi) {
SPEED_FEATURES *const sf = &cpi->sf;
ThreadData *const td = &cpi->td;
MACROBLOCK *const x = &td->mb;
}
}
-void vp10_encode_frame(VP9_COMP *cpi) {
+void vp10_encode_frame(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
// In the longer term the encoder should be generalized to match the
++counts->uv_mode[y_mode][uv_mode];
}
-static void encode_superblock(VP9_COMP *cpi, ThreadData *td,
+static void encode_superblock(VP10_COMP *cpi, ThreadData *td,
TOKENEXTRA **t, int output_enabled,
int mi_row, int mi_col, BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx) {
struct macroblock;
struct yv12_buffer_config;
-struct VP9_COMP;
+struct VP10_COMP;
struct ThreadData;
// Constants used in SOURCE_VAR_BASED_PARTITION
const struct yv12_buffer_config *src,
int mi_row, int mi_col);
-void vp10_encode_frame(struct VP9_COMP *cpi);
+void vp10_encode_frame(struct VP10_COMP *cpi);
-void vp10_init_tile_data(struct VP9_COMP *cpi);
-void vp10_encode_tile(struct VP9_COMP *cpi, struct ThreadData *td,
+void vp10_init_tile_data(struct VP10_COMP *cpi);
+void vp10_encode_tile(struct VP10_COMP *cpi, struct ThreadData *td,
int tile_row, int tile_col);
-void vp10_set_variance_partition_thresholds(struct VP9_COMP *cpi, int q);
+void vp10_set_variance_partition_thresholds(struct VP10_COMP *cpi, int q);
#ifdef __cplusplus
} // extern "C"
}
}
-void vp10_encode_mv(VP9_COMP* cpi, vpx_writer* w,
+void vp10_encode_mv(VP10_COMP* cpi, vpx_writer* w,
const MV* mv, const MV* ref,
const nmv_context* mvctx, int usehp) {
const MV diff = {mv->row - ref->row,
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,
+void vp10_encode_mv(VP10_COMP *cpi, vpx_writer* w, const MV* mv, const MV* ref,
const nmv_context* mvctx, int usehp);
void vp10_build_nmv_cost_table(int *mvjoint, int *mvcost[2],
// Mark all inactive blocks as active. Other segmentation features may be set
// so memset cannot be used, instead only inactive blocks should be reset.
-static void suppress_active_map(VP9_COMP *cpi) {
+static void suppress_active_map(VP10_COMP *cpi) {
unsigned char *const seg_map = cpi->segmentation_map;
int i;
if (cpi->active_map.enabled || cpi->active_map.update)
seg_map[i] = AM_SEGMENT_ID_ACTIVE;
}
-static void apply_active_map(VP9_COMP *cpi) {
+static void apply_active_map(VP10_COMP *cpi) {
struct segmentation *const seg = &cpi->common.seg;
unsigned char *const seg_map = cpi->segmentation_map;
const unsigned char *const active_map = cpi->active_map.map;
}
}
-int vp10_set_active_map(VP9_COMP* cpi,
+int vp10_set_active_map(VP10_COMP* cpi,
unsigned char* new_map_16x16,
int rows,
int cols) {
}
}
-int vp10_get_active_map(VP9_COMP* cpi,
+int vp10_get_active_map(VP10_COMP* cpi,
unsigned char* new_map_16x16,
int rows,
int cols) {
}
}
-void vp10_set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv) {
+void vp10_set_high_precision_mv(VP10_COMP *cpi, int allow_high_precision_mv) {
MACROBLOCK *const mb = &cpi->td.mb;
cpi->common.allow_high_precision_mv = allow_high_precision_mv;
if (cpi->common.allow_high_precision_mv) {
}
}
-static void setup_frame(VP9_COMP *cpi) {
+static void setup_frame(VP10_COMP *cpi) {
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
}
}
-static void dealloc_compressor_data(VP9_COMP *cpi) {
+static void dealloc_compressor_data(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
int i;
memset(&cpi->svc.empty_frame, 0, sizeof(cpi->svc.empty_frame));
}
-static void save_coding_context(VP9_COMP *cpi) {
+static void save_coding_context(VP10_COMP *cpi) {
CODING_CONTEXT *const cc = &cpi->coding_context;
VP10_COMMON *cm = &cpi->common;
cc->fc = *cm->fc;
}
-static void restore_coding_context(VP9_COMP *cpi) {
+static void restore_coding_context(VP10_COMP *cpi) {
CODING_CONTEXT *const cc = &cpi->coding_context;
VP10_COMMON *cm = &cpi->common;
*cm->fc = cc->fc;
}
-static void configure_static_seg_features(VP9_COMP *cpi) {
+static void configure_static_seg_features(VP10_COMP *cpi) {
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) {
+static void update_reference_segmentation_map(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
MODE_INFO **mi_8x8_ptr = cm->mi_grid_visible;
uint8_t *cache_ptr = cm->last_frame_seg_map;
}
}
-static void alloc_raw_frame_buffers(VP9_COMP *cpi) {
+static void alloc_raw_frame_buffers(VP10_COMP *cpi) {
VP10_COMMON *cm = &cpi->common;
const VP9EncoderConfig *oxcf = &cpi->oxcf;
"Failed to allocate altref buffer");
}
-static void alloc_util_frame_buffers(VP9_COMP *cpi) {
+static void alloc_util_frame_buffers(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
if (vp9_realloc_frame_buffer(&cpi->last_frame_uf,
cm->width, cm->height,
}
-static int alloc_context_buffers_ext(VP9_COMP *cpi) {
+static int alloc_context_buffers_ext(VP10_COMP *cpi) {
VP10_COMMON *cm = &cpi->common;
int mi_size = cm->mi_cols * cm->mi_rows;
return 0;
}
-void vp10_alloc_compressor_data(VP9_COMP *cpi) {
+void vp10_alloc_compressor_data(VP10_COMP *cpi) {
VP10_COMMON *cm = &cpi->common;
vp10_alloc_context_buffers(cm, cm->width, cm->height);
vp10_setup_pc_tree(&cpi->common, &cpi->td);
}
-void vp10_new_framerate(VP9_COMP *cpi, double framerate) {
+void vp10_new_framerate(VP10_COMP *cpi, double framerate) {
cpi->framerate = framerate < 0.1 ? 30 : framerate;
vp10_rc_update_framerate(cpi);
}
-static void set_tile_limits(VP9_COMP *cpi) {
+static void set_tile_limits(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
int min_log2_tile_cols, max_log2_tile_cols;
}
}
-static void update_frame_size(VP9_COMP *cpi) {
+static void update_frame_size(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
}
}
-static void init_buffer_indices(VP9_COMP *cpi) {
+static void init_buffer_indices(VP10_COMP *cpi) {
cpi->lst_fb_idx = 0;
cpi->gld_fb_idx = 1;
cpi->alt_fb_idx = 2;
}
-static void init_config(struct VP9_COMP *cpi, VP9EncoderConfig *oxcf) {
+static void init_config(struct VP10_COMP *cpi, VP9EncoderConfig *oxcf) {
VP10_COMMON *const cm = &cpi->common;
cpi->oxcf = *oxcf;
MAKE_BFP_SAD8_WRAPPER(vpx_highbd_sad4x4x8)
MAKE_BFP_SAD4D_WRAPPER(vpx_highbd_sad4x4x4d)
-static void highbd_set_var_fns(VP9_COMP *const cpi) {
+static void highbd_set_var_fns(VP10_COMP *const cpi) {
VP10_COMMON *const cm = &cpi->common;
if (cm->use_highbitdepth) {
switch (cm->bit_depth) {
}
#endif // CONFIG_VP9_HIGHBITDEPTH
-static void realloc_segmentation_maps(VP9_COMP *cpi) {
+static void realloc_segmentation_maps(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
// Create the encoder segmentation map and set all entries to 0
vpx_calloc(cm->mi_rows * cm->mi_cols, 1));
}
-void vp10_change_config(struct VP9_COMP *cpi, const VP9EncoderConfig *oxcf) {
+void vp10_change_config(struct VP10_COMP *cpi, const VP9EncoderConfig *oxcf) {
VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
}
-VP9_COMP *vp10_create_compressor(VP9EncoderConfig *oxcf,
+VP10_COMP *vp10_create_compressor(VP9EncoderConfig *oxcf,
BufferPool *const pool) {
unsigned int i;
- VP9_COMP *volatile const cpi = vpx_memalign(32, sizeof(VP9_COMP));
+ VP10_COMP *volatile const cpi = vpx_memalign(32, sizeof(VP10_COMP));
VP10_COMMON *volatile const cm = cpi != NULL ? &cpi->common : NULL;
if (!cm)
#define SNPRINT2(H, T, V) \
snprintf((H) + strlen(H), sizeof(H) - strlen(H), (T), (V))
-void vp10_remove_compressor(VP9_COMP *cpi) {
+void vp10_remove_compressor(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
unsigned int i;
int t;
}
#endif // CONFIG_VP9_HIGHBITDEPTH
-static void generate_psnr_packet(VP9_COMP *cpi) {
+static void generate_psnr_packet(VP10_COMP *cpi) {
struct vpx_codec_cx_pkt pkt;
int i;
PSNR_STATS psnr;
vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
}
-int vp10_use_as_reference(VP9_COMP *cpi, int ref_frame_flags) {
+int vp10_use_as_reference(VP10_COMP *cpi, int ref_frame_flags) {
if (ref_frame_flags > 7)
return -1;
return 0;
}
-void vp10_update_reference(VP9_COMP *cpi, int ref_frame_flags) {
+void vp10_update_reference(VP10_COMP *cpi, int ref_frame_flags) {
cpi->ext_refresh_golden_frame = (ref_frame_flags & VP9_GOLD_FLAG) != 0;
cpi->ext_refresh_alt_ref_frame = (ref_frame_flags & VP9_ALT_FLAG) != 0;
cpi->ext_refresh_last_frame = (ref_frame_flags & VP9_LAST_FLAG) != 0;
cpi->ext_refresh_frame_flags_pending = 1;
}
-static YV12_BUFFER_CONFIG *get_vp10_ref_frame_buffer(VP9_COMP *cpi,
+static YV12_BUFFER_CONFIG *get_vp10_ref_frame_buffer(VP10_COMP *cpi,
VP9_REFFRAME ref_frame_flag) {
MV_REFERENCE_FRAME ref_frame = NONE;
if (ref_frame_flag == VP9_LAST_FLAG)
return ref_frame == NONE ? NULL : get_ref_frame_buffer(cpi, ref_frame);
}
-int vp10_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
+int vp10_copy_reference_enc(VP10_COMP *cpi, VP9_REFFRAME ref_frame_flag,
YV12_BUFFER_CONFIG *sd) {
YV12_BUFFER_CONFIG *cfg = get_vp10_ref_frame_buffer(cpi, ref_frame_flag);
if (cfg) {
}
}
-int vp10_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
+int vp10_set_reference_enc(VP10_COMP *cpi, VP9_REFFRAME ref_frame_flag,
YV12_BUFFER_CONFIG *sd) {
YV12_BUFFER_CONFIG *cfg = get_vp10_ref_frame_buffer(cpi, ref_frame_flag);
if (cfg) {
}
}
-int vp10_update_entropy(VP9_COMP * cpi, int update) {
+int vp10_update_entropy(VP10_COMP * cpi, int update) {
cpi->ext_refresh_frame_context = update;
cpi->ext_refresh_frame_context_pending = 1;
return 0;
vp9_extend_frame_borders(dst);
}
-static int scale_down(VP9_COMP *cpi, int q) {
+static int scale_down(VP10_COMP *cpi, int q) {
RATE_CONTROL *const rc = &cpi->rc;
GF_GROUP *const gf_group = &cpi->twopass.gf_group;
int scale = 0;
// Function to test for conditions that indicate we should loop
// back and recode a frame.
-static int recode_loop_test(VP9_COMP *cpi,
+static int recode_loop_test(VP10_COMP *cpi,
int high_limit, int low_limit,
int q, int maxq, int minq) {
const RATE_CONTROL *const rc = &cpi->rc;
return force_recode;
}
-void vp10_update_reference_frames(VP9_COMP *cpi) {
+void vp10_update_reference_frames(VP10_COMP *cpi) {
VP10_COMMON * const cm = &cpi->common;
BufferPool *const pool = cm->buffer_pool;
#endif
}
-static void loopfilter_frame(VP9_COMP *cpi, VP10_COMMON *cm) {
+static void loopfilter_frame(VP10_COMP *cpi, VP10_COMMON *cm) {
MACROBLOCKD *xd = &cpi->td.mb.e_mbd;
struct loopfilter *lf = &cm->lf;
if (xd->lossless) {
}
}
-void vp10_scale_references(VP9_COMP *cpi) {
+void vp10_scale_references(VP10_COMP *cpi) {
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) {
+static void release_scaled_references(VP10_COMP *cpi) {
VP10_COMMON *cm = &cpi->common;
int i;
if (cpi->oxcf.pass == 0 && !cpi->use_svc) {
}
#if 0 && CONFIG_INTERNAL_STATS
-static void output_frame_level_debug_stats(VP9_COMP *cpi) {
+static void output_frame_level_debug_stats(VP10_COMP *cpi) {
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) {
+static void set_mv_search_params(VP10_COMP *cpi) {
const VP10_COMMON *const cm = &cpi->common;
const unsigned int max_mv_def = MIN(cm->width, cm->height);
}
}
-static void set_size_independent_vars(VP9_COMP *cpi) {
+static void set_size_independent_vars(VP10_COMP *cpi) {
vp10_set_speed_features_framesize_independent(cpi);
vp10_set_rd_speed_thresholds(cpi);
vp10_set_rd_speed_thresholds_sub8x8(cpi);
cpi->common.interp_filter = cpi->sf.default_interp_filter;
}
-static void set_size_dependent_vars(VP9_COMP *cpi, int *q,
+static void set_size_dependent_vars(VP10_COMP *cpi, int *q,
int *bottom_index, int *top_index) {
VP10_COMMON *const cm = &cpi->common;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
#endif // CONFIG_VP9_POSTPROC
}
-static void init_motion_estimation(VP9_COMP *cpi) {
+static void init_motion_estimation(VP10_COMP *cpi) {
int y_stride = cpi->scaled_source.y_stride;
if (cpi->sf.mv.search_method == NSTEP) {
}
}
-static void set_frame_size(VP9_COMP *cpi) {
+static void set_frame_size(VP10_COMP *cpi) {
int ref_frame;
VP10_COMMON *const cm = &cpi->common;
VP9EncoderConfig *const oxcf = &cpi->oxcf;
set_ref_ptrs(cm, xd, LAST_FRAME, LAST_FRAME);
}
-static void encode_without_recode_loop(VP9_COMP *cpi) {
+static void encode_without_recode_loop(VP10_COMP *cpi) {
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,
+static void encode_with_recode_loop(VP10_COMP *cpi,
size_t *size,
uint8_t *dest) {
VP10_COMMON *const cm = &cpi->common;
} while (loop);
}
-static int get_ref_frame_flags(const VP9_COMP *cpi) {
+static int get_ref_frame_flags(const VP10_COMP *cpi) {
const int *const map = cpi->common.ref_frame_map;
const int gold_is_last = map[cpi->gld_fb_idx] == map[cpi->lst_fb_idx];
const int alt_is_last = map[cpi->alt_fb_idx] == map[cpi->lst_fb_idx];
return flags;
}
-static void set_ext_overrides(VP9_COMP *cpi) {
+static void set_ext_overrides(VP10_COMP *cpi) {
// Overrides the defaults with the externally supplied values with
// vp10_update_reference() and vp10_update_entropy() calls
// Note: The overrides are valid only for the next frame passed
}
}
-static void set_arf_sign_bias(VP9_COMP *cpi) {
+static void set_arf_sign_bias(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
int arf_sign_bias;
cm->ref_frame_sign_bias[ALTREF_FRAME] = arf_sign_bias;
}
-static int setup_interp_filter_search_mask(VP9_COMP *cpi) {
+static int setup_interp_filter_search_mask(VP10_COMP *cpi) {
INTERP_FILTER ifilter;
int ref_total[MAX_REF_FRAMES] = {0};
MV_REFERENCE_FRAME ref;
return mask;
}
-static void encode_frame_to_data_rate(VP9_COMP *cpi,
+static void encode_frame_to_data_rate(VP10_COMP *cpi,
size_t *size,
uint8_t *dest,
unsigned int *frame_flags) {
cm->frame_type;
}
-static void SvcEncode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
+static void SvcEncode(VP10_COMP *cpi, size_t *size, uint8_t *dest,
unsigned int *frame_flags) {
vp10_rc_get_svc_params(cpi);
encode_frame_to_data_rate(cpi, size, dest, frame_flags);
}
-static void Pass0Encode(VP9_COMP *cpi, size_t *size, uint8_t *dest,
+static void Pass0Encode(VP10_COMP *cpi, size_t *size, uint8_t *dest,
unsigned int *frame_flags) {
if (cpi->oxcf.rc_mode == VPX_CBR) {
vp10_rc_get_one_pass_cbr_params(cpi);
encode_frame_to_data_rate(cpi, size, dest, frame_flags);
}
-static void Pass2Encode(VP9_COMP *cpi, size_t *size,
+static void Pass2Encode(VP10_COMP *cpi, size_t *size,
uint8_t *dest, unsigned int *frame_flags) {
cpi->allow_encode_breakout = ENCODE_BREAKOUT_ENABLED;
encode_frame_to_data_rate(cpi, size, dest, frame_flags);
}
}
-static void check_initial_width(VP9_COMP *cpi,
+static void check_initial_width(VP10_COMP *cpi,
#if CONFIG_VP9_HIGHBITDEPTH
int use_highbitdepth,
#endif
}
#if CONFIG_VP9_TEMPORAL_DENOISING
-static void setup_denoiser_buffer(VP9_COMP *cpi) {
+static void setup_denoiser_buffer(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
if (cpi->oxcf.noise_sensitivity > 0 &&
!cpi->denoiser.frame_buffer_initialized) {
}
#endif
-int vp10_receive_raw_frame(VP9_COMP *cpi, unsigned int frame_flags,
+int vp10_receive_raw_frame(VP10_COMP *cpi, unsigned int frame_flags,
YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
int64_t end_time) {
VP10_COMMON *cm = &cpi->common;
}
-static int frame_is_reference(const VP9_COMP *cpi) {
+static int frame_is_reference(const VP10_COMP *cpi) {
const VP10_COMMON *cm = &cpi->common;
return cm->frame_type == KEY_FRAME ||
cm->seg.update_data;
}
-static void adjust_frame_rate(VP9_COMP *cpi,
+static void adjust_frame_rate(VP10_COMP *cpi,
const struct lookahead_entry *source) {
int64_t this_duration;
int step = 0;
// Returns 0 if this is not an alt ref else the offset of the source frame
// used as the arf midpoint.
-static int get_arf_src_index(VP9_COMP *cpi) {
+static int get_arf_src_index(VP10_COMP *cpi) {
RATE_CONTROL *const rc = &cpi->rc;
int arf_src_index = 0;
if (is_altref_enabled(cpi)) {
return arf_src_index;
}
-static void check_src_altref(VP9_COMP *cpi,
+static void check_src_altref(VP10_COMP *cpi,
const struct lookahead_entry *source) {
RATE_CONTROL *const rc = &cpi->rc;
}
#endif // CONFIG_INTERNAL_STATS
-int vp10_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
+int vp10_get_compressed_data(VP10_COMP *cpi, unsigned int *frame_flags,
size_t *size, uint8_t *dest,
int64_t *time_stamp, int64_t *time_end, int flush) {
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
return 0;
}
-int vp10_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
+int vp10_get_preview_raw_frame(VP10_COMP *cpi, YV12_BUFFER_CONFIG *dest,
vp10_ppflags_t *flags) {
VP10_COMMON *cm = &cpi->common;
#if !CONFIG_VP9_POSTPROC
}
}
-int vp10_set_internal_size(VP9_COMP *cpi,
+int vp10_set_internal_size(VP10_COMP *cpi,
VPX_SCALING horiz_mode, VPX_SCALING vert_mode) {
VP10_COMMON *cm = &cpi->common;
int hr = 0, hs = 0, vr = 0, vs = 0;
return 0;
}
-int vp10_set_size_literal(VP9_COMP *cpi, unsigned int width,
+int vp10_set_size_literal(VP10_COMP *cpi, unsigned int width,
unsigned int height) {
VP10_COMMON *cm = &cpi->common;
#if CONFIG_VP9_HIGHBITDEPTH
return 0;
}
-void vp10_set_svc(VP9_COMP *cpi, int use_svc) {
+void vp10_set_svc(VP10_COMP *cpi, int use_svc) {
cpi->use_svc = use_svc;
return;
}
}
#endif // CONFIG_VP9_HIGHBITDEPTH
-int vp10_get_quantizer(VP9_COMP *cpi) {
+int vp10_get_quantizer(VP10_COMP *cpi) {
return cpi->common.base_qindex;
}
-void vp10_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags) {
+void vp10_apply_encoding_flags(VP10_COMP *cpi, vpx_enc_frame_flags_t flags) {
if (flags & (VP8_EFLAG_NO_REF_LAST | VP8_EFLAG_NO_REF_GF |
VP8_EFLAG_NO_REF_ARF)) {
int ref = 7;
double worst;
} ImageStat;
-typedef struct VP9_COMP {
+typedef struct VP10_COMP {
QUANTS quants;
ThreadData td;
MB_MODE_INFO_EXT *mbmi_ext_base;
VPxWorker *workers;
struct EncWorkerData *tile_thr_data;
VP9LfSync lf_row_sync;
-} VP9_COMP;
+} VP10_COMP;
void vp10_initialize_enc(void);
-struct VP9_COMP *vp10_create_compressor(VP9EncoderConfig *oxcf,
+struct VP10_COMP *vp10_create_compressor(VP9EncoderConfig *oxcf,
BufferPool *const pool);
-void vp10_remove_compressor(VP9_COMP *cpi);
+void vp10_remove_compressor(VP10_COMP *cpi);
-void vp10_change_config(VP9_COMP *cpi, const VP9EncoderConfig *oxcf);
+void vp10_change_config(VP10_COMP *cpi, const VP9EncoderConfig *oxcf);
// receive a frames worth of data. caller can assume that a copy of this
// frame is made and not just a copy of the pointer..
-int vp10_receive_raw_frame(VP9_COMP *cpi, unsigned int frame_flags,
+int vp10_receive_raw_frame(VP10_COMP *cpi, unsigned int frame_flags,
YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
int64_t end_time_stamp);
-int vp10_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
+int vp10_get_compressed_data(VP10_COMP *cpi, unsigned int *frame_flags,
size_t *size, uint8_t *dest,
int64_t *time_stamp, int64_t *time_end, int flush);
-int vp10_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
+int vp10_get_preview_raw_frame(VP10_COMP *cpi, YV12_BUFFER_CONFIG *dest,
vp10_ppflags_t *flags);
-int vp10_use_as_reference(VP9_COMP *cpi, int ref_frame_flags);
+int vp10_use_as_reference(VP10_COMP *cpi, int ref_frame_flags);
-void vp10_update_reference(VP9_COMP *cpi, int ref_frame_flags);
+void vp10_update_reference(VP10_COMP *cpi, int ref_frame_flags);
-int vp10_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
+int vp10_copy_reference_enc(VP10_COMP *cpi, VP9_REFFRAME ref_frame_flag,
YV12_BUFFER_CONFIG *sd);
-int vp10_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
+int vp10_set_reference_enc(VP10_COMP *cpi, VP9_REFFRAME ref_frame_flag,
YV12_BUFFER_CONFIG *sd);
-int vp10_update_entropy(VP9_COMP *cpi, int update);
+int vp10_update_entropy(VP10_COMP *cpi, int update);
-int vp10_set_active_map(VP9_COMP *cpi, unsigned char *map, int rows, int cols);
+int vp10_set_active_map(VP10_COMP *cpi, unsigned char *map, int rows, int cols);
-int vp10_get_active_map(VP9_COMP *cpi, unsigned char *map, int rows, int cols);
+int vp10_get_active_map(VP10_COMP *cpi, unsigned char *map, int rows, int cols);
-int vp10_set_internal_size(VP9_COMP *cpi,
+int vp10_set_internal_size(VP10_COMP *cpi,
VPX_SCALING horiz_mode, VPX_SCALING vert_mode);
-int vp10_set_size_literal(VP9_COMP *cpi, unsigned int width,
+int vp10_set_size_literal(VP10_COMP *cpi, unsigned int width,
unsigned int height);
-void vp10_set_svc(VP9_COMP *cpi, int use_svc);
+void vp10_set_svc(VP10_COMP *cpi, int use_svc);
-int vp10_get_quantizer(struct VP9_COMP *cpi);
+int vp10_get_quantizer(struct VP10_COMP *cpi);
-static INLINE int frame_is_kf_gf_arf(const VP9_COMP *cpi) {
+static INLINE int frame_is_kf_gf_arf(const VP10_COMP *cpi) {
return frame_is_intra_only(&cpi->common) ||
cpi->refresh_alt_ref_frame ||
(cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref);
}
-static INLINE int get_ref_frame_map_idx(const VP9_COMP *cpi,
+static INLINE int get_ref_frame_map_idx(const VP10_COMP *cpi,
MV_REFERENCE_FRAME ref_frame) {
if (ref_frame == LAST_FRAME) {
return cpi->lst_fb_idx;
}
}
-static INLINE int get_ref_frame_buf_idx(const VP9_COMP *const cpi,
+static INLINE int get_ref_frame_buf_idx(const VP10_COMP *const cpi,
int ref_frame) {
const VP10_COMMON *const cm = &cpi->common;
const int map_idx = get_ref_frame_map_idx(cpi, ref_frame);
}
static INLINE YV12_BUFFER_CONFIG *get_ref_frame_buffer(
- VP9_COMP *cpi, MV_REFERENCE_FRAME ref_frame) {
+ VP10_COMP *cpi, MV_REFERENCE_FRAME ref_frame) {
VP10_COMMON *const cm = &cpi->common;
const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
return
const YV12_BUFFER_CONFIG *b);
#endif // CONFIG_VP9_HIGHBITDEPTH
-void vp10_alloc_compressor_data(VP9_COMP *cpi);
+void vp10_alloc_compressor_data(VP10_COMP *cpi);
-void vp10_scale_references(VP9_COMP *cpi);
+void vp10_scale_references(VP10_COMP *cpi);
-void vp10_update_reference_frames(VP9_COMP *cpi);
+void vp10_update_reference_frames(VP10_COMP *cpi);
-void vp10_set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv);
+void vp10_set_high_precision_mv(VP10_COMP *cpi, int allow_high_precision_mv);
YV12_BUFFER_CONFIG *vp10_scale_if_required_fast(VP10_COMMON *cm,
YV12_BUFFER_CONFIG *unscaled,
YV12_BUFFER_CONFIG *unscaled,
YV12_BUFFER_CONFIG *scaled);
-void vp10_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags);
+void vp10_apply_encoding_flags(VP10_COMP *cpi, vpx_enc_frame_flags_t flags);
-static INLINE int is_two_pass_svc(const struct VP9_COMP *const cpi) {
+static INLINE int is_two_pass_svc(const struct VP10_COMP *const cpi) {
return cpi->use_svc && cpi->oxcf.pass != 0;
}
-static INLINE int is_one_pass_cbr_svc(const struct VP9_COMP *const cpi) {
+static INLINE int is_one_pass_cbr_svc(const struct VP10_COMP *const cpi) {
return (cpi->use_svc && cpi->oxcf.pass == 0);
}
-static INLINE int is_altref_enabled(const VP9_COMP *const cpi) {
+static INLINE int is_altref_enabled(const VP10_COMP *const cpi) {
return cpi->oxcf.mode != REALTIME && cpi->oxcf.lag_in_frames > 0 &&
(cpi->oxcf.enable_auto_arf &&
(!is_two_pass_svc(cpi) ||
return frame_index & 0x1;
}
-static INLINE int *cond_cost_list(const struct VP9_COMP *cpi, int *cost_list) {
+static INLINE int *cond_cost_list(const struct VP10_COMP *cpi, int *cost_list) {
return cpi->sf.mv.subpel_search_method != SUBPEL_TREE ? cost_list : NULL;
}
-void vp10_new_framerate(VP9_COMP *cpi, double framerate);
+void vp10_new_framerate(VP10_COMP *cpi, double framerate);
#define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
}
static int enc_worker_hook(EncWorkerData *const thread_data, void *unused) {
- VP9_COMP *const cpi = thread_data->cpi;
+ VP10_COMP *const cpi = thread_data->cpi;
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;
return 0;
}
-static int get_max_tile_cols(VP9_COMP *cpi) {
+static int get_max_tile_cols(VP10_COMP *cpi) {
const int aligned_width = ALIGN_POWER_OF_TWO(cpi->oxcf.width, MI_SIZE_LOG2);
int mi_cols = aligned_width >> MI_SIZE_LOG2;
int min_log2_tile_cols, max_log2_tile_cols;
return (1 << log2_tile_cols);
}
-void vp10_encode_tiles_mt(VP9_COMP *cpi) {
+void vp10_encode_tiles_mt(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
const int tile_cols = 1 << cm->log2_tile_cols;
const VPxWorkerInterface *const winterface = vpx_get_worker_interface();
#ifndef VP10_ENCODER_ETHREAD_H_
#define VP10_ENCODER_ETHREAD_H_
-struct VP9_COMP;
+struct VP10_COMP;
struct ThreadData;
typedef struct EncWorkerData {
- struct VP9_COMP *cpi;
+ struct VP10_COMP *cpi;
struct ThreadData *td;
int start;
} EncWorkerData;
-void vp10_encode_tiles_mt(struct VP9_COMP *cpi);
+void vp10_encode_tiles_mt(struct VP10_COMP *cpi);
#endif // VP10_ENCODER_ETHREAD_H_
}
#if CONFIG_FP_MB_STATS
-static void output_fpmb_stats(uint8_t *this_frame_mb_stats, VP10_COMMON *cm,
- struct vpx_codec_pkt_list *pktlist) {
+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;
pkt.data.firstpass_mb_stats.buf = this_frame_mb_stats;
// bars and partially discounts other 0 energy areas.
#define MIN_ACTIVE_AREA 0.5
#define MAX_ACTIVE_AREA 1.0
-static double calculate_active_area(const VP9_COMP *cpi,
+static double calculate_active_area(const VP10_COMP *cpi,
const FIRSTPASS_STATS *this_frame)
{
double active_pct;
// Calculate a modified Error used in distributing bits between easier and
// harder frames.
#define ACT_AREA_CORRECTION 0.5
-static double calculate_modified_err(const VP9_COMP *cpi,
+static double calculate_modified_err(const VP10_COMP *cpi,
const TWO_PASS *twopass,
const VP9EncoderConfig *oxcf,
const FIRSTPASS_STATS *this_frame) {
return (int)max_bits;
}
-void vp10_init_first_pass(VP9_COMP *cpi) {
+void vp10_init_first_pass(VP10_COMP *cpi) {
zero_stats(&cpi->twopass.total_stats);
}
-void vp10_end_first_pass(VP9_COMP *cpi) {
+void vp10_end_first_pass(VP10_COMP *cpi) {
if (is_two_pass_svc(cpi)) {
int i;
for (i = 0; i < cpi->svc.number_spatial_layers; ++i) {
// Refine the motion search range according to the frame dimension
// for first pass test.
-static int get_search_range(const VP9_COMP *cpi) {
+static int get_search_range(const VP10_COMP *cpi) {
int sr = 0;
const int dim = MIN(cpi->initial_width, cpi->initial_height);
return sr;
}
-static void first_pass_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
+static void first_pass_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
const MV *ref_mv, MV *best_mv,
int *best_motion_err) {
MACROBLOCKD *const xd = &x->e_mbd;
return i;
}
-static void set_first_pass_params(VP9_COMP *cpi) {
+static void set_first_pass_params(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
if (!cpi->refresh_alt_ref_frame &&
(cm->current_video_frame == 0 ||
#define UL_INTRA_THRESH 50
#define INVALID_ROW -1
-void vp10_first_pass(VP9_COMP *cpi, const struct lookahead_entry *source) {
+void vp10_first_pass(VP10_COMP *cpi, const struct lookahead_entry *source) {
int mb_row, mb_col;
MACROBLOCK *const x = &cpi->td.mb;
VP10_COMMON *const cm = &cpi->common;
// increased size and hence coding cost of motion vectors.
#define EDIV_SIZE_FACTOR 800
-static int get_twopass_worst_quality(const VP9_COMP *cpi,
+static int get_twopass_worst_quality(const VP10_COMP *cpi,
const double section_err,
double inactive_zone,
int section_target_bandwidth,
}
}
-static void setup_rf_level_maxq(VP9_COMP *cpi) {
+static void setup_rf_level_maxq(VP10_COMP *cpi) {
int i;
RATE_CONTROL *const rc = &cpi->rc;
for (i = INTER_NORMAL; i < RATE_FACTOR_LEVELS; ++i) {
}
}
-void vp10_init_subsampling(VP9_COMP *cpi) {
+void vp10_init_subsampling(VP10_COMP *cpi) {
const VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
const int w = cm->width;
setup_rf_level_maxq(cpi);
}
-void vp10_calculate_coded_size(VP9_COMP *cpi,
+void vp10_calculate_coded_size(VP10_COMP *cpi,
int *scaled_frame_width,
int *scaled_frame_height) {
RATE_CONTROL *const rc = &cpi->rc;
*scaled_frame_height = rc->frame_height[rc->frame_size_selector];
}
-void vp10_init_second_pass(VP9_COMP *cpi) {
+void vp10_init_second_pass(VP10_COMP *cpi) {
SVC *const svc = &cpi->svc;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
const int is_two_pass_svc = (svc->number_spatial_layers > 1) ||
#define LOW_SR_DIFF_TRHESH 0.1
#define SR_DIFF_MAX 128.0
-static double get_sr_decay_rate(const VP9_COMP *cpi,
+static double get_sr_decay_rate(const VP10_COMP *cpi,
const FIRSTPASS_STATS *frame) {
const int num_mbs = (cpi->oxcf.resize_mode != RESIZE_NONE)
? cpi->initial_mbs : cpi->common.MBs;
// This function gives an estimate of how badly we believe the prediction
// quality is decaying from frame to frame.
-static double get_zero_motion_factor(const VP9_COMP *cpi,
+static double get_zero_motion_factor(const VP10_COMP *cpi,
const FIRSTPASS_STATS *frame) {
const double zero_motion_pct = frame->pcnt_inter -
frame->pcnt_motion;
#define ZM_POWER_FACTOR 0.75
-static double get_prediction_decay_rate(const VP9_COMP *cpi,
+static double get_prediction_decay_rate(const VP10_COMP *cpi,
const FIRSTPASS_STATS *next_frame) {
const double sr_decay_rate = get_sr_decay_rate(cpi, next_frame);
const double zero_motion_factor =
// Function to test for a condition where a complex transition is followed
// by a static section. For example in slide shows where there is a fade
// between slides. This is to help with more optimal kf and gf positioning.
-static int detect_transition_to_still(VP9_COMP *cpi,
+static int detect_transition_to_still(VP10_COMP *cpi,
int frame_interval, int still_interval,
double loop_decay_rate,
double last_decay_rate) {
}
#define BASELINE_ERR_PER_MB 1000.0
-static double calc_frame_boost(VP9_COMP *cpi,
+static double calc_frame_boost(VP10_COMP *cpi,
const FIRSTPASS_STATS *this_frame,
double this_frame_mv_in_out,
double max_boost) {
return MIN(frame_boost, max_boost * boost_q_correction);
}
-static int calc_arf_boost(VP9_COMP *cpi, int offset,
+static int calc_arf_boost(VP10_COMP *cpi, int offset,
int f_frames, int b_frames,
int *f_boost, int *b_boost) {
TWO_PASS *const twopass = &cpi->twopass;
}
// Calculate the total bits to allocate in this GF/ARF group.
-static int64_t calculate_total_gf_group_bits(VP9_COMP *cpi,
+static int64_t calculate_total_gf_group_bits(VP10_COMP *cpi,
double gf_group_err) {
const RATE_CONTROL *const rc = &cpi->rc;
const TWO_PASS *const twopass = &cpi->twopass;
arf_buffer_indices[1] = ARF_SLOT2;
}
-static void allocate_gf_group_bits(VP9_COMP *cpi, int64_t gf_group_bits,
+static void allocate_gf_group_bits(VP10_COMP *cpi, int64_t gf_group_bits,
double group_error, int gf_arf_bits) {
RATE_CONTROL *const rc = &cpi->rc;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
}
// Analyse and define a gf/arf group.
-static void define_gf_group(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
+static void define_gf_group(VP10_COMP *cpi, FIRSTPASS_STATS *this_frame) {
VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
VP9EncoderConfig *const oxcf = &cpi->oxcf;
return is_viable_kf;
}
-static void find_next_key_frame(VP9_COMP *cpi, FIRSTPASS_STATS *this_frame) {
+static void find_next_key_frame(VP10_COMP *cpi, FIRSTPASS_STATS *this_frame) {
int i, j;
RATE_CONTROL *const rc = &cpi->rc;
TWO_PASS *const twopass = &cpi->twopass;
}
// Define the reference buffers that will be updated post encode.
-static void configure_buffer_updates(VP9_COMP *cpi) {
+static void configure_buffer_updates(VP10_COMP *cpi) {
TWO_PASS *const twopass = &cpi->twopass;
cpi->rc.is_src_frame_alt_ref = 0;
}
}
-static int is_skippable_frame(const VP9_COMP *cpi) {
+static int is_skippable_frame(const VP10_COMP *cpi) {
// If the current frame does not have non-zero motion vector detected in the
// first pass, and so do its previous and forward frames, then this frame
// can be skipped for partition check, and the partition size is assigned
twopass->stats_in->pcnt_inter - twopass->stats_in->pcnt_motion == 1);
}
-void vp10_rc_get_second_pass_params(VP9_COMP *cpi) {
+void vp10_rc_get_second_pass_params(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
TWO_PASS *const twopass = &cpi->twopass;
#define MINQ_ADJ_LIMIT 48
#define MINQ_ADJ_LIMIT_CQ 20
#define HIGH_UNDERSHOOT_RATIO 2
-void vp10_twopass_postencode_update(VP9_COMP *cpi) {
+void vp10_twopass_postencode_update(VP10_COMP *cpi) {
TWO_PASS *const twopass = &cpi->twopass;
RATE_CONTROL *const rc = &cpi->rc;
const int bits_used = rc->base_frame_target;
GF_GROUP gf_group;
} TWO_PASS;
-struct VP9_COMP;
+struct VP10_COMP;
-void vp10_init_first_pass(struct VP9_COMP *cpi);
-void vp10_rc_get_first_pass_params(struct VP9_COMP *cpi);
-void vp10_first_pass(struct VP9_COMP *cpi, const struct lookahead_entry *source);
-void vp10_end_first_pass(struct VP9_COMP *cpi);
+void vp10_init_first_pass(struct VP10_COMP *cpi);
+void vp10_rc_get_first_pass_params(struct VP10_COMP *cpi);
+void vp10_first_pass(struct VP10_COMP *cpi,
+ const struct lookahead_entry *source);
+void vp10_end_first_pass(struct VP10_COMP *cpi);
-void vp10_init_second_pass(struct VP9_COMP *cpi);
-void vp10_rc_get_second_pass_params(struct VP9_COMP *cpi);
-void vp10_twopass_postencode_update(struct VP9_COMP *cpi);
+void vp10_init_second_pass(struct VP10_COMP *cpi);
+void vp10_rc_get_second_pass_params(struct VP10_COMP *cpi);
+void vp10_twopass_postencode_update(struct VP10_COMP *cpi);
// Post encode update of the rate control parameters for 2-pass
-void vp10_twopass_postencode_update(struct VP9_COMP *cpi);
+void vp10_twopass_postencode_update(struct VP10_COMP *cpi);
-void vp10_init_subsampling(struct VP9_COMP *cpi);
+void vp10_init_subsampling(struct VP10_COMP *cpi);
-void vp10_calculate_coded_size(struct VP9_COMP *cpi,
+void vp10_calculate_coded_size(struct VP10_COMP *cpi,
int *scaled_frame_width,
int *scaled_frame_height);
#include "vp10/common/reconintra.h"
-static unsigned int do_16x16_motion_iteration(VP9_COMP *cpi,
+static unsigned int do_16x16_motion_iteration(VP10_COMP *cpi,
const MV *ref_mv,
MV *dst_mv,
int mb_row,
xd->plane[0].dst.buf, xd->plane[0].dst.stride);
}
-static int do_16x16_motion_search(VP9_COMP *cpi, const MV *ref_mv,
+static int do_16x16_motion_search(VP10_COMP *cpi, const MV *ref_mv,
int_mv *dst_mv, int mb_row, int mb_col) {
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
return err;
}
-static int do_16x16_zerozero_search(VP9_COMP *cpi, int_mv *dst_mv) {
+static int do_16x16_zerozero_search(VP10_COMP *cpi, int_mv *dst_mv) {
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
unsigned int err;
return err;
}
-static int find_best_16x16_intra(VP9_COMP *cpi, PREDICTION_MODE *pbest_mode) {
+static int find_best_16x16_intra(VP10_COMP *cpi, PREDICTION_MODE *pbest_mode) {
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &x->e_mbd;
PREDICTION_MODE best_mode = -1, mode;
static void update_mbgraph_mb_stats
(
- VP9_COMP *cpi,
+ VP10_COMP *cpi,
MBGRAPH_MB_STATS *stats,
YV12_BUFFER_CONFIG *buf,
int mb_y_offset,
}
}
-static void update_mbgraph_frame_stats(VP9_COMP *cpi,
+static void update_mbgraph_frame_stats(VP10_COMP *cpi,
MBGRAPH_FRAME_STATS *stats,
YV12_BUFFER_CONFIG *buf,
YV12_BUFFER_CONFIG *golden_ref,
}
// void separate_arf_mbs_byzz
-static void separate_arf_mbs(VP9_COMP *cpi) {
+static void separate_arf_mbs(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
int mb_col, mb_row, offset, i;
int mi_row, mi_col;
vpx_free(arf_not_zz);
}
-void vp10_update_mbgraph_stats(VP9_COMP *cpi) {
+void vp10_update_mbgraph_stats(VP10_COMP *cpi) {
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);
MBGRAPH_MB_STATS *mb_stats;
} MBGRAPH_FRAME_STATS;
-struct VP9_COMP;
+struct VP10_COMP;
-void vp10_update_mbgraph_stats(struct VP9_COMP *cpi);
+void vp10_update_mbgraph_stats(struct VP10_COMP *cpi);
#ifdef __cplusplus
} // extern "C"
{-1, 0}, {0, -1}, {0, 1}, {1, 0},
};
-unsigned int vp10_int_pro_motion_estimation(const VP9_COMP *cpi, MACROBLOCK *x,
+unsigned int vp10_int_pro_motion_estimation(const VP10_COMP *cpi, MACROBLOCK *x,
BLOCK_SIZE bsize,
int mi_row, int mi_col) {
MACROBLOCKD *xd = &x->e_mbd;
/* do_refine: If last step (1-away) of n-step search doesn't pick the center
point as the best match, we will do a final 1-away diamond
refining search */
-int vp10_full_pixel_diamond(const VP9_COMP *cpi, MACROBLOCK *x,
+int vp10_full_pixel_diamond(const VP10_COMP *cpi, MACROBLOCK *x,
MV *mvp_full, int step_param,
int sadpb, int further_steps, int do_refine,
int *cost_list,
return best_sad;
}
-int vp10_full_pixel_search(VP9_COMP *cpi, MACROBLOCK *x,
+int vp10_full_pixel_search(VP10_COMP *cpi, MACROBLOCK *x,
BLOCK_SIZE bsize, MV *mvp_full,
int step_param, int error_per_bit,
int *cost_list,
const vp9_variance_fn_ptr_t *vfp,
int use_mvcost);
-struct VP9_COMP;
+struct VP10_COMP;
struct SPEED_FEATURES;
int vp10_init_search_range(int size);
const struct mv *center_mv);
// Runs sequence of diamond searches in smaller steps for RD.
-int vp10_full_pixel_diamond(const struct VP9_COMP *cpi, MACROBLOCK *x,
+int vp10_full_pixel_diamond(const struct VP10_COMP *cpi, MACROBLOCK *x,
MV *mvp_full, int step_param,
int sadpb, int further_steps, int do_refine,
int *cost_list,
const MV *ref_mv, MV *dst_mv);
// Perform integral projection based motion estimation.
-unsigned int vp10_int_pro_motion_estimation(const struct VP9_COMP *cpi,
+unsigned int vp10_int_pro_motion_estimation(const struct VP10_COMP *cpi,
MACROBLOCK *x,
BLOCK_SIZE bsize,
int mi_row, int mi_col);
const vp9_variance_fn_ptr_t *fn_ptr,
const MV *center_mv, const uint8_t *second_pred);
-struct VP9_COMP;
+struct VP10_COMP;
-int vp10_full_pixel_search(struct VP9_COMP *cpi, MACROBLOCK *x,
+int vp10_full_pixel_search(struct VP10_COMP *cpi, MACROBLOCK *x,
BLOCK_SIZE bsize, MV *mvp_full,
int step_param, int error_per_bit,
int *cost_list,
#include "vp10/encoder/picklpf.h"
#include "vp10/encoder/quantize.h"
-static int get_max_filter_level(const VP9_COMP *cpi) {
+static int get_max_filter_level(const VP10_COMP *cpi) {
if (cpi->oxcf.pass == 2) {
return cpi->twopass.section_intra_rating > 8 ? MAX_LOOP_FILTER * 3 / 4
: MAX_LOOP_FILTER;
static int64_t try_filter_frame(const YV12_BUFFER_CONFIG *sd,
- VP9_COMP *const cpi,
+ VP10_COMP *const cpi,
int filt_level, int partial_frame) {
VP10_COMMON *const cm = &cpi->common;
int64_t filt_err;
return filt_err;
}
-static int search_filter_level(const YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi,
+static int search_filter_level(const YV12_BUFFER_CONFIG *sd, VP10_COMP *cpi,
int partial_frame) {
const VP10_COMMON *const cm = &cpi->common;
const struct loopfilter *const lf = &cm->lf;
return filt_best;
}
-void vp10_pick_filter_level(const YV12_BUFFER_CONFIG *sd, VP9_COMP *cpi,
+void vp10_pick_filter_level(const YV12_BUFFER_CONFIG *sd, VP10_COMP *cpi,
LPF_PICK_METHOD method) {
VP10_COMMON *const cm = &cpi->common;
struct loopfilter *const lf = &cm->lf;
#include "vp10/encoder/encoder.h"
struct yv12_buffer_config;
-struct VP9_COMP;
+struct VP10_COMP;
void vp10_pick_filter_level(const struct yv12_buffer_config *sd,
- struct VP9_COMP *cpi, LPF_PICK_METHOD method);
+ struct VP10_COMP *cpi, LPF_PICK_METHOD method);
#ifdef __cplusplus
} // extern "C"
#endif
return const_motion;
}
-static int combined_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
+static int combined_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
BLOCK_SIZE bsize, int mi_row, int mi_col,
int_mv *tmp_mv, int *rate_mv,
int64_t best_rd_sofar) {
}
}
-static void model_rd_for_sb_y_large(VP9_COMP *cpi, BLOCK_SIZE bsize,
+static void model_rd_for_sb_y_large(VP10_COMP *cpi, BLOCK_SIZE bsize,
MACROBLOCK *x, MACROBLOCKD *xd,
int *out_rate_sum, int64_t *out_dist_sum,
unsigned int *var_y, unsigned int *sse_y,
*out_dist_sum += dist << 4;
}
-static void model_rd_for_sb_y(VP9_COMP *cpi, BLOCK_SIZE bsize,
+static void model_rd_for_sb_y(VP10_COMP *cpi, BLOCK_SIZE bsize,
MACROBLOCK *x, MACROBLOCKD *xd,
int *out_rate_sum, int64_t *out_dist_sum,
unsigned int *var_y, unsigned int *sse_y) {
}
#if CONFIG_VP9_HIGHBITDEPTH
-static void block_yrd(VP9_COMP *cpi, MACROBLOCK *x, int *rate, int64_t *dist,
+static void block_yrd(VP10_COMP *cpi, MACROBLOCK *x, int *rate, int64_t *dist,
int *skippable, int64_t *sse, int plane,
BLOCK_SIZE bsize, TX_SIZE tx_size) {
MACROBLOCKD *xd = &x->e_mbd;
return;
}
#else
-static void block_yrd(VP9_COMP *cpi, MACROBLOCK *x, int *rate, int64_t *dist,
+static void block_yrd(VP10_COMP *cpi, MACROBLOCK *x, int *rate, int64_t *dist,
int *skippable, int64_t *sse, int plane,
BLOCK_SIZE bsize, TX_SIZE tx_size) {
MACROBLOCKD *xd = &x->e_mbd;
}
#endif
-static void model_rd_for_sb_uv(VP9_COMP *cpi, BLOCK_SIZE bsize,
+static void model_rd_for_sb_uv(VP10_COMP *cpi, BLOCK_SIZE bsize,
MACROBLOCK *x, MACROBLOCKD *xd,
int *out_rate_sum, int64_t *out_dist_sum,
unsigned int *var_y, unsigned int *sse_y) {
p->in_use = 0;
}
-static void encode_breakout_test(VP9_COMP *cpi, MACROBLOCK *x,
+static void encode_breakout_test(VP10_COMP *cpi, MACROBLOCK *x,
BLOCK_SIZE bsize, int mi_row, int mi_col,
MV_REFERENCE_FRAME ref_frame,
PREDICTION_MODE this_mode,
}
struct estimate_block_intra_args {
- VP9_COMP *cpi;
+ VP10_COMP *cpi;
MACROBLOCK *x;
PREDICTION_MODE mode;
int rate;
static void estimate_block_intra(int plane, int block, BLOCK_SIZE plane_bsize,
TX_SIZE tx_size, void *arg) {
struct estimate_block_intra_args* const args = arg;
- VP9_COMP *const cpi = args->cpi;
+ VP10_COMP *const cpi = args->cpi;
MACROBLOCK *const x = args->x;
MACROBLOCKD *const xd = &x->e_mbd;
struct macroblock_plane *const p = &x->plane[0];
}
}
-static INLINE void update_thresh_freq_fact(VP9_COMP *cpi,
+static INLINE void update_thresh_freq_fact(VP10_COMP *cpi,
TileDataEnc *tile_data,
BLOCK_SIZE bsize,
MV_REFERENCE_FRAME ref_frame,
cpi->sf.adaptive_rd_thresh * RD_THRESH_MAX_FACT);
}
-void vp10_pick_intra_mode(VP9_COMP *cpi, MACROBLOCK *x, RD_COST *rd_cost,
+void vp10_pick_intra_mode(VP10_COMP *cpi, MACROBLOCK *x, RD_COST *rd_cost,
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) {
MACROBLOCKD *const xd = &x->e_mbd;
MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
// TODO(jingning) placeholder for inter-frame non-RD mode decision.
// this needs various further optimizations. to be continued..
-void vp10_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
+void vp10_pick_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
TileDataEnc *tile_data,
int mi_row, int mi_col, RD_COST *rd_cost,
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) {
*rd_cost = best_rdc;
}
-void vp10_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
+void vp10_pick_inter_mode_sub8x8(VP10_COMP *cpi, MACROBLOCK *x,
int mi_row, int mi_col, RD_COST *rd_cost,
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx) {
VP10_COMMON *const cm = &cpi->common;
extern "C" {
#endif
-void vp10_pick_intra_mode(VP9_COMP *cpi, MACROBLOCK *x, RD_COST *rd_cost,
+void vp10_pick_intra_mode(VP10_COMP *cpi, MACROBLOCK *x, RD_COST *rd_cost,
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx);
-void vp10_pick_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
+void vp10_pick_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
TileDataEnc *tile_data,
int mi_row, int mi_col, RD_COST *rd_cost,
BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx);
-void vp10_pick_inter_mode_sub8x8(VP9_COMP *cpi, MACROBLOCK *x,
+void vp10_pick_inter_mode_sub8x8(VP10_COMP *cpi, MACROBLOCK *x,
int mi_row, int mi_col, RD_COST *rd_cost,
BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx);
#endif
}
-void vp10_init_quantizer(VP9_COMP *cpi) {
+void vp10_init_quantizer(VP10_COMP *cpi) {
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) {
+void vp10_init_plane_quantizers(VP10_COMP *cpi, MACROBLOCK *x) {
const VP10_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
QUANTS *const quants = &cpi->quants;
vp10_initialize_me_consts(cpi, x, x->q_index);
}
-void vp10_frame_init_quantizer(VP9_COMP *cpi) {
+void vp10_frame_init_quantizer(VP10_COMP *cpi) {
vp10_init_plane_quantizers(cpi, &cpi->td.mb);
}
void vp10_regular_quantize_b_4x4(MACROBLOCK *x, int plane, int block,
const int16_t *scan, const int16_t *iscan);
-struct VP9_COMP;
+struct VP10_COMP;
struct VP9Common;
-void vp10_frame_init_quantizer(struct VP9_COMP *cpi);
+void vp10_frame_init_quantizer(struct VP10_COMP *cpi);
-void vp10_init_plane_quantizers(struct VP9_COMP *cpi, MACROBLOCK *x);
+void vp10_init_plane_quantizers(struct VP10_COMP *cpi, MACROBLOCK *x);
-void vp10_init_quantizer(struct VP9_COMP *cpi);
+void vp10_init_quantizer(struct VP10_COMP *cpi);
void vp10_set_quantizer(struct VP9Common *cm, int q);
(int)((uint64_t)bpm * mbs) >> BPER_MB_NORMBITS);
}
-int vp10_rc_clamp_pframe_target_size(const VP9_COMP *const cpi, int target) {
+int vp10_rc_clamp_pframe_target_size(const VP10_COMP *const cpi, int target) {
const RATE_CONTROL *rc = &cpi->rc;
const VP9EncoderConfig *oxcf = &cpi->oxcf;
const int min_frame_target = MAX(rc->min_frame_bandwidth,
return target;
}
-int vp10_rc_clamp_iframe_target_size(const VP9_COMP *const cpi, int target) {
+int vp10_rc_clamp_iframe_target_size(const VP10_COMP *const cpi, int target) {
const RATE_CONTROL *rc = &cpi->rc;
const VP9EncoderConfig *oxcf = &cpi->oxcf;
if (oxcf->rc_max_intra_bitrate_pct) {
}
// Update the buffer level: leaky bucket model.
-static void update_buffer_level(VP9_COMP *cpi, int encoded_frame_size) {
+static void update_buffer_level(VP10_COMP *cpi, int encoded_frame_size) {
const VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
rc->baseline_gf_interval = (rc->min_gf_interval + rc->max_gf_interval) / 2;
}
-int vp10_rc_drop_frame(VP9_COMP *cpi) {
+int vp10_rc_drop_frame(VP10_COMP *cpi) {
const VP9EncoderConfig *oxcf = &cpi->oxcf;
RATE_CONTROL *const rc = &cpi->rc;
}
}
-static double get_rate_correction_factor(const VP9_COMP *cpi) {
+static double get_rate_correction_factor(const VP10_COMP *cpi) {
const RATE_CONTROL *const rc = &cpi->rc;
double rcf;
return fclamp(rcf, MIN_BPB_FACTOR, MAX_BPB_FACTOR);
}
-static void set_rate_correction_factor(VP9_COMP *cpi, double factor) {
+static void set_rate_correction_factor(VP10_COMP *cpi, double factor) {
RATE_CONTROL *const rc = &cpi->rc;
// Normalize RCF to account for the size-dependent scaling factor.
}
}
-void vp10_rc_update_rate_correction_factors(VP9_COMP *cpi) {
+void vp10_rc_update_rate_correction_factors(VP10_COMP *cpi) {
const VP10_COMMON *const cm = &cpi->common;
int correction_factor = 100;
double rate_correction_factor = get_rate_correction_factor(cpi);
}
-int vp10_rc_regulate_q(const VP9_COMP *cpi, int target_bits_per_frame,
+int vp10_rc_regulate_q(const VP10_COMP *cpi, int target_bits_per_frame,
int active_best_quality, int active_worst_quality) {
const VP10_COMMON *const cm = &cpi->common;
int q = active_worst_quality;
arfgf_low_motion_minq, arfgf_high_motion_minq);
}
-static int calc_active_worst_quality_one_pass_vbr(const VP9_COMP *cpi) {
+static int calc_active_worst_quality_one_pass_vbr(const VP10_COMP *cpi) {
const RATE_CONTROL *const rc = &cpi->rc;
const unsigned int curr_frame = cpi->common.current_video_frame;
int active_worst_quality;
}
// Adjust active_worst_quality level based on buffer level.
-static int calc_active_worst_quality_one_pass_cbr(const VP9_COMP *cpi) {
+static int calc_active_worst_quality_one_pass_cbr(const VP10_COMP *cpi) {
// Adjust active_worst_quality: If buffer is above the optimal/target level,
// bring active_worst_quality down depending on fullness of buffer.
// If buffer is below the optimal level, let the active_worst_quality go from
return active_worst_quality;
}
-static int rc_pick_q_and_bounds_one_pass_cbr(const VP9_COMP *cpi,
+static int rc_pick_q_and_bounds_one_pass_cbr(const VP10_COMP *cpi,
int *bottom_index,
int *top_index) {
const VP10_COMMON *const cm = &cpi->common;
return active_cq_level;
}
-static int rc_pick_q_and_bounds_one_pass_vbr(const VP9_COMP *cpi,
+static int rc_pick_q_and_bounds_one_pass_vbr(const VP10_COMP *cpi,
int *bottom_index,
int *top_index) {
const VP10_COMMON *const cm = &cpi->common;
return q;
}
-int vp10_frame_type_qdelta(const VP9_COMP *cpi, int rf_level, int q) {
+int vp10_frame_type_qdelta(const VP10_COMP *cpi, int rf_level, int q) {
static const double rate_factor_deltas[RATE_FACTOR_LEVELS] = {
1.00, // INTER_NORMAL
1.00, // INTER_HIGH
}
#define STATIC_MOTION_THRESH 95
-static int rc_pick_q_and_bounds_two_pass(const VP9_COMP *cpi,
+static int rc_pick_q_and_bounds_two_pass(const VP10_COMP *cpi,
int *bottom_index,
int *top_index) {
const VP10_COMMON *const cm = &cpi->common;
return q;
}
-int vp10_rc_pick_q_and_bounds(const VP9_COMP *cpi,
+int vp10_rc_pick_q_and_bounds(const VP10_COMP *cpi,
int *bottom_index, int *top_index) {
int q;
if (cpi->oxcf.pass == 0) {
return q;
}
-void vp10_rc_compute_frame_size_bounds(const VP9_COMP *cpi,
+void vp10_rc_compute_frame_size_bounds(const VP10_COMP *cpi,
int frame_target,
int *frame_under_shoot_limit,
int *frame_over_shoot_limit) {
}
}
-void vp10_rc_set_frame_target(VP9_COMP *cpi, int target) {
+void vp10_rc_set_frame_target(VP10_COMP *cpi, int target) {
const VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
(cm->width * cm->height);
}
-static void update_alt_ref_frame_stats(VP9_COMP *cpi) {
+static void update_alt_ref_frame_stats(VP10_COMP *cpi) {
// this frame refreshes means next frames don't unless specified by user
RATE_CONTROL *const rc = &cpi->rc;
rc->frames_since_golden = 0;
rc->source_alt_ref_active = 1;
}
-static void update_golden_frame_stats(VP9_COMP *cpi) {
+static void update_golden_frame_stats(VP10_COMP *cpi) {
RATE_CONTROL *const rc = &cpi->rc;
// Update the Golden frame usage counts.
}
}
-void vp10_rc_postencode_update(VP9_COMP *cpi, uint64_t bytes_used) {
+void vp10_rc_postencode_update(VP10_COMP *cpi, uint64_t bytes_used) {
const VP10_COMMON *const cm = &cpi->common;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
RATE_CONTROL *const rc = &cpi->rc;
}
}
-void vp10_rc_postencode_update_drop_frame(VP9_COMP *cpi) {
+void vp10_rc_postencode_update_drop_frame(VP10_COMP *cpi) {
// Update buffer level with zero size, update frame counters, and return.
update_buffer_level(cpi, 0);
cpi->rc.frames_since_key++;
// Use this macro to turn on/off use of alt-refs in one-pass mode.
#define USE_ALTREF_FOR_ONE_PASS 1
-static int calc_pframe_target_size_one_pass_vbr(const VP9_COMP *const cpi) {
+static int calc_pframe_target_size_one_pass_vbr(const VP10_COMP *const cpi) {
static const int af_ratio = 10;
const RATE_CONTROL *const rc = &cpi->rc;
int target;
return vp10_rc_clamp_pframe_target_size(cpi, target);
}
-static int calc_iframe_target_size_one_pass_vbr(const VP9_COMP *const cpi) {
+static int calc_iframe_target_size_one_pass_vbr(const VP10_COMP *const cpi) {
static const int kf_ratio = 25;
const RATE_CONTROL *rc = &cpi->rc;
const int target = rc->avg_frame_bandwidth * kf_ratio;
return vp10_rc_clamp_iframe_target_size(cpi, target);
}
-void vp10_rc_get_one_pass_vbr_params(VP9_COMP *cpi) {
+void vp10_rc_get_one_pass_vbr_params(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
int target;
vp10_rc_set_frame_target(cpi, target);
}
-static int calc_pframe_target_size_one_pass_cbr(const VP9_COMP *cpi) {
+static int calc_pframe_target_size_one_pass_cbr(const VP10_COMP *cpi) {
const VP9EncoderConfig *oxcf = &cpi->oxcf;
const RATE_CONTROL *rc = &cpi->rc;
const SVC *const svc = &cpi->svc;
return MAX(min_frame_target, target);
}
-static int calc_iframe_target_size_one_pass_cbr(const VP9_COMP *cpi) {
+static int calc_iframe_target_size_one_pass_cbr(const VP10_COMP *cpi) {
const RATE_CONTROL *rc = &cpi->rc;
const VP9EncoderConfig *oxcf = &cpi->oxcf;
const SVC *const svc = &cpi->svc;
// Reset information needed to set proper reference frames and buffer updates
// for temporal layering. This is called when a key frame is encoded.
-static void reset_temporal_layer_to_zero(VP9_COMP *cpi) {
+static void reset_temporal_layer_to_zero(VP10_COMP *cpi) {
int sl;
LAYER_CONTEXT *lc = NULL;
cpi->svc.temporal_layer_id = 0;
}
}
-void vp10_rc_get_svc_params(VP9_COMP *cpi) {
+void vp10_rc_get_svc_params(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
int target = rc->avg_frame_bandwidth;
rc->baseline_gf_interval = INT_MAX;
}
-void vp10_rc_get_one_pass_cbr_params(VP9_COMP *cpi) {
+void vp10_rc_get_one_pass_cbr_params(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
int target;
return target_index - qindex;
}
-void vp10_rc_set_gf_interval_range(const VP9_COMP *const cpi,
+void vp10_rc_set_gf_interval_range(const VP10_COMP *const cpi,
RATE_CONTROL *const rc) {
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
rc->min_gf_interval = MIN(rc->min_gf_interval, rc->max_gf_interval);
}
-void vp10_rc_update_framerate(VP9_COMP *cpi) {
+void vp10_rc_update_framerate(VP10_COMP *cpi) {
const VP10_COMMON *const cm = &cpi->common;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
RATE_CONTROL *const rc = &cpi->rc;
#define VBR_PCT_ADJUSTMENT_LIMIT 50
// For VBR...adjustment to the frame target based on error from previous frames
-static void vbr_rate_correction(VP9_COMP *cpi, int *this_frame_target) {
+static void vbr_rate_correction(VP10_COMP *cpi, int *this_frame_target) {
RATE_CONTROL *const rc = &cpi->rc;
int64_t vbr_bits_off_target = rc->vbr_bits_off_target;
int max_delta;
}
}
-void vp10_set_target_rate(VP9_COMP *cpi) {
+void vp10_set_target_rate(VP10_COMP *cpi) {
RATE_CONTROL *const rc = &cpi->rc;
int target_rate = rc->base_frame_target;
// 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) {
+int vp10_resize_one_pass_cbr(VP10_COMP *cpi) {
const VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
int resize_now = 0;
int rf_level_maxq[RATE_FACTOR_LEVELS];
} RATE_CONTROL;
-struct VP9_COMP;
+struct VP10_COMP;
struct VP9EncoderConfig;
void vp10_rc_init(const struct VP9EncoderConfig *oxcf, int pass,
// Functions to set parameters for encoding before the actual
// encode_frame_to_data_rate() function.
-void vp10_rc_get_one_pass_vbr_params(struct VP9_COMP *cpi);
-void vp10_rc_get_one_pass_cbr_params(struct VP9_COMP *cpi);
-void vp10_rc_get_svc_params(struct VP9_COMP *cpi);
+void vp10_rc_get_one_pass_vbr_params(struct VP10_COMP *cpi);
+void vp10_rc_get_one_pass_cbr_params(struct VP10_COMP *cpi);
+void vp10_rc_get_svc_params(struct VP10_COMP *cpi);
// Post encode update of the rate control parameters based
// on bytes used
-void vp10_rc_postencode_update(struct VP9_COMP *cpi, uint64_t bytes_used);
+void vp10_rc_postencode_update(struct VP10_COMP *cpi, uint64_t bytes_used);
// Post encode update of the rate control parameters for dropped frames
-void vp10_rc_postencode_update_drop_frame(struct VP9_COMP *cpi);
+void vp10_rc_postencode_update_drop_frame(struct VP10_COMP *cpi);
// Updates rate correction factors
// Changes only the rate correction factors in the rate control structure.
-void vp10_rc_update_rate_correction_factors(struct VP9_COMP *cpi);
+void vp10_rc_update_rate_correction_factors(struct VP10_COMP *cpi);
// Decide if we should drop this frame: For 1-pass CBR.
// Changes only the decimation count in the rate control structure
-int vp10_rc_drop_frame(struct VP9_COMP *cpi);
+int vp10_rc_drop_frame(struct VP10_COMP *cpi);
// Computes frame size bounds.
-void vp10_rc_compute_frame_size_bounds(const struct VP9_COMP *cpi,
+void vp10_rc_compute_frame_size_bounds(const struct VP10_COMP *cpi,
int this_frame_target,
int *frame_under_shoot_limit,
int *frame_over_shoot_limit);
// Picks q and q bounds given the target for bits
-int vp10_rc_pick_q_and_bounds(const struct VP9_COMP *cpi,
+int vp10_rc_pick_q_and_bounds(const struct VP10_COMP *cpi,
int *bottom_index,
int *top_index);
// Estimates q to achieve a target bits per frame
-int vp10_rc_regulate_q(const struct VP9_COMP *cpi, int target_bits_per_frame,
+int vp10_rc_regulate_q(const struct VP10_COMP *cpi, int target_bits_per_frame,
int active_best_quality, int active_worst_quality);
// Estimates bits per mb for a given qindex and correction factor.
double correction_factor, vpx_bit_depth_t bit_depth);
// Clamping utilities for bitrate targets for iframes and pframes.
-int vp10_rc_clamp_iframe_target_size(const struct VP9_COMP *const cpi,
+int vp10_rc_clamp_iframe_target_size(const struct VP10_COMP *const cpi,
int target);
-int vp10_rc_clamp_pframe_target_size(const struct VP9_COMP *const cpi,
+int vp10_rc_clamp_pframe_target_size(const struct VP10_COMP *const cpi,
int target);
// Utility to set frame_target into the RATE_CONTROL structure
// This function is called only from the vp10_rc_get_..._params() functions.
-void vp10_rc_set_frame_target(struct VP9_COMP *cpi, int target);
+void vp10_rc_set_frame_target(struct VP10_COMP *cpi, int target);
// Computes a q delta (in "q index" terms) to get from a starting q value
// to a target q value
int qindex, double rate_target_ratio,
vpx_bit_depth_t bit_depth);
-int vp10_frame_type_qdelta(const struct VP9_COMP *cpi, int rf_level, int q);
+int vp10_frame_type_qdelta(const struct VP10_COMP *cpi, int rf_level, int q);
-void vp10_rc_update_framerate(struct VP9_COMP *cpi);
+void vp10_rc_update_framerate(struct VP10_COMP *cpi);
-void vp10_rc_set_gf_interval_range(const struct VP9_COMP *const cpi,
+void vp10_rc_set_gf_interval_range(const struct VP10_COMP *const cpi,
RATE_CONTROL *const rc);
-void vp10_set_target_rate(struct VP9_COMP *cpi);
+void vp10_set_target_rate(struct VP10_COMP *cpi);
-int vp10_resize_one_pass_cbr(struct VP9_COMP *cpi);
+int vp10_resize_one_pass_cbr(struct VP10_COMP *cpi);
#ifdef __cplusplus
} // extern "C"
2, 3, 3, 4, 6, 6, 8, 12, 12, 16, 24, 24, 32
};
-static void fill_mode_costs(VP9_COMP *cpi) {
+static void fill_mode_costs(VP10_COMP *cpi) {
const FRAME_CONTEXT *const fc = cpi->common.fc;
int i, j;
128, 144, 128, 128, 144
};
-int vp10_compute_rd_mult(const VP9_COMP *cpi, int qindex) {
+int vp10_compute_rd_mult(const VP10_COMP *cpi, int qindex) {
const int64_t q = vp10_dc_quant(qindex, 0, cpi->common.bit_depth);
#if CONFIG_VP9_HIGHBITDEPTH
int64_t rdmult = 0;
return MAX((int)(pow(q, RD_THRESH_POW) * 5.12), 8);
}
-void vp10_initialize_me_consts(VP9_COMP *cpi, MACROBLOCK *x, int qindex) {
+void vp10_initialize_me_consts(VP10_COMP *cpi, MACROBLOCK *x, int qindex) {
#if CONFIG_VP9_HIGHBITDEPTH
switch (cpi->common.bit_depth) {
case VPX_BITS_8:
}
}
-void vp10_initialize_rd_consts(VP9_COMP *cpi) {
+void vp10_initialize_rd_consts(VP10_COMP *cpi) {
VP10_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->td.mb;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
}
}
-void vp10_mv_pred(VP9_COMP *cpi, MACROBLOCK *x,
+void vp10_mv_pred(VP10_COMP *cpi, MACROBLOCK *x,
uint8_t *ref_y_buffer, int ref_y_stride,
int ref_frame, BLOCK_SIZE block_size) {
int i;
return base + vp10_raster_block_offset(plane_bsize, raster_block, stride);
}
-YV12_BUFFER_CONFIG *vp10_get_scaled_ref_frame(const VP9_COMP *cpi,
+YV12_BUFFER_CONFIG *vp10_get_scaled_ref_frame(const VP10_COMP *cpi,
int ref_frame) {
const VP10_COMMON *const cm = &cpi->common;
const int scaled_idx = cpi->scaled_ref_idx[ref_frame - 1];
&cm->buffer_pool->frame_bufs[scaled_idx].buf : NULL;
}
-int vp10_get_switchable_rate(const VP9_COMP *cpi, const MACROBLOCKD *const xd) {
+int vp10_get_switchable_rate(const VP10_COMP *cpi,
+ const MACROBLOCKD *const xd) {
const MB_MODE_INFO *const mbmi = &xd->mi[0]->mbmi;
const int ctx = vp10_get_pred_context_switchable_interp(xd);
return SWITCHABLE_INTERP_RATE_FACTOR *
cpi->switchable_interp_costs[ctx][mbmi->interp_filter];
}
-void vp10_set_rd_speed_thresholds(VP9_COMP *cpi) {
+void vp10_set_rd_speed_thresholds(VP10_COMP *cpi) {
int i;
RD_OPT *const rd = &cpi->rd;
SPEED_FEATURES *const sf = &cpi->sf;
rd->thresh_mult[THR_D63_PRED] += 2500;
}
-void vp10_set_rd_speed_thresholds_sub8x8(VP9_COMP *cpi) {
+void vp10_set_rd_speed_thresholds_sub8x8(VP10_COMP *cpi) {
static const int thresh_mult[2][MAX_REFS] =
{{2500, 2500, 2500, 4500, 4500, 2500},
{2000, 2000, 2000, 4000, 4000, 2000}};
struct TileInfo;
struct TileDataEnc;
-struct VP9_COMP;
+struct VP10_COMP;
struct macroblock;
-int vp10_compute_rd_mult(const struct VP9_COMP *cpi, int qindex);
+int vp10_compute_rd_mult(const struct VP10_COMP *cpi, int qindex);
-void vp10_initialize_rd_consts(struct VP9_COMP *cpi);
+void vp10_initialize_rd_consts(struct VP10_COMP *cpi);
-void vp10_initialize_me_consts(struct VP9_COMP *cpi, MACROBLOCK *x, int qindex);
+void vp10_initialize_me_consts(struct VP10_COMP *cpi,
+ MACROBLOCK *x, int qindex);
void vp10_model_rd_from_var_lapndz(unsigned int var, unsigned int n,
unsigned int qstep, int *rate,
int64_t *dist);
-int vp10_get_switchable_rate(const struct VP9_COMP *cpi,
+int vp10_get_switchable_rate(const struct VP10_COMP *cpi,
const MACROBLOCKD *const xd);
int vp10_raster_block_offset(BLOCK_SIZE plane_bsize,
int16_t* vp10_raster_block_offset_int16(BLOCK_SIZE plane_bsize,
int raster_block, int16_t *base);
-YV12_BUFFER_CONFIG *vp10_get_scaled_ref_frame(const struct VP9_COMP *cpi,
+YV12_BUFFER_CONFIG *vp10_get_scaled_ref_frame(const struct VP10_COMP *cpi,
int ref_frame);
void vp10_init_me_luts(void);
ENTROPY_CONTEXT t_above[16],
ENTROPY_CONTEXT t_left[16]);
-void vp10_set_rd_speed_thresholds(struct VP9_COMP *cpi);
+void vp10_set_rd_speed_thresholds(struct VP10_COMP *cpi);
-void vp10_set_rd_speed_thresholds_sub8x8(struct VP9_COMP *cpi);
+void vp10_set_rd_speed_thresholds_sub8x8(struct VP10_COMP *cpi);
void vp10_update_rd_thresh_fact(int (*fact)[MAX_MODES], int rd_thresh,
int bsize, int best_mode_index);
return best_rd < ((int64_t)thresh * thresh_fact >> 5) || thresh == INT_MAX;
}
-void vp10_mv_pred(struct VP9_COMP *cpi, MACROBLOCK *x,
+void vp10_mv_pred(struct VP10_COMP *cpi, MACROBLOCK *x,
uint8_t *ref_y_buffer, int ref_y_stride,
int ref_frame, BLOCK_SIZE block_size);
}
}
-static void model_rd_for_sb(VP9_COMP *cpi, BLOCK_SIZE bsize,
+static void model_rd_for_sb(VP10_COMP *cpi, BLOCK_SIZE bsize,
MACROBLOCK *x, MACROBLOCKD *xd,
int *out_rate_sum, int64_t *out_dist_sum,
int *skip_txfm_sb, int64_t *skip_sse_sb) {
}
}
-static void choose_largest_tx_size(VP9_COMP *cpi, MACROBLOCK *x,
+static void choose_largest_tx_size(VP10_COMP *cpi, MACROBLOCK *x,
int *rate, int64_t *distortion,
int *skip, int64_t *sse,
int64_t ref_best_rd,
mbmi->tx_size, cpi->sf.use_fast_coef_costing);
}
-static void choose_tx_size_from_rd(VP9_COMP *cpi, MACROBLOCK *x,
+static void choose_tx_size_from_rd(VP10_COMP *cpi, MACROBLOCK *x,
int *rate,
int64_t *distortion,
int *skip,
*psse = sse[mbmi->tx_size];
}
-static void super_block_yrd(VP9_COMP *cpi, MACROBLOCK *x, int *rate,
+static void super_block_yrd(VP10_COMP *cpi, MACROBLOCK *x, int *rate,
int64_t *distortion, int *skip,
int64_t *psse, BLOCK_SIZE bs,
int64_t ref_best_rd) {
return 0;
}
-static int64_t rd_pick_intra4x4block(VP9_COMP *cpi, MACROBLOCK *x,
+static int64_t rd_pick_intra4x4block(VP10_COMP *cpi, MACROBLOCK *x,
int row, int col,
PREDICTION_MODE *best_mode,
const int *bmode_costs,
return best_rd;
}
-static int64_t rd_pick_intra_sub_8x8_y_mode(VP9_COMP *cpi, MACROBLOCK *mb,
+static int64_t rd_pick_intra_sub_8x8_y_mode(VP10_COMP *cpi, MACROBLOCK *mb,
int *rate, int *rate_y,
int64_t *distortion,
int64_t best_rd) {
}
// This function is used only for intra_only frames
-static int64_t rd_pick_intra_sby_mode(VP9_COMP *cpi, MACROBLOCK *x,
+static int64_t rd_pick_intra_sby_mode(VP10_COMP *cpi, MACROBLOCK *x,
int *rate, int *rate_tokenonly,
int64_t *distortion, int *skippable,
BLOCK_SIZE bsize,
// Return value 0: early termination triggered, no valid rd cost available;
// 1: rd cost values are valid.
-static int super_block_uvrd(const VP9_COMP *cpi, MACROBLOCK *x,
+static int super_block_uvrd(const VP10_COMP *cpi, MACROBLOCK *x,
int *rate, int64_t *distortion, int *skippable,
int64_t *sse, BLOCK_SIZE bsize,
int64_t ref_best_rd) {
return is_cost_valid;
}
-static int64_t rd_pick_intra_sbuv_mode(VP9_COMP *cpi, MACROBLOCK *x,
+static int64_t rd_pick_intra_sbuv_mode(VP10_COMP *cpi, MACROBLOCK *x,
PICK_MODE_CONTEXT *ctx,
int *rate, int *rate_tokenonly,
int64_t *distortion, int *skippable,
return best_rd;
}
-static int64_t rd_sbuv_dcpred(const VP9_COMP *cpi, MACROBLOCK *x,
+static int64_t rd_sbuv_dcpred(const VP10_COMP *cpi, MACROBLOCK *x,
int *rate, int *rate_tokenonly,
int64_t *distortion, int *skippable,
BLOCK_SIZE bsize) {
return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
}
-static void choose_intra_uv_mode(VP9_COMP *cpi, MACROBLOCK *const x,
+static void choose_intra_uv_mode(VP10_COMP *cpi, MACROBLOCK *const x,
PICK_MODE_CONTEXT *ctx,
BLOCK_SIZE bsize, TX_SIZE max_tx_size,
int *rate_uv, int *rate_uv_tokenonly,
*mode_uv = x->e_mbd.mi[0]->mbmi.uv_mode;
}
-static int cost_mv_ref(const VP9_COMP *cpi, PREDICTION_MODE mode,
+static int cost_mv_ref(const VP10_COMP *cpi, PREDICTION_MODE mode,
int mode_context) {
assert(is_inter_mode(mode));
return cpi->inter_mode_cost[mode_context][INTER_OFFSET(mode)];
}
-static int set_and_cost_bmi_mvs(VP9_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd,
+static int set_and_cost_bmi_mvs(VP10_COMP *cpi, MACROBLOCK *x, MACROBLOCKD *xd,
int i,
PREDICTION_MODE mode, int_mv this_mv[2],
int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES],
thismvcost;
}
-static int64_t encode_inter_mb_segment(VP9_COMP *cpi,
+static int64_t encode_inter_mb_segment(VP10_COMP *cpi,
MACROBLOCK *x,
int64_t best_yrd,
int i,
// Check if NEARESTMV/NEARMV/ZEROMV is the cheapest way encode zero motion.
// TODO(aconverse): Find out if this is still productive then clean up or remove
static int check_best_zero_mv(
- const VP9_COMP *cpi, const uint8_t mode_context[MAX_REF_FRAMES],
+ const VP10_COMP *cpi, const uint8_t mode_context[MAX_REF_FRAMES],
int_mv frame_mv[MB_MODE_COUNT][MAX_REF_FRAMES], int this_mode,
const MV_REFERENCE_FRAME ref_frames[2]) {
if ((this_mode == NEARMV || this_mode == NEARESTMV || this_mode == ZEROMV) &&
return 1;
}
-static void joint_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
+static void joint_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
BLOCK_SIZE bsize,
int_mv *frame_mv,
int mi_row, int mi_col,
}
}
-static int64_t rd_pick_best_sub8x8_mode(VP9_COMP *cpi, MACROBLOCK *x,
+static int64_t rd_pick_best_sub8x8_mode(VP10_COMP *cpi, MACROBLOCK *x,
int_mv *best_ref_mv,
int_mv *second_best_ref_mv,
int64_t best_rd, int *returntotrate,
sizeof(*best_filter_diff) * SWITCHABLE_FILTER_CONTEXTS);
}
-static void setup_buffer_inter(VP9_COMP *cpi, MACROBLOCK *x,
+static void setup_buffer_inter(VP10_COMP *cpi, MACROBLOCK *x,
MV_REFERENCE_FRAME ref_frame,
BLOCK_SIZE block_size,
int mi_row, int mi_col,
ref_frame, block_size);
}
-static void single_motion_search(VP9_COMP *cpi, MACROBLOCK *x,
+static void single_motion_search(VP10_COMP *cpi, MACROBLOCK *x,
BLOCK_SIZE bsize,
int mi_row, int mi_col,
int_mv *tmp_mv, int *rate_mv) {
// However, once established that vector may be usable through the nearest and
// near mv modes to reduce distortion in subsequent blocks and also improve
// visual quality.
-static int discount_newmv_test(const VP9_COMP *cpi,
+static int discount_newmv_test(const VP10_COMP *cpi,
int this_mode,
int_mv this_mv,
int_mv (*mode_mv)[MAX_REF_FRAMES],
(mode_mv[NEARMV][ref_frame].as_int == INVALID_MV)));
}
-static int64_t handle_inter_mode(VP9_COMP *cpi, MACROBLOCK *x,
+static int64_t handle_inter_mode(VP10_COMP *cpi, MACROBLOCK *x,
BLOCK_SIZE bsize,
int *rate2, int64_t *distortion,
int *skippable,
return 0; // The rate-distortion cost will be re-calculated by caller.
}
-void vp10_rd_pick_intra_mode_sb(VP9_COMP *cpi, MACROBLOCK *x,
+void vp10_rd_pick_intra_mode_sb(VP10_COMP *cpi, MACROBLOCK *x,
RD_COST *rd_cost, BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx, int64_t best_rd) {
VP10_COMMON *const cm = &cpi->common;
#define LOW_VAR_THRESH 16
#define VLOW_ADJ_MAX 25
#define VHIGH_ADJ_MAX 8
-static void rd_variance_adjustment(VP9_COMP *cpi,
+static void rd_variance_adjustment(VP10_COMP *cpi,
MACROBLOCK *x,
BLOCK_SIZE bsize,
int64_t *this_rd,
// Do we have an internal image edge (e.g. formatting bars).
-int vp10_internal_image_edge(VP9_COMP *cpi) {
+int vp10_internal_image_edge(VP10_COMP *cpi) {
return (cpi->oxcf.pass == 2) &&
((cpi->twopass.this_frame_stats.inactive_zone_rows > 0) ||
(cpi->twopass.this_frame_stats.inactive_zone_cols > 0));
// Checks to see if a super block is on a horizontal image edge.
// In most cases this is the "real" edge unless there are formatting
// bars embedded in the stream.
-int vp10_active_h_edge(VP9_COMP *cpi, int mi_row, int mi_step) {
+int vp10_active_h_edge(VP10_COMP *cpi, int mi_row, int mi_step) {
int top_edge = 0;
int bottom_edge = cpi->common.mi_rows;
int is_active_h_edge = 0;
// Checks to see if a super block is on a vertical image edge.
// In most cases this is the "real" edge unless there are formatting
// bars embedded in the stream.
-int vp10_active_v_edge(VP9_COMP *cpi, int mi_col, int mi_step) {
+int vp10_active_v_edge(VP10_COMP *cpi, int mi_col, int mi_step) {
int left_edge = 0;
int right_edge = cpi->common.mi_cols;
int is_active_v_edge = 0;
// Checks to see if a super block is at the edge of the active image.
// In most cases this is the "real" edge unless there are formatting
// bars embedded in the stream.
-int vp10_active_edge_sb(VP9_COMP *cpi,
+int vp10_active_edge_sb(VP10_COMP *cpi,
int mi_row, int mi_col) {
return vp10_active_h_edge(cpi, mi_row, MI_BLOCK_SIZE) ||
vp10_active_v_edge(cpi, mi_col, MI_BLOCK_SIZE);
}
-void vp10_rd_pick_inter_mode_sb(VP9_COMP *cpi,
+void vp10_rd_pick_inter_mode_sb(VP10_COMP *cpi,
TileDataEnc *tile_data,
MACROBLOCK *x,
int mi_row, int mi_col,
best_filter_diff, best_mode_skippable);
}
-void vp10_rd_pick_inter_mode_sb_seg_skip(VP9_COMP *cpi,
+void vp10_rd_pick_inter_mode_sb_seg_skip(VP10_COMP *cpi,
TileDataEnc *tile_data,
MACROBLOCK *x,
RD_COST *rd_cost,
best_pred_diff, best_filter_diff, 0);
}
-void vp10_rd_pick_inter_mode_sub8x8(VP9_COMP *cpi,
+void vp10_rd_pick_inter_mode_sub8x8(VP10_COMP *cpi,
TileDataEnc *tile_data,
MACROBLOCK *x,
int mi_row, int mi_col,
#endif
struct TileInfo;
-struct VP9_COMP;
+struct VP10_COMP;
struct macroblock;
struct RD_COST;
-void vp10_rd_pick_intra_mode_sb(struct VP9_COMP *cpi, struct macroblock *x,
+void vp10_rd_pick_intra_mode_sb(struct VP10_COMP *cpi, struct macroblock *x,
struct RD_COST *rd_cost, BLOCK_SIZE bsize,
PICK_MODE_CONTEXT *ctx, int64_t best_rd);
-unsigned int vp10_get_sby_perpixel_variance(VP9_COMP *cpi,
+unsigned int vp10_get_sby_perpixel_variance(VP10_COMP *cpi,
const struct buf_2d *ref,
BLOCK_SIZE bs);
#if CONFIG_VP9_HIGHBITDEPTH
-unsigned int vp10_high_get_sby_perpixel_variance(VP9_COMP *cpi,
+unsigned int vp10_high_get_sby_perpixel_variance(VP10_COMP *cpi,
const struct buf_2d *ref,
BLOCK_SIZE bs, int bd);
#endif
-void vp10_rd_pick_inter_mode_sb(struct VP9_COMP *cpi,
+void vp10_rd_pick_inter_mode_sb(struct VP10_COMP *cpi,
struct TileDataEnc *tile_data,
struct macroblock *x,
int mi_row, int mi_col,
BLOCK_SIZE bsize, PICK_MODE_CONTEXT *ctx,
int64_t best_rd_so_far);
-void vp10_rd_pick_inter_mode_sb_seg_skip(struct VP9_COMP *cpi,
+void vp10_rd_pick_inter_mode_sb_seg_skip(struct VP10_COMP *cpi,
struct TileDataEnc *tile_data,
struct macroblock *x,
struct RD_COST *rd_cost,
PICK_MODE_CONTEXT *ctx,
int64_t best_rd_so_far);
-int vp10_internal_image_edge(struct VP9_COMP *cpi);
-int vp10_active_h_edge(struct VP9_COMP *cpi, int mi_row, int mi_step);
-int vp10_active_v_edge(struct VP9_COMP *cpi, int mi_col, int mi_step);
-int vp10_active_edge_sb(struct VP9_COMP *cpi, int mi_row, int mi_col);
+int vp10_internal_image_edge(struct VP10_COMP *cpi);
+int vp10_active_h_edge(struct VP10_COMP *cpi, int mi_row, int mi_step);
+int vp10_active_v_edge(struct VP10_COMP *cpi, int mi_col, int mi_step);
+int vp10_active_edge_sb(struct VP10_COMP *cpi, int mi_row, int mi_col);
-void vp10_rd_pick_inter_mode_sub8x8(struct VP9_COMP *cpi,
+void vp10_rd_pick_inter_mode_sub8x8(struct VP10_COMP *cpi,
struct TileDataEnc *tile_data,
struct macroblock *x,
int mi_row, int mi_col,
#ifdef OUTPUT_YUV_SKINMAP
// For viewing skin map on input source.
-void vp10_compute_skin_map(VP9_COMP *const cpi, FILE *yuv_skinmap_file) {
+void vp10_compute_skin_map(VP10_COMP *const cpi, FILE *yuv_skinmap_file) {
int i, j, mi_row, mi_col;
VP10_COMMON *const cm = &cpi->common;
uint8_t *y;
extern "C" {
#endif
-struct VP9_COMP;
+struct VP10_COMP;
// #define OUTPUT_YUV_SKINMAP
#ifdef OUTPUT_YUV_SKINMAP
// For viewing skin map on input source.
-void vp10_compute_skin_map(VP9_COMP *const cpi, FILE *yuv_skinmap_file);
+void vp10_compute_skin_map(VP10_COMP *const cpi, FILE *yuv_skinmap_file);
#endif
#ifdef __cplusplus
// Intra only frames, golden frames (except alt ref overlays) and
// alt ref frames tend to be coded at a higher than ambient quality
-static int frame_is_boosted(const VP9_COMP *cpi) {
+static int frame_is_boosted(const VP10_COMP *cpi) {
return frame_is_kf_gf_arf(cpi) || vp10_is_upper_layer_key_frame(cpi);
}
}
}
-static void set_good_speed_feature_framesize_dependent(VP9_COMP *cpi,
+static void set_good_speed_feature_framesize_dependent(VP10_COMP *cpi,
SPEED_FEATURES *sf,
int speed) {
VP10_COMMON *const cm = &cpi->common;
}
}
-static void set_good_speed_feature(VP9_COMP *cpi, VP10_COMMON *cm,
+static void set_good_speed_feature(VP10_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,
+static void set_rt_speed_feature_framesize_dependent(VP10_COMP *cpi,
SPEED_FEATURES *sf, int speed) {
VP10_COMMON *const cm = &cpi->common;
}
}
-static void set_rt_speed_feature(VP9_COMP *cpi, SPEED_FEATURES *sf,
+static void set_rt_speed_feature(VP10_COMP *cpi, SPEED_FEATURES *sf,
int speed, vp9e_tune_content content) {
VP10_COMMON *const cm = &cpi->common;
const int is_keyframe = cm->frame_type == KEY_FRAME;
}
}
-void vp10_set_speed_features_framesize_dependent(VP9_COMP *cpi) {
+void vp10_set_speed_features_framesize_dependent(VP10_COMP *cpi) {
SPEED_FEATURES *const sf = &cpi->sf;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
RD_OPT *const rd = &cpi->rd;
}
}
-void vp10_set_speed_features_framesize_independent(VP9_COMP *cpi) {
+void vp10_set_speed_features_framesize_independent(VP10_COMP *cpi) {
SPEED_FEATURES *const sf = &cpi->sf;
VP10_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &cpi->td.mb;
int simple_model_rd_from_var;
} SPEED_FEATURES;
-struct VP9_COMP;
+struct VP10_COMP;
-void vp10_set_speed_features_framesize_independent(struct VP9_COMP *cpi);
-void vp10_set_speed_features_framesize_dependent(struct VP9_COMP *cpi);
+void vp10_set_speed_features_framesize_independent(struct VP10_COMP *cpi);
+void vp10_set_speed_features_framesize_dependent(struct VP10_COMP *cpi);
#ifdef __cplusplus
} // extern "C"
#define SMALL_FRAME_WIDTH 16
#define SMALL_FRAME_HEIGHT 16
-void vp10_init_layer_context(VP9_COMP *const cpi) {
+void vp10_init_layer_context(VP10_COMP *const cpi) {
SVC *const svc = &cpi->svc;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
int sl, tl;
}
// Update the layer context from a change_config() call.
-void vp10_update_layer_context_change_config(VP9_COMP *const cpi,
+void vp10_update_layer_context_change_config(VP10_COMP *const cpi,
const int target_bandwidth) {
SVC *const svc = &cpi->svc;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
}
}
-static LAYER_CONTEXT *get_layer_context(VP9_COMP *const cpi) {
+static LAYER_CONTEXT *get_layer_context(VP10_COMP *const cpi) {
if (is_one_pass_cbr_svc(cpi))
return &cpi->svc.layer_context[cpi->svc.spatial_layer_id *
cpi->svc.number_temporal_layers + cpi->svc.temporal_layer_id];
&cpi->svc.layer_context[cpi->svc.spatial_layer_id];
}
-void vp10_update_temporal_layer_framerate(VP9_COMP *const cpi) {
+void vp10_update_temporal_layer_framerate(VP10_COMP *const cpi) {
SVC *const svc = &cpi->svc;
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
LAYER_CONTEXT *const lc = get_layer_context(cpi);
}
}
-void vp10_update_spatial_layer_framerate(VP9_COMP *const cpi, double framerate) {
+void vp10_update_spatial_layer_framerate(VP10_COMP *const cpi,
+ double framerate) {
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
LAYER_CONTEXT *const lc = get_layer_context(cpi);
RATE_CONTROL *const lrc = &lc->rc;
vp10_rc_set_gf_interval_range(cpi, lrc);
}
-void vp10_restore_layer_context(VP9_COMP *const cpi) {
+void vp10_restore_layer_context(VP10_COMP *const cpi) {
LAYER_CONTEXT *const lc = get_layer_context(cpi);
const int old_frame_since_key = cpi->rc.frames_since_key;
const int old_frame_to_key = cpi->rc.frames_to_key;
}
}
-void vp10_save_layer_context(VP9_COMP *const cpi) {
+void vp10_save_layer_context(VP10_COMP *const cpi) {
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
LAYER_CONTEXT *const lc = get_layer_context(cpi);
lc->alt_ref_source = cpi->alt_ref_source;
}
-void vp10_init_second_pass_spatial_svc(VP9_COMP *cpi) {
+void vp10_init_second_pass_spatial_svc(VP10_COMP *cpi) {
SVC *const svc = &cpi->svc;
int i;
svc->spatial_layer_id = 0;
}
-void vp10_inc_frame_in_layer(VP9_COMP *const cpi) {
+void vp10_inc_frame_in_layer(VP10_COMP *const cpi) {
LAYER_CONTEXT *const lc =
&cpi->svc.layer_context[cpi->svc.spatial_layer_id *
cpi->svc.number_temporal_layers];
++lc->frames_from_key_frame;
}
-int vp10_is_upper_layer_key_frame(const VP9_COMP *const cpi) {
+int vp10_is_upper_layer_key_frame(const VP10_COMP *const cpi) {
return is_two_pass_svc(cpi) &&
cpi->svc.spatial_layer_id > 0 &&
cpi->svc.layer_context[cpi->svc.spatial_layer_id *
// The function sets proper ref_frame_flags, buffer indices, and buffer update
// variables for temporal layering mode 3 - that does 0-2-1-2 temporal layering
// scheme.
-static void set_flags_and_fb_idx_for_temporal_mode3(VP9_COMP *const cpi) {
+static void set_flags_and_fb_idx_for_temporal_mode3(VP10_COMP *const cpi) {
int frame_num_within_temporal_struct = 0;
int spatial_id, temporal_id;
spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode;
// The function sets proper ref_frame_flags, buffer indices, and buffer update
// variables for temporal layering mode 2 - that does 0-1-0-1 temporal layering
// scheme.
-static void set_flags_and_fb_idx_for_temporal_mode2(VP9_COMP *const cpi) {
+static void set_flags_and_fb_idx_for_temporal_mode2(VP10_COMP *const cpi) {
int spatial_id, temporal_id;
spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode;
temporal_id = cpi->svc.temporal_layer_id =
// The function sets proper ref_frame_flags, buffer indices, and buffer update
// variables for temporal layering mode 0 - that has no temporal layering.
static void set_flags_and_fb_idx_for_temporal_mode_noLayering(
- VP9_COMP *const cpi) {
+ VP10_COMP *const cpi) {
int spatial_id;
spatial_id = cpi->svc.spatial_layer_id = cpi->svc.spatial_layer_to_encode;
cpi->ext_refresh_last_frame =
cpi->gld_fb_idx = 0;
}
-int vp10_one_pass_cbr_svc_start_layer(VP9_COMP *const cpi) {
+int vp10_one_pass_cbr_svc_start_layer(VP10_COMP *const cpi) {
int width = 0, height = 0;
LAYER_CONTEXT *lc = NULL;
}
#if CONFIG_SPATIAL_SVC
-int vp10_svc_start_frame(VP9_COMP *const cpi) {
+int vp10_svc_start_frame(VP10_COMP *const cpi) {
int width = 0, height = 0;
LAYER_CONTEXT *lc;
struct lookahead_entry *buf;
#endif
-struct lookahead_entry *vp10_svc_lookahead_pop(VP9_COMP *const cpi,
+struct lookahead_entry *vp10_svc_lookahead_pop(VP10_COMP *const cpi,
struct lookahead_ctx *ctx,
int drain) {
struct lookahead_entry *buf = NULL;
VP9E_TEMPORAL_LAYERING_MODE temporal_layering_mode;
} SVC;
-struct VP9_COMP;
+struct VP10_COMP;
// Initialize layer context data from init_config().
-void vp10_init_layer_context(struct VP9_COMP *const cpi);
+void vp10_init_layer_context(struct VP10_COMP *const cpi);
// Update the layer context from a change_config() call.
-void vp10_update_layer_context_change_config(struct VP9_COMP *const cpi,
+void vp10_update_layer_context_change_config(struct VP10_COMP *const cpi,
const int target_bandwidth);
// Prior to encoding the frame, update framerate-related quantities
// for the current temporal layer.
-void vp10_update_temporal_layer_framerate(struct VP9_COMP *const cpi);
+void vp10_update_temporal_layer_framerate(struct VP10_COMP *const cpi);
// Update framerate-related quantities for the current spatial layer.
-void vp10_update_spatial_layer_framerate(struct VP9_COMP *const cpi,
+void vp10_update_spatial_layer_framerate(struct VP10_COMP *const cpi,
double framerate);
// Prior to encoding the frame, set the layer context, for the current layer
// to be encoded, to the cpi struct.
-void vp10_restore_layer_context(struct VP9_COMP *const cpi);
+void vp10_restore_layer_context(struct VP10_COMP *const cpi);
// Save the layer context after encoding the frame.
-void vp10_save_layer_context(struct VP9_COMP *const cpi);
+void vp10_save_layer_context(struct VP10_COMP *const cpi);
// Initialize second pass rc for spatial svc.
-void vp10_init_second_pass_spatial_svc(struct VP9_COMP *cpi);
+void vp10_init_second_pass_spatial_svc(struct VP10_COMP *cpi);
// Increment number of video frames in layer
-void vp10_inc_frame_in_layer(struct VP9_COMP *const cpi);
+void vp10_inc_frame_in_layer(struct VP10_COMP *const cpi);
// Check if current layer is key frame in spatial upper layer
-int vp10_is_upper_layer_key_frame(const struct VP9_COMP *const cpi);
+int vp10_is_upper_layer_key_frame(const struct VP10_COMP *const cpi);
// Get the next source buffer to encode
-struct lookahead_entry *vp10_svc_lookahead_pop(struct VP9_COMP *const cpi,
+struct lookahead_entry *vp10_svc_lookahead_pop(struct VP10_COMP *const cpi,
struct lookahead_ctx *ctx,
int drain);
// Start a frame and initialize svc parameters
-int vp10_svc_start_frame(struct VP9_COMP *const cpi);
+int vp10_svc_start_frame(struct VP10_COMP *const cpi);
-int vp10_one_pass_cbr_svc_start_layer(struct VP9_COMP *const cpi);
+int vp10_one_pass_cbr_svc_start_layer(struct VP10_COMP *const cpi);
#ifdef __cplusplus
} // extern "C"
}
#endif // CONFIG_VP9_HIGHBITDEPTH
-static int temporal_filter_find_matching_mb_c(VP9_COMP *cpi,
+static int temporal_filter_find_matching_mb_c(VP10_COMP *cpi,
uint8_t *arf_frame_buf,
uint8_t *frame_ptr_buf,
int stride) {
return bestsme;
}
-static void temporal_filter_iterate_c(VP9_COMP *cpi,
+static void temporal_filter_iterate_c(VP10_COMP *cpi,
YV12_BUFFER_CONFIG **frames,
int frame_count,
int alt_ref_index,
}
// Apply buffer limits and context specific adjustments to arnr filter.
-static void adjust_arnr_filter(VP9_COMP *cpi,
+static void adjust_arnr_filter(VP10_COMP *cpi,
int distance, int group_boost,
int *arnr_frames, int *arnr_strength) {
const VP9EncoderConfig *const oxcf = &cpi->oxcf;
*arnr_strength = strength;
}
-void vp10_temporal_filter(VP9_COMP *cpi, int distance) {
+void vp10_temporal_filter(VP10_COMP *cpi, int distance) {
VP10_COMMON *const cm = &cpi->common;
RATE_CONTROL *const rc = &cpi->rc;
MACROBLOCKD *const xd = &cpi->td.mb.e_mbd;
#endif
void vp10_temporal_filter_init(void);
-void vp10_temporal_filter(VP9_COMP *cpi, int distance);
+void vp10_temporal_filter(VP10_COMP *cpi, int distance);
#ifdef __cplusplus
} // extern "C"
struct tokenize_b_args {
- VP9_COMP *cpi;
+ VP10_COMP *cpi;
ThreadData *td;
TOKENEXTRA **tp;
};
static void tokenize_b(int plane, int block, BLOCK_SIZE plane_bsize,
TX_SIZE tx_size, void *arg) {
struct tokenize_b_args* const args = arg;
- VP9_COMP *cpi = args->cpi;
+ VP10_COMP *cpi = args->cpi;
ThreadData *const td = args->td;
MACROBLOCK *const x = &td->mb;
MACROBLOCKD *const xd = &x->e_mbd;
return result;
}
-void vp10_tokenize_sb(VP9_COMP *cpi, ThreadData *td, TOKENEXTRA **t,
+void vp10_tokenize_sb(VP10_COMP *cpi, ThreadData *td, TOKENEXTRA **t,
int dry_run, BLOCK_SIZE bsize) {
VP10_COMMON *const cm = &cpi->common;
MACROBLOCK *const x = &td->mb;
int vp10_is_skippable_in_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane);
int vp10_has_high_freq_in_plane(MACROBLOCK *x, BLOCK_SIZE bsize, int plane);
-struct VP9_COMP;
+struct VP10_COMP;
struct ThreadData;
-void vp10_tokenize_sb(struct VP9_COMP *cpi, struct ThreadData *td,
+void vp10_tokenize_sb(struct VP10_COMP *cpi, struct ThreadData *td,
TOKENEXTRA **t, int dry_run, BLOCK_SIZE bsize);
extern const int16_t *vp10_dct_value_cost_ptr;
vpx_codec_enc_cfg_t cfg;
struct vp10_extracfg extra_cfg;
VP9EncoderConfig oxcf;
- VP9_COMP *cpi;
+ VP10_COMP *cpi;
unsigned char *cx_data;
size_t cx_data_sz;
unsigned char *pending_cx_data;
return (n * timebase->den + round) / timebase->num / TICKS_PER_SEC;
}
-static vpx_codec_frame_flags_t get_frame_pkt_flags(const VP9_COMP *cpi,
+static vpx_codec_frame_flags_t get_frame_pkt_flags(const VP10_COMP *cpi,
unsigned int lib_flags) {
vpx_codec_frame_flags_t flags = lib_flags << 16;
vpx_enc_frame_flags_t flags,
unsigned long deadline) {
vpx_codec_err_t res = VPX_CODEC_OK;
- VP9_COMP *const cpi = ctx->cpi;
+ VP10_COMP *const cpi = ctx->cpi;
const vpx_rational_t *const timebase = &ctx->cfg.g_timebase;
size_t data_sz;
static vpx_codec_err_t ctrl_set_svc_layer_id(vpx_codec_alg_priv_t *ctx,
va_list args) {
vpx_svc_layer_id_t *const data = va_arg(args, vpx_svc_layer_id_t *);
- VP9_COMP *const cpi = (VP9_COMP *)ctx->cpi;
+ VP10_COMP *const cpi = (VP10_COMP *)ctx->cpi;
SVC *const svc = &cpi->svc;
svc->spatial_layer_id = data->spatial_layer_id;
static vpx_codec_err_t ctrl_get_svc_layer_id(vpx_codec_alg_priv_t *ctx,
va_list args) {
vpx_svc_layer_id_t *data = va_arg(args, vpx_svc_layer_id_t *);
- VP9_COMP *const cpi = (VP9_COMP *)ctx->cpi;
+ VP10_COMP *const cpi = (VP10_COMP *)ctx->cpi;
SVC *const svc = &cpi->svc;
data->spatial_layer_id = svc->spatial_layer_id;
static vpx_codec_err_t ctrl_set_svc_parameters(vpx_codec_alg_priv_t *ctx,
va_list args) {
- VP9_COMP *const cpi = ctx->cpi;
+ VP10_COMP *const cpi = ctx->cpi;
vpx_svc_extra_cfg_t *const params = va_arg(args, vpx_svc_extra_cfg_t *);
int sl, tl;
projects / libvpx / commitdiff