generic-library/vpx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add support for tile rows.

Browse Source 
These allow sending partial bitstream packets over the network before
encoding a complete frame is completed, thus lowering end-to-end
latency. The tile-rows are not independent.

Change-Id: I99986595cbcbff9153e2a14f49b4aa7dee4768e2
This commit is contained in:
Ronald S. Bultje
2013-02-08 11:33:11 -08:00
committed by Gerrit Code Review
parent 56049d9488
commit 89a206ef2f
13 changed files with 163 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
vp9/common/vp9_onyx.h
View File

@@ -177,6 +177,7 @@ extern "C"
int arnr_type;
int tile_columns;
int tile_rows;
struct vpx_fixed_buf two_pass_stats_in;
struct vpx_codec_pkt_list *output_pkt_list;

4
vp9/common/vp9_onyxc_int.h
View File

@@ -280,7 +280,9 @@ typedef struct VP9Common {
int frame_parallel_decoding_mode;
int tile_columns, log2_tile_columns;
int cur_tile_mb_col_start, cur_tile_mb_col_end, cur_tile_idx;
int cur_tile_mb_col_start, cur_tile_mb_col_end, cur_tile_col_idx;
int tile_rows, log2_tile_rows;
int cur_tile_mb_row_start, cur_tile_mb_row_end, cur_tile_row_idx;
} VP9_COMMON;
static int get_free_fb(VP9_COMMON *cm) {

32
vp9/common/vp9_tile_common.c
View File

@@ -10,17 +10,29 @@
#include "vp9/common/vp9_tile_common.h"
void vp9_get_tile_offsets(VP9_COMMON *cm, int *min_tile_off,
int *max_tile_off) {
const int log2_n_tiles = cm->log2_tile_columns;
const int tile_idx = cm->cur_tile_idx;
const int mb_cols = cm->mb_cols;
const int sb_cols = (mb_cols + 3) >> 2;
const int sb_off1 = (tile_idx * sb_cols) >> log2_n_tiles;
const int sb_off2 = ((tile_idx + 1) * sb_cols) >> log2_n_tiles;
static void vp9_get_tile_offsets(VP9_COMMON *cm, int *min_tile_off,
int *max_tile_off, int tile_idx,
int log2_n_tiles, int n_mbs) {
const int n_sbs = (n_mbs + 3) >> 2;
const int sb_off1 = (tile_idx * n_sbs) >> log2_n_tiles;
const int sb_off2 = ((tile_idx + 1) * n_sbs) >> log2_n_tiles;
*min_tile_off = (sb_off1 << 2) > mb_cols ? mb_cols : (sb_off1 << 2);
*max_tile_off = (sb_off2 << 2) > mb_cols ? mb_cols : (sb_off2 << 2);
*min_tile_off = (sb_off1 << 2) > n_mbs ? n_mbs : (sb_off1 << 2);
*max_tile_off = (sb_off2 << 2) > n_mbs ? n_mbs : (sb_off2 << 2);
}
void vp9_get_tile_col_offsets(VP9_COMMON *cm, int tile_col_idx) {
cm->cur_tile_col_idx = tile_col_idx;
vp9_get_tile_offsets(cm, &cm->cur_tile_mb_col_start,
&cm->cur_tile_mb_col_end, tile_col_idx,
cm->log2_tile_columns, cm->mb_cols);
}
void vp9_get_tile_row_offsets(VP9_COMMON *cm, int tile_row_idx) {
cm->cur_tile_row_idx = tile_row_idx;
vp9_get_tile_offsets(cm, &cm->cur_tile_mb_row_start,
&cm->cur_tile_mb_row_end, tile_row_idx,
cm->log2_tile_rows, cm->mb_rows);
}
#define MIN_TILE_WIDTH_SBS (MIN_TILE_WIDTH >> 6)

5
vp9/common/vp9_tile_common.h
View File

@@ -16,8 +16,9 @@
#define MIN_TILE_WIDTH 256
#define MAX_TILE_WIDTH 4096
extern void vp9_get_tile_offsets(VP9_COMMON *cm, int *min_tile_off,
int *max_tile_off);
extern void vp9_get_tile_col_offsets(VP9_COMMON *cm, int tile_col_idx);
extern void vp9_get_tile_row_offsets(VP9_COMMON *cm, int tile_row_idx);
extern void vp9_get_tile_n_bits(VP9_COMMON *cm, int *min_log2_n_tiles,
int *delta_log2_n_tiles);

97
vp9/decoder/vp9_decodframe.c
View File

@@ -1770,7 +1770,7 @@ int vp9_decode_frame(VP9D_COMP *pbi, const unsigned char **p_data_end) {
/* tile info */
{
const unsigned char *data_ptr = data + first_partition_length_in_bytes;
int tile, delta_log2_tiles;
int tile_row, tile_col, delta_log2_tiles;
vp9_get_tile_n_bits(pc, &pc->log2_tile_columns, &delta_log2_tiles);
while (delta_log2_tiles--) {
@@ -1780,55 +1780,80 @@ int vp9_decode_frame(VP9D_COMP *pbi, const unsigned char **p_data_end) {
break;
}
}
pc->log2_tile_rows = vp9_read_bit(&header_bc);
if (pc->log2_tile_rows)
pc->log2_tile_rows += vp9_read_bit(&header_bc);
pc->tile_columns = 1 << pc->log2_tile_columns;
pc->tile_rows = 1 << pc->log2_tile_rows;
vpx_memset(pc->above_context, 0,
sizeof(ENTROPY_CONTEXT_PLANES) * pc->mb_cols);
if (pbi->oxcf.inv_tile_order) {
const unsigned char *data_ptr2[4];
const int n_cols = pc->tile_columns;
const unsigned char *data_ptr2[4][1 << 6];
BOOL_DECODER UNINITIALIZED_IS_SAFE(bc_bak);
data_ptr2[0] = data_ptr;
for (tile = 1; tile < pc->tile_columns; tile++) {
int size = data_ptr2[tile - 1][0] + (data_ptr2[tile - 1][1] << 8) +
(data_ptr2[tile - 1][2] << 16) + (data_ptr2[tile - 1][3] << 24);
data_ptr2[tile - 1] += 4;
data_ptr2[tile] = data_ptr2[tile - 1] + size;
}
for (tile = pc->tile_columns - 1; tile >= 0; tile--) {
pc->cur_tile_idx = tile;
vp9_get_tile_offsets(pc, &pc->cur_tile_mb_col_start,
&pc->cur_tile_mb_col_end);
setup_token_decoder(pbi, data_ptr2[tile], &residual_bc);
/* Decode a row of superblocks */
for (mb_row = 0; mb_row < pc->mb_rows; mb_row += 4) {
decode_sb_row(pbi, pc, mb_row, xd, &residual_bc);
// pre-initialize the offsets, we're going to read in inverse order
data_ptr2[0][0] = data_ptr;
for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
if (tile_row) {
int size = data_ptr2[tile_row - 1][n_cols - 1][0] +
(data_ptr2[tile_row - 1][n_cols - 1][1] << 8) +
(data_ptr2[tile_row - 1][n_cols - 1][2] << 16) +
(data_ptr2[tile_row - 1][n_cols - 1][3] << 24);
data_ptr2[tile_row - 1][n_cols - 1] += 4;
data_ptr2[tile_row][0] = data_ptr2[tile_row - 1][n_cols - 1] + size;
}
for (tile_col = 1; tile_col < n_cols; tile_col++) {
int size = data_ptr2[tile_row][tile_col - 1][0] +
(data_ptr2[tile_row][tile_col - 1][1] << 8) +
(data_ptr2[tile_row][tile_col - 1][2] << 16) +
(data_ptr2[tile_row][tile_col - 1][3] << 24);
data_ptr2[tile_row][tile_col - 1] += 4;
data_ptr2[tile_row][tile_col] =
data_ptr2[tile_row][tile_col - 1] + size;
}
}
for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
vp9_get_tile_row_offsets(pc, tile_row);
for (tile_col = n_cols - 1; tile_col >= 0; tile_col--) {
vp9_get_tile_col_offsets(pc, tile_col);
setup_token_decoder(pbi, data_ptr2[tile_row][tile_col], &residual_bc);
/* Decode a row of superblocks */
for (mb_row = pc->cur_tile_mb_row_start;
mb_row < pc->cur_tile_mb_row_end; mb_row += 4) {
decode_sb_row(pbi, pc, mb_row, xd, &residual_bc);
}
if (tile_row == pc->tile_rows - 1 && tile_col == n_cols - 1)
bc_bak = residual_bc;
}
if (tile == pc->tile_columns - 1)
bc_bak = residual_bc;
}
residual_bc = bc_bak;
} else {
for (tile = 0; tile < pc->tile_columns; tile++) {
pc->cur_tile_idx = tile;
vp9_get_tile_offsets(pc, &pc->cur_tile_mb_col_start,
&pc->cur_tile_mb_col_end);
for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
vp9_get_tile_row_offsets(pc, tile_row);
for (tile_col = 0; tile_col < pc->tile_columns; tile_col++) {
vp9_get_tile_col_offsets(pc, tile_col);
if (tile < pc->tile_columns - 1)
setup_token_decoder(pbi, data_ptr + 4, &residual_bc);
else
setup_token_decoder(pbi, data_ptr, &residual_bc);
if (tile_col < pc->tile_columns - 1 || tile_row < pc->tile_rows - 1)
setup_token_decoder(pbi, data_ptr + 4, &residual_bc);
else
setup_token_decoder(pbi, data_ptr, &residual_bc);
/* Decode a row of superblocks */
for (mb_row = 0; mb_row < pc->mb_rows; mb_row += 4) {
decode_sb_row(pbi, pc, mb_row, xd, &residual_bc);
}
if (tile < pc->tile_columns - 1) {
int size = data_ptr[0] + (data_ptr[1] << 8) + (data_ptr[2] << 16) +
(data_ptr[3] << 24);
data_ptr += 4 + size;
/* Decode a row of superblocks */
for (mb_row = pc->cur_tile_mb_row_start;
mb_row < pc->cur_tile_mb_row_end; mb_row += 4) {
decode_sb_row(pbi, pc, mb_row, xd, &residual_bc);
}
if (tile_col < pc->tile_columns - 1 || tile_row < pc->tile_rows - 1) {
int size = data_ptr[0] + (data_ptr[1] << 8) + (data_ptr[2] << 16) +
(data_ptr[3] << 24);
data_ptr += 4 + size;
}
}
}
}

66
vp9/encoder/vp9_bitstream.c
View File

@@ -1089,14 +1089,15 @@ static void write_modes_b(VP9_COMP *cpi, MODE_INFO *m, vp9_writer *bc,
}
static void write_modes(VP9_COMP *cpi, vp9_writer* const bc,
TOKENEXTRA **tok) {
TOKENEXTRA **tok, TOKENEXTRA *tok_end) {
VP9_COMMON *const c = &cpi->common;
const int mis = c->mode_info_stride;
MODE_INFO *m, *m_ptr = c->mi + c->cur_tile_mb_col_start;
MODE_INFO *m, *m_ptr = c->mi;
int i, mb_row, mb_col;
TOKENEXTRA *tok_end = *tok + cpi->tok_count;
for (mb_row = 0; mb_row < c->mb_rows; mb_row += 4, m_ptr += 4 * mis) {
m_ptr += c->cur_tile_mb_col_start + c->cur_tile_mb_row_start * mis;
for (mb_row = c->cur_tile_mb_row_start;
mb_row < c->cur_tile_mb_row_end; mb_row += 4, m_ptr += 4 * mis) {
m = m_ptr;
for (mb_col = c->cur_tile_mb_col_start;
mb_col < c->cur_tile_mb_col_end; mb_col += 4, m += 4) {
@@ -2046,6 +2047,9 @@ void vp9_pack_bitstream(VP9_COMP *cpi, unsigned char *dest,
break;
}
}
vp9_write_bit(&header_bc, pc->log2_tile_rows != 0);
if (pc->log2_tile_rows != 0)
vp9_write_bit(&header_bc, pc->log2_tile_rows != 1);
}
vp9_stop_encode(&header_bc);
@@ -2075,33 +2079,45 @@ void vp9_pack_bitstream(VP9_COMP *cpi, unsigned char *dest,
}
{
int tile, total_size = 0;
int tile_row, tile_col, total_size = 0;
unsigned char *data_ptr = cx_data + header_bc.pos;
TOKENEXTRA *tok = cpi->tok;
TOKENEXTRA *tok[1 << 6], *tok_end;
for (tile = 0; tile < pc->tile_columns; tile++) {
pc->cur_tile_idx = tile;
vp9_get_tile_offsets(pc, &pc->cur_tile_mb_col_start,
&pc->cur_tile_mb_col_end);
tok[0] = cpi->tok;
for (tile_col = 1; tile_col < pc->tile_columns; tile_col++)
tok[tile_col] = tok[tile_col - 1] + cpi->tok_count[tile_col - 1];
if (tile < pc->tile_columns - 1)
vp9_start_encode(&residual_bc, data_ptr + total_size + 4);
else
vp9_start_encode(&residual_bc, data_ptr + total_size);
write_modes(cpi, &residual_bc, &tok);
vp9_stop_encode(&residual_bc);
if (tile < pc->tile_columns - 1) {
/* size of this tile */
data_ptr[total_size + 0] = residual_bc.pos;
data_ptr[total_size + 1] = residual_bc.pos >> 8;
data_ptr[total_size + 2] = residual_bc.pos >> 16;
data_ptr[total_size + 3] = residual_bc.pos >> 24;
total_size += 4;
for (tile_row = 0; tile_row < pc->tile_rows; tile_row++) {
vp9_get_tile_row_offsets(pc, tile_row);
tok_end = cpi->tok + cpi->tok_count[0];
for (tile_col = 0; tile_col < pc->tile_columns;
tile_col++, tok_end += cpi->tok_count[tile_col]) {
vp9_get_tile_col_offsets(pc, tile_col);
if (tile_col < pc->tile_columns - 1 || tile_row < pc->tile_rows - 1)
vp9_start_encode(&residual_bc, data_ptr + total_size + 4);
else
vp9_start_encode(&residual_bc, data_ptr + total_size);
write_modes(cpi, &residual_bc, &tok[tile_col], tok_end);
vp9_stop_encode(&residual_bc);
if (tile_col < pc->tile_columns - 1 || tile_row < pc->tile_rows - 1) {
/* size of this tile */
data_ptr[total_size + 0] = residual_bc.pos;
data_ptr[total_size + 1] = residual_bc.pos >> 8;
data_ptr[total_size + 2] = residual_bc.pos >> 16;
data_ptr[total_size + 3] = residual_bc.pos >> 24;
total_size += 4;
}
total_size += residual_bc.pos;
}
total_size += residual_bc.pos;
}
assert((unsigned int)(tok[0] - cpi->tok) == cpi->tok_count[0]);
for (tile_col = 1; tile_col < pc->tile_columns; tile_col++)
assert((unsigned int)(tok[tile_col] - tok[tile_col - 1]) ==
cpi->tok_count[tile_col]);
*size += total_size;
}
}

16
vp9/encoder/vp9_encodeframe.c
View File

@@ -1231,8 +1231,6 @@ static void encode_frame_internal(VP9_COMP *cpi) {
MACROBLOCK *const x = &cpi->mb;
VP9_COMMON *const cm = &cpi->common;
MACROBLOCKD *const xd = &x->e_mbd;
TOKENEXTRA *tp = cpi->tok;
int totalrate;
// printf("encode_frame_internal frame %d (%d)\n",
@@ -1313,19 +1311,19 @@ static void encode_frame_internal(VP9_COMP *cpi) {
{
// Take tiles into account and give start/end MB
int tile;
int tile_col;
TOKENEXTRA *tp = cpi->tok;
for (tile_col = 0; tile_col < cm->tile_columns; tile_col++) {
TOKENEXTRA *tp_old = tp;
for (tile = 0; tile < cm->tile_columns; tile++) {
// For each row of SBs in the frame
cm->cur_tile_idx = tile;
vp9_get_tile_offsets(cm, &cm->cur_tile_mb_col_start,
&cm->cur_tile_mb_col_end);
vp9_get_tile_col_offsets(cm, tile_col);
for (mb_row = 0; mb_row < cm->mb_rows; mb_row += 4) {
encode_sb_row(cpi, mb_row, &tp, &totalrate);
}
cpi->tok_count[tile_col] = (unsigned int)(tp - tp_old);
}
cpi->tok_count = (unsigned int)(tp - cpi->tok);
}
vpx_usec_timer_mark(&emr_timer);

13
vp9/encoder/vp9_onyx_if.c
View File

@@ -1105,9 +1105,13 @@ rescale(int val, int num, int denom) {
return (int)(llval * llnum / llden);
}
static void set_tile_limits(VP9_COMMON *cm) {
static void set_tile_limits(VP9_COMP *cpi) {
VP9_COMMON *const cm = &cpi->common;
int min_log2_tiles, max_log2_tiles;
cm->log2_tile_columns = cpi->oxcf.tile_columns;
cm->log2_tile_rows = cpi->oxcf.tile_rows;
vp9_get_tile_n_bits(cm, &min_log2_tiles, &max_log2_tiles);
max_log2_tiles += min_log2_tiles;
if (cm->log2_tile_columns < min_log2_tiles)
@@ -1115,6 +1119,7 @@ static void set_tile_limits(VP9_COMMON *cm) {
else if (cm->log2_tile_columns > max_log2_tiles)
cm->log2_tile_columns = max_log2_tiles;
cm->tile_columns = 1 << cm->log2_tile_columns;
cm->tile_rows = 1 << cm->log2_tile_rows;
}
static void init_config(VP9_PTR ptr, VP9_CONFIG *oxcf) {
@@ -1154,8 +1159,7 @@ static void init_config(VP9_PTR ptr, VP9_CONFIG *oxcf) {
cpi->gld_fb_idx = 1;
cpi->alt_fb_idx = 2;
cm->log2_tile_columns = cpi->oxcf.tile_columns;
set_tile_limits(cm);
set_tile_limits(cpi);
#if VP9_TEMPORAL_ALT_REF
{
@@ -1382,8 +1386,7 @@ void vp9_change_config(VP9_PTR ptr, VP9_CONFIG *oxcf) {
cpi->last_frame_distortion = 0;
#endif
cm->log2_tile_columns = cpi->oxcf.tile_columns;
set_tile_limits(cm);
set_tile_limits(cpi);
}
#define M_LOG2_E 0.693147180559945309417

2
vp9/encoder/vp9_onyx_int.h
View File

@@ -347,7 +347,7 @@ typedef struct VP9_COMP {
YV12_BUFFER_CONFIG last_frame_uf;
TOKENEXTRA *tok;
unsigned int tok_count;
unsigned int tok_count[1 << 6];
unsigned int frames_since_key;

8
vp9/encoder/vp9_segmentation.c
View File

@@ -255,7 +255,7 @@ void vp9_choose_segmap_coding_method(VP9_COMP *cpi) {
int t_pred_cost = INT_MAX;
int i;
int tile, mb_row, mb_col;
int tile_col, mb_row, mb_col;
int temporal_predictor_count[PREDICTION_PROBS][2];
int no_pred_segcounts[MAX_MB_SEGMENTS];
@@ -283,10 +283,8 @@ void vp9_choose_segmap_coding_method(VP9_COMP *cpi) {
// First of all generate stats regarding how well the last segment map
// predicts this one
for (tile = 0; tile < cm->tile_columns; tile++) {
cm->cur_tile_idx = tile;
vp9_get_tile_offsets(cm, &cm->cur_tile_mb_col_start,
&cm->cur_tile_mb_col_end);
for (tile_col = 0; tile_col < cm->tile_columns; tile_col++) {
vp9_get_tile_col_offsets(cm, tile_col);
mi_ptr = cm->mi + cm->cur_tile_mb_col_start;
for (mb_row = 0; mb_row < cm->mb_rows; mb_row += 4, mi_ptr += 4 * mis) {
mi = mi_ptr;

6
vp9/vp9_cx_iface.c
View File

@@ -27,6 +27,7 @@ struct vp8_extracfg {
unsigned int Sharpness;
unsigned int static_thresh;
unsigned int tile_columns;
unsigned int tile_rows;
unsigned int arnr_max_frames; /* alt_ref Noise Reduction Max Frame Count */
unsigned int arnr_strength; /* alt_ref Noise Reduction Strength */
unsigned int arnr_type; /* alt_ref filter type */
@@ -55,6 +56,7 @@ static const struct extraconfig_map extracfg_map[] = {
0, /* Sharpness */
0, /* static_thresh */
0, /* tile_columns */
0, /* tile_rows */
0, /* arnr_max_frames */
3, /* arnr_strength */
3, /* arnr_type*/
@@ -172,6 +174,7 @@ static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t *ctx,
RANGE_CHECK_HI(vp8_cfg, noise_sensitivity, 6);
RANGE_CHECK(vp8_cfg, tile_columns, 0, 6);
RANGE_CHECK(vp8_cfg, tile_rows, 0, 2);
RANGE_CHECK_HI(vp8_cfg, Sharpness, 7);
RANGE_CHECK(vp8_cfg, arnr_max_frames, 0, 15);
RANGE_CHECK_HI(vp8_cfg, arnr_strength, 6);
@@ -309,6 +312,7 @@ static vpx_codec_err_t set_vp8e_config(VP9_CONFIG *oxcf,
oxcf->tuning = vp8_cfg.tuning;
oxcf->tile_columns = vp8_cfg.tile_columns;
oxcf->tile_rows = vp8_cfg.tile_rows;
#if CONFIG_LOSSLESS
oxcf->lossless = vp8_cfg.lossless;
@@ -416,6 +420,7 @@ static vpx_codec_err_t set_param(vpx_codec_alg_priv_t *ctx,
MAP(VP8E_SET_SHARPNESS, xcfg.Sharpness);
MAP(VP8E_SET_STATIC_THRESHOLD, xcfg.static_thresh);
MAP(VP9E_SET_TILE_COLUMNS, xcfg.tile_columns);
MAP(VP9E_SET_TILE_ROWS, xcfg.tile_rows);
MAP(VP8E_SET_ARNR_MAXFRAMES, xcfg.arnr_max_frames);
MAP(VP8E_SET_ARNR_STRENGTH, xcfg.arnr_strength);
@@ -1006,6 +1011,7 @@ static vpx_codec_ctrl_fn_map_t vp8e_ctf_maps[] = {
{VP8E_SET_SHARPNESS, set_param},
{VP8E_SET_STATIC_THRESHOLD, set_param},
{VP9E_SET_TILE_COLUMNS, set_param},
{VP9E_SET_TILE_ROWS, set_param},
{VP8E_GET_LAST_QUANTIZER, get_param},
{VP8E_GET_LAST_QUANTIZER_64, get_param},
{VP8E_SET_ARNR_MAXFRAMES, set_param},

4
vpx/vp8cx.h
View File

@@ -188,7 +188,8 @@ enum vp8e_enc_control_id {
/* TODO(jkoleszar): Move to vp9cx.h */
VP9E_SET_LOSSLESS,
VP9E_SET_TILE_COLUMNS
VP9E_SET_TILE_COLUMNS,
VP9E_SET_TILE_ROWS,
};
/*!\brief vpx 1-D scaling mode
@@ -300,6 +301,7 @@ VPX_CTRL_USE_TYPE(VP8E_SET_TUNING, int) /* vp8e_tuning */
VPX_CTRL_USE_TYPE(VP8E_SET_CQ_LEVEL, unsigned int)
VPX_CTRL_USE_TYPE(VP9E_SET_TILE_COLUMNS, int)
VPX_CTRL_USE_TYPE(VP9E_SET_TILE_ROWS, int)
VPX_CTRL_USE_TYPE(VP8E_GET_LAST_QUANTIZER, int *)
VPX_CTRL_USE_TYPE(VP8E_GET_LAST_QUANTIZER_64, int *)

6
vpxenc.c
View File

@@ -1084,6 +1084,8 @@ static const arg_def_t token_parts = ARG_DEF(NULL, "token-parts", 1,
"Number of token partitions to use, log2");
static const arg_def_t tile_cols = ARG_DEF(NULL, "tile-columns", 1,
"Number of tile columns to use, log2");
static const arg_def_t tile_rows = ARG_DEF(NULL, "tile-rows", 1,
"Number of tile rows to use, log2");
static const arg_def_t auto_altref = ARG_DEF(NULL, "auto-alt-ref", 1,
"Enable automatic alt reference frames");
static const arg_def_t arnr_maxframes = ARG_DEF(NULL, "arnr-maxframes", 1,
@@ -1127,7 +1129,7 @@ static const int vp8_arg_ctrl_map[] = {
#if CONFIG_VP9_ENCODER
static const arg_def_t *vp9_args[] = {
&cpu_used, &auto_altref, &noise_sens, &sharpness, &static_thresh,
&tile_cols, &arnr_maxframes, &arnr_strength, &arnr_type,
&tile_cols, &tile_rows, &arnr_maxframes, &arnr_strength, &arnr_type,
&tune_ssim, &cq_level, &max_intra_rate_pct,
#if CONFIG_LOSSLESS
&lossless,
@@ -1137,7 +1139,7 @@ static const arg_def_t *vp9_args[] = {
static const int vp9_arg_ctrl_map[] = {
VP8E_SET_CPUUSED, VP8E_SET_ENABLEAUTOALTREF,
VP8E_SET_NOISE_SENSITIVITY, VP8E_SET_SHARPNESS, VP8E_SET_STATIC_THRESHOLD,
VP9E_SET_TILE_COLUMNS,
VP9E_SET_TILE_COLUMNS, VP9E_SET_TILE_ROWS,
VP8E_SET_ARNR_MAXFRAMES, VP8E_SET_ARNR_STRENGTH, VP8E_SET_ARNR_TYPE,
VP8E_SET_TUNING, VP8E_SET_CQ_LEVEL, VP8E_SET_MAX_INTRA_BITRATE_PCT,
#if CONFIG_LOSSLESS