Merge "Assign 2nd ref frame in choose_partitioning"
diff --git a/build/make/configure.sh b/build/make/configure.sh
index 932dd8e..c0b5072 100644
--- a/build/make/configure.sh
+++ b/build/make/configure.sh
@@ -1159,6 +1159,14 @@
auto|"")
which nasm >/dev/null 2>&1 && AS=nasm
which yasm >/dev/null 2>&1 && AS=yasm
+ if [ "${AS}" = nasm ] ; then
+ # Apple ships version 0.98 of nasm through at least Xcode 6. Revisit
+ # this check if they start shipping a compatible version.
+ apple=`nasm -v | grep "Apple"`
+ [ -n "${apple}" ] \
+ && echo "Unsupported version of nasm: ${apple}" \
+ && AS=""
+ fi
[ "${AS}" = auto ] || [ -z "${AS}" ] \
&& die "Neither yasm nor nasm have been found"
;;
diff --git a/test/decode_api_test.cc b/test/decode_api_test.cc
index 2837f8c..f9b13f6 100644
--- a/test/decode_api_test.cc
+++ b/test/decode_api_test.cc
@@ -57,6 +57,21 @@
}
}
+#if CONFIG_VP8_DECODER
+TEST(DecodeAPI, OptionalParams) {
+ vpx_codec_ctx_t dec;
+
+#if CONFIG_ERROR_CONCEALMENT
+ EXPECT_EQ(VPX_CODEC_OK, vpx_codec_dec_init(&dec, &vpx_codec_vp8_dx_algo, NULL,
+ VPX_CODEC_USE_ERROR_CONCEALMENT));
+#else
+ EXPECT_EQ(VPX_CODEC_INCAPABLE,
+ vpx_codec_dec_init(&dec, &vpx_codec_vp8_dx_algo, NULL,
+ VPX_CODEC_USE_ERROR_CONCEALMENT));
+#endif // CONFIG_ERROR_CONCEALMENT
+}
+#endif // CONFIG_VP8_DECODER
+
#if CONFIG_VP9_DECODER
// Test VP9 codec controls after a decode error to ensure the code doesn't
// misbehave.
diff --git a/test/encode_test_driver.h b/test/encode_test_driver.h
index 765c7d1..7b7dd31 100644
--- a/test/encode_test_driver.h
+++ b/test/encode_test_driver.h
@@ -140,6 +140,12 @@
}
#endif
+ void Config(const vpx_codec_enc_cfg_t *cfg) {
+ const vpx_codec_err_t res = vpx_codec_enc_config_set(&encoder_, cfg);
+ ASSERT_EQ(VPX_CODEC_OK, res) << EncoderError();
+ cfg_ = *cfg;
+ }
+
void set_deadline(unsigned long deadline) {
deadline_ = deadline;
}
diff --git a/test/resize_test.cc b/test/resize_test.cc
index 5c25dc1..ef84156 100644
--- a/test/resize_test.cc
+++ b/test/resize_test.cc
@@ -261,9 +261,115 @@
}
}
+vpx_img_fmt_t CspForFrameNumber(int frame) {
+ if (frame < 10)
+ return VPX_IMG_FMT_I420;
+ if (frame < 20)
+ return VPX_IMG_FMT_I444;
+ return VPX_IMG_FMT_I420;
+}
+
+class ResizeCspTest : public ResizeTest {
+ protected:
+#if WRITE_COMPRESSED_STREAM
+ ResizeCspTest()
+ : ResizeTest(),
+ frame0_psnr_(0.0),
+ outfile_(NULL),
+ out_frames_(0) {}
+#else
+ ResizeCspTest() : ResizeTest(), frame0_psnr_(0.0) {}
+#endif
+
+ virtual ~ResizeCspTest() {}
+
+ virtual void BeginPassHook(unsigned int /*pass*/) {
+#if WRITE_COMPRESSED_STREAM
+ outfile_ = fopen("vp91-2-05-cspchape.ivf", "wb");
+#endif
+ }
+
+ virtual void EndPassHook() {
+#if WRITE_COMPRESSED_STREAM
+ if (outfile_) {
+ if (!fseek(outfile_, 0, SEEK_SET))
+ write_ivf_file_header(&cfg_, out_frames_, outfile_);
+ fclose(outfile_);
+ outfile_ = NULL;
+ }
+#endif
+ }
+
+ virtual void PreEncodeFrameHook(libvpx_test::VideoSource *video,
+ libvpx_test::Encoder *encoder) {
+ if (CspForFrameNumber(video->frame()) != VPX_IMG_FMT_I420 &&
+ cfg_.g_profile != 1) {
+ cfg_.g_profile = 1;
+ encoder->Config(&cfg_);
+ }
+ if (CspForFrameNumber(video->frame()) == VPX_IMG_FMT_I420 &&
+ cfg_.g_profile != 0) {
+ cfg_.g_profile = 0;
+ encoder->Config(&cfg_);
+ }
+ }
+
+ virtual void PSNRPktHook(const vpx_codec_cx_pkt_t *pkt) {
+ if (!frame0_psnr_)
+ frame0_psnr_ = pkt->data.psnr.psnr[0];
+ EXPECT_NEAR(pkt->data.psnr.psnr[0], frame0_psnr_, 2.0);
+ }
+
+#if WRITE_COMPRESSED_STREAM
+ virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {
+ ++out_frames_;
+
+ // Write initial file header if first frame.
+ if (pkt->data.frame.pts == 0)
+ write_ivf_file_header(&cfg_, 0, outfile_);
+
+ // Write frame header and data.
+ write_ivf_frame_header(pkt, outfile_);
+ (void)fwrite(pkt->data.frame.buf, 1, pkt->data.frame.sz, outfile_);
+ }
+#endif
+
+ double frame0_psnr_;
+#if WRITE_COMPRESSED_STREAM
+ FILE *outfile_;
+ unsigned int out_frames_;
+#endif
+};
+
+class ResizingCspVideoSource : public ::libvpx_test::DummyVideoSource {
+ public:
+ ResizingCspVideoSource() {
+ SetSize(kInitialWidth, kInitialHeight);
+ limit_ = 30;
+ }
+
+ virtual ~ResizingCspVideoSource() {}
+
+ protected:
+ virtual void Next() {
+ ++frame_;
+ SetImageFormat(CspForFrameNumber(frame_));
+ FillFrame();
+ }
+};
+
+TEST_P(ResizeCspTest, TestResizeCspWorks) {
+ ResizingCspVideoSource video;
+ cfg_.rc_min_quantizer = cfg_.rc_max_quantizer = 48;
+ cfg_.g_lag_in_frames = 0;
+ ASSERT_NO_FATAL_FAILURE(RunLoop(&video));
+}
+
VP8_INSTANTIATE_TEST_CASE(ResizeTest, ONE_PASS_TEST_MODES);
VP9_INSTANTIATE_TEST_CASE(ResizeTest,
::testing::Values(::libvpx_test::kRealTime));
VP9_INSTANTIATE_TEST_CASE(ResizeInternalTest,
::testing::Values(::libvpx_test::kOnePassBest));
+VP9_INSTANTIATE_TEST_CASE(ResizeCspTest,
+ ::testing::Values(::libvpx_test::kRealTime));
} // namespace
diff --git a/test/video_source.h b/test/video_source.h
index b97e155..63294d1 100644
--- a/test/video_source.h
+++ b/test/video_source.h
@@ -134,8 +134,13 @@
class DummyVideoSource : public VideoSource {
public:
- DummyVideoSource() : img_(NULL), limit_(100), width_(0), height_(0) {
- SetSize(80, 64);
+ DummyVideoSource()
+ : img_(NULL),
+ limit_(100),
+ width_(80),
+ height_(64),
+ format_(VPX_IMG_FMT_I420) {
+ ReallocImage();
}
virtual ~DummyVideoSource() { vpx_img_free(img_); }
@@ -174,23 +179,35 @@
void SetSize(unsigned int width, unsigned int height) {
if (width != width_ || height != height_) {
- vpx_img_free(img_);
- img_ = vpx_img_alloc(NULL, VPX_IMG_FMT_I420, width, height, 32);
- raw_sz_ = ((img_->w + 31) & ~31) * img_->h * 3 / 2;
width_ = width;
height_ = height;
+ ReallocImage();
+ }
+ }
+
+ void SetImageFormat(vpx_img_fmt_t format) {
+ if (format_ != format) {
+ format_ = format;
+ ReallocImage();
}
}
protected:
virtual void FillFrame() { if (img_) memset(img_->img_data, 0, raw_sz_); }
+ void ReallocImage() {
+ vpx_img_free(img_);
+ img_ = vpx_img_alloc(NULL, format_, width_, height_, 32);
+ raw_sz_ = ((img_->w + 31) & ~31) * img_->h * img_->bps / 8;
+ }
+
vpx_image_t *img_;
size_t raw_sz_;
unsigned int limit_;
unsigned int frame_;
unsigned int width_;
unsigned int height_;
+ vpx_img_fmt_t format_;
};
diff --git a/vp9/decoder/vp9_decodeframe.c b/vp9/decoder/vp9_decodeframe.c
index c69bfa6..07249d0 100644
--- a/vp9/decoder/vp9_decodeframe.c
+++ b/vp9/decoder/vp9_decodeframe.c
@@ -299,6 +299,7 @@
struct intra_args {
VP9_COMMON *cm;
MACROBLOCKD *xd;
+ FRAME_COUNTS *counts;
vp9_reader *r;
};
@@ -323,7 +324,7 @@
x, y, plane);
if (!mi->mbmi.skip) {
- const int eob = vp9_decode_block_tokens(cm, xd, plane, block,
+ const int eob = vp9_decode_block_tokens(cm, xd, args->counts, plane, block,
plane_bsize, x, y, tx_size,
args->r);
inverse_transform_block(xd, plane, block, tx_size, dst, pd->dst.stride,
@@ -335,6 +336,7 @@
VP9_COMMON *cm;
MACROBLOCKD *xd;
vp9_reader *r;
+ FRAME_COUNTS *counts;
int *eobtotal;
};
@@ -347,8 +349,8 @@
struct macroblockd_plane *const pd = &xd->plane[plane];
int x, y, eob;
txfrm_block_to_raster_xy(plane_bsize, tx_size, block, &x, &y);
- eob = vp9_decode_block_tokens(cm, xd, plane, block, plane_bsize, x, y,
- tx_size, args->r);
+ eob = vp9_decode_block_tokens(cm, xd, args->counts, plane, block, plane_bsize,
+ x, y, tx_size, args->r);
inverse_transform_block(xd, plane, block, tx_size,
&pd->dst.buf[4 * y * pd->dst.stride + 4 * x],
pd->dst.stride, eob);
@@ -385,13 +387,14 @@
}
static void decode_block(VP9Decoder *const pbi, MACROBLOCKD *const xd,
+ FRAME_COUNTS *counts,
const TileInfo *const tile,
int mi_row, int mi_col,
vp9_reader *r, BLOCK_SIZE bsize) {
VP9_COMMON *const cm = &pbi->common;
const int less8x8 = bsize < BLOCK_8X8;
MB_MODE_INFO *mbmi = set_offsets(cm, xd, tile, bsize, mi_row, mi_col);
- vp9_read_mode_info(pbi, xd, tile, mi_row, mi_col, r);
+ vp9_read_mode_info(pbi, xd, counts, tile, mi_row, mi_col, r);
if (less8x8)
bsize = BLOCK_8X8;
@@ -405,7 +408,7 @@
}
if (!is_inter_block(mbmi)) {
- struct intra_args arg = { cm, xd, r };
+ struct intra_args arg = { cm, xd, counts, r };
vp9_foreach_transformed_block(xd, bsize,
predict_and_reconstruct_intra_block, &arg);
} else {
@@ -415,7 +418,7 @@
// Reconstruction
if (!mbmi->skip) {
int eobtotal = 0;
- struct inter_args arg = { cm, xd, r, &eobtotal };
+ struct inter_args arg = { cm, xd, r, counts, &eobtotal };
vp9_foreach_transformed_block(xd, bsize, reconstruct_inter_block, &arg);
if (!less8x8 && eobtotal == 0)
mbmi->skip = 1; // skip loopfilter
@@ -425,7 +428,8 @@
xd->corrupted |= vp9_reader_has_error(r);
}
-static PARTITION_TYPE read_partition(VP9_COMMON *cm, MACROBLOCKD *xd, int hbs,
+static PARTITION_TYPE read_partition(VP9_COMMON *cm, MACROBLOCKD *xd,
+ FRAME_COUNTS *counts, int hbs,
int mi_row, int mi_col, BLOCK_SIZE bsize,
vp9_reader *r) {
const int ctx = partition_plane_context(xd, mi_row, mi_col, bsize);
@@ -444,12 +448,13 @@
p = PARTITION_SPLIT;
if (!cm->frame_parallel_decoding_mode)
- ++cm->counts.partition[ctx][p];
+ ++counts->partition[ctx][p];
return p;
}
static void decode_partition(VP9Decoder *const pbi, MACROBLOCKD *const xd,
+ FRAME_COUNTS *counts,
const TileInfo *const tile,
int mi_row, int mi_col,
vp9_reader* r, BLOCK_SIZE bsize) {
@@ -461,34 +466,37 @@
if (mi_row >= cm->mi_rows || mi_col >= cm->mi_cols)
return;
- partition = read_partition(cm, xd, hbs, mi_row, mi_col, bsize, r);
+ partition = read_partition(cm, xd, counts, hbs, mi_row, mi_col, bsize, r);
subsize = get_subsize(bsize, partition);
uv_subsize = ss_size_lookup[subsize][cm->subsampling_x][cm->subsampling_y];
if (subsize >= BLOCK_8X8 && uv_subsize == BLOCK_INVALID)
vpx_internal_error(xd->error_info,
VPX_CODEC_CORRUPT_FRAME, "Invalid block size.");
if (subsize < BLOCK_8X8) {
- decode_block(pbi, xd, tile, mi_row, mi_col, r, subsize);
+ decode_block(pbi, xd, counts, tile, mi_row, mi_col, r, subsize);
} else {
switch (partition) {
case PARTITION_NONE:
- decode_block(pbi, xd, tile, mi_row, mi_col, r, subsize);
+ decode_block(pbi, xd, counts, tile, mi_row, mi_col, r, subsize);
break;
case PARTITION_HORZ:
- decode_block(pbi, xd, tile, mi_row, mi_col, r, subsize);
+ decode_block(pbi, xd, counts, tile, mi_row, mi_col, r, subsize);
if (mi_row + hbs < cm->mi_rows)
- decode_block(pbi, xd, tile, mi_row + hbs, mi_col, r, subsize);
+ decode_block(pbi, xd, counts, tile, mi_row + hbs, mi_col, r, subsize);
break;
case PARTITION_VERT:
- decode_block(pbi, xd, tile, mi_row, mi_col, r, subsize);
+ decode_block(pbi, xd, counts, tile, mi_row, mi_col, r, subsize);
if (mi_col + hbs < cm->mi_cols)
- decode_block(pbi, xd, tile, mi_row, mi_col + hbs, r, subsize);
+ decode_block(pbi, xd, counts, tile, mi_row, mi_col + hbs, r, subsize);
break;
case PARTITION_SPLIT:
- decode_partition(pbi, xd, tile, mi_row, mi_col, r, subsize);
- decode_partition(pbi, xd, tile, mi_row, mi_col + hbs, r, subsize);
- decode_partition(pbi, xd, tile, mi_row + hbs, mi_col, r, subsize);
- decode_partition(pbi, xd, tile, mi_row + hbs, mi_col + hbs, r, subsize);
+ decode_partition(pbi, xd, counts, tile, mi_row, mi_col, r, subsize);
+ decode_partition(pbi, xd, counts, tile, mi_row, mi_col + hbs, r,
+ subsize);
+ decode_partition(pbi, xd, counts, tile, mi_row + hbs, mi_col, r,
+ subsize);
+ decode_partition(pbi, xd, counts, tile, mi_row + hbs, mi_col + hbs, r,
+ subsize);
break;
default:
assert(0 && "Invalid partition type");
@@ -983,8 +991,8 @@
vp9_zero(tile_data->xd.left_seg_context);
for (mi_col = tile.mi_col_start; mi_col < tile.mi_col_end;
mi_col += MI_BLOCK_SIZE) {
- decode_partition(pbi, &tile_data->xd, &tile, mi_row, mi_col,
- &tile_data->bit_reader, BLOCK_64X64);
+ decode_partition(pbi, &tile_data->xd, &cm->counts, &tile, mi_row,
+ mi_col, &tile_data->bit_reader, BLOCK_64X64);
}
pbi->mb.corrupted |= tile_data->xd.corrupted;
if (pbi->mb.corrupted)
@@ -1056,8 +1064,10 @@
vp9_zero(tile_data->xd.left_seg_context);
for (mi_col = tile->mi_col_start; mi_col < tile->mi_col_end;
mi_col += MI_BLOCK_SIZE) {
- decode_partition(tile_data->pbi, &tile_data->xd, tile,
- mi_row, mi_col, &tile_data->bit_reader, BLOCK_64X64);
+ decode_partition(tile_data->pbi, &tile_data->xd,
+ &tile_data->pbi->common.counts,
+ tile, mi_row, mi_col, &tile_data->bit_reader,
+ BLOCK_64X64);
}
}
return !tile_data->xd.corrupted;
@@ -1812,12 +1822,6 @@
? average_split_mvs(pd, mi, ref, block)
: mi->mbmi.mv[ref].as_mv;
-
- // TODO(jkoleszar): This clamping is done in the incorrect place for the
- // scaling case. It needs to be done on the scaled MV, not the pre-scaling
- // MV. Note however that it performs the subsampling aware scaling so
- // that the result is always q4.
- // mv_precision precision is MV_PRECISION_Q4.
const MV mv_q4 = clamp_mv_to_umv_border_sb(xd, &mv, bw, bh,
pd->subsampling_x,
pd->subsampling_y);
@@ -1829,6 +1833,7 @@
const int idx = xd->block_refs[ref]->idx;
BufferPool *const pool = pbi->common.buffer_pool;
RefCntBuffer *const ref_frame_buf = &pool->frame_bufs[idx];
+ const int is_scaled = vp9_is_scaled(sf);
// Get reference frame pointer, width and height.
if (plane == 0) {
@@ -1842,7 +1847,7 @@
: ref_frame_buf->buf.v_buffer;
}
- if (vp9_is_scaled(sf)) {
+ if (is_scaled) {
// Co-ordinate of containing block to pixel precision.
int x_start = (-xd->mb_to_left_edge >> (3 + pd->subsampling_x));
int y_start = (-xd->mb_to_top_edge >> (3 + pd->subsampling_y));
@@ -1897,20 +1902,19 @@
// Do border extension if there is motion or the
// width/height is not a multiple of 8 pixels.
- if (scaled_mv.col || scaled_mv.row ||
+ if (is_scaled || scaled_mv.col || scaled_mv.row ||
(frame_width & 0x7) || (frame_height & 0x7)) {
- int x_pad = 0, y_pad = 0;
-
// Get reference block bottom right horizontal coordinate.
int x1 = ((x0_16 + (w - 1) * xs) >> SUBPEL_BITS) + 1;
+ int x_pad = 0, y_pad = 0;
- if (subpel_x || (sf->x_step_q4 & SUBPEL_MASK)) {
+ if (subpel_x || (sf->x_step_q4 != SUBPEL_SHIFTS)) {
x0 -= VP9_INTERP_EXTEND - 1;
x1 += VP9_INTERP_EXTEND;
x_pad = 1;
}
- if (subpel_y || (sf->y_step_q4 & SUBPEL_MASK)) {
+ if (subpel_y || (sf->y_step_q4 != SUBPEL_SHIFTS)) {
y0 -= VP9_INTERP_EXTEND - 1;
y1 += VP9_INTERP_EXTEND;
y_pad = 1;
diff --git a/vp9/decoder/vp9_decodemv.c b/vp9/decoder/vp9_decodemv.c
index 40280ba..ec32f1d 100644
--- a/vp9/decoder/vp9_decodemv.c
+++ b/vp9/decoder/vp9_decodemv.c
@@ -27,29 +27,31 @@
return (PREDICTION_MODE)vp9_read_tree(r, vp9_intra_mode_tree, p);
}
-static PREDICTION_MODE read_intra_mode_y(VP9_COMMON *cm, vp9_reader *r,
- int size_group) {
+static PREDICTION_MODE read_intra_mode_y(VP9_COMMON *cm, FRAME_COUNTS *counts,
+ vp9_reader *r, int size_group) {
const PREDICTION_MODE y_mode =
read_intra_mode(r, cm->fc->y_mode_prob[size_group]);
if (!cm->frame_parallel_decoding_mode)
- ++cm->counts.y_mode[size_group][y_mode];
+ ++counts->y_mode[size_group][y_mode];
return y_mode;
}
-static PREDICTION_MODE read_intra_mode_uv(VP9_COMMON *cm, vp9_reader *r,
+static PREDICTION_MODE read_intra_mode_uv(VP9_COMMON *cm, FRAME_COUNTS *counts,
+ vp9_reader *r,
PREDICTION_MODE y_mode) {
const PREDICTION_MODE uv_mode = read_intra_mode(r,
cm->fc->uv_mode_prob[y_mode]);
if (!cm->frame_parallel_decoding_mode)
- ++cm->counts.uv_mode[y_mode][uv_mode];
+ ++counts->uv_mode[y_mode][uv_mode];
return uv_mode;
}
-static PREDICTION_MODE read_inter_mode(VP9_COMMON *cm, vp9_reader *r, int ctx) {
+static PREDICTION_MODE read_inter_mode(VP9_COMMON *cm, FRAME_COUNTS *counts,
+ vp9_reader *r, int ctx) {
const int mode = vp9_read_tree(r, vp9_inter_mode_tree,
cm->fc->inter_mode_probs[ctx]);
if (!cm->frame_parallel_decoding_mode)
- ++cm->counts.inter_mode[ctx][mode];
+ ++counts->inter_mode[ctx][mode];
return NEARESTMV + mode;
}
@@ -59,6 +61,7 @@
}
static TX_SIZE read_selected_tx_size(VP9_COMMON *cm, MACROBLOCKD *xd,
+ FRAME_COUNTS *counts,
TX_SIZE max_tx_size, vp9_reader *r) {
const int ctx = vp9_get_tx_size_context(xd);
const vp9_prob *tx_probs = get_tx_probs(max_tx_size, ctx, &cm->fc->tx_probs);
@@ -70,17 +73,18 @@
}
if (!cm->frame_parallel_decoding_mode)
- ++get_tx_counts(max_tx_size, ctx, &cm->counts.tx)[tx_size];
+ ++get_tx_counts(max_tx_size, ctx, &counts->tx)[tx_size];
return (TX_SIZE)tx_size;
}
static TX_SIZE read_tx_size(VP9_COMMON *cm, MACROBLOCKD *xd,
+ FRAME_COUNTS *counts,
int allow_select, vp9_reader *r) {
TX_MODE tx_mode = cm->tx_mode;
BLOCK_SIZE bsize = xd->mi[0].src_mi->mbmi.sb_type;
const TX_SIZE max_tx_size = max_txsize_lookup[bsize];
if (allow_select && tx_mode == TX_MODE_SELECT && bsize >= BLOCK_8X8)
- return read_selected_tx_size(cm, xd, max_tx_size, r);
+ return read_selected_tx_size(cm, xd, counts, max_tx_size, r);
else
return MIN(max_tx_size, tx_mode_to_biggest_tx_size[tx_mode]);
}
@@ -171,6 +175,7 @@
}
static int read_skip(VP9_COMMON *cm, const MACROBLOCKD *xd,
+ FRAME_COUNTS *counts,
int segment_id, vp9_reader *r) {
if (vp9_segfeature_active(&cm->seg, segment_id, SEG_LVL_SKIP)) {
return 1;
@@ -178,13 +183,14 @@
const int ctx = vp9_get_skip_context(xd);
const int skip = vp9_read(r, cm->fc->skip_probs[ctx]);
if (!cm->frame_parallel_decoding_mode)
- ++cm->counts.skip[ctx][skip];
+ ++counts->skip[ctx][skip];
return skip;
}
}
static void read_intra_frame_mode_info(VP9_COMMON *const cm,
MACROBLOCKD *const xd,
+ FRAME_COUNTS *counts,
int mi_row, int mi_col, vp9_reader *r) {
MODE_INFO *const mi = xd->mi[0].src_mi;
MB_MODE_INFO *const mbmi = &mi->mbmi;
@@ -194,8 +200,8 @@
int i;
mbmi->segment_id = read_intra_segment_id(cm, xd, mi_row, mi_col, r);
- mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r);
- mbmi->tx_size = read_tx_size(cm, xd, 1, r);
+ mbmi->skip = read_skip(cm, xd, counts, mbmi->segment_id, r);
+ mbmi->tx_size = read_tx_size(cm, xd, counts, 1, r);
mbmi->ref_frame[0] = INTRA_FRAME;
mbmi->ref_frame[1] = NONE;
@@ -280,13 +286,14 @@
static REFERENCE_MODE read_block_reference_mode(VP9_COMMON *cm,
const MACROBLOCKD *xd,
+ FRAME_COUNTS *counts,
vp9_reader *r) {
if (cm->reference_mode == REFERENCE_MODE_SELECT) {
const int ctx = vp9_get_reference_mode_context(cm, xd);
const REFERENCE_MODE mode =
(REFERENCE_MODE)vp9_read(r, cm->fc->comp_inter_prob[ctx]);
if (!cm->frame_parallel_decoding_mode)
- ++cm->counts.comp_inter[ctx][mode];
+ ++counts->comp_inter[ctx][mode];
return mode; // SINGLE_REFERENCE or COMPOUND_REFERENCE
} else {
return cm->reference_mode;
@@ -295,17 +302,16 @@
// Read the referncence frame
static void read_ref_frames(VP9_COMMON *const cm, MACROBLOCKD *const xd,
- vp9_reader *r,
+ FRAME_COUNTS *counts, vp9_reader *r,
int segment_id, MV_REFERENCE_FRAME ref_frame[2]) {
FRAME_CONTEXT *const fc = cm->fc;
- FRAME_COUNTS *const counts = &cm->counts;
if (vp9_segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
ref_frame[0] = (MV_REFERENCE_FRAME)vp9_get_segdata(&cm->seg, segment_id,
SEG_LVL_REF_FRAME);
ref_frame[1] = NONE;
} else {
- const REFERENCE_MODE mode = read_block_reference_mode(cm, xd, r);
+ const REFERENCE_MODE mode = read_block_reference_mode(cm, xd, counts, r);
// FIXME(rbultje) I'm pretty sure this breaks segmentation ref frame coding
if (mode == COMPOUND_REFERENCE) {
const int idx = cm->ref_frame_sign_bias[cm->comp_fixed_ref];
@@ -339,17 +345,19 @@
static INLINE INTERP_FILTER read_switchable_interp_filter(
- VP9_COMMON *const cm, MACROBLOCKD *const xd, vp9_reader *r) {
+ VP9_COMMON *const cm, MACROBLOCKD *const xd,
+ FRAME_COUNTS *counts, vp9_reader *r) {
const int ctx = vp9_get_pred_context_switchable_interp(xd);
const INTERP_FILTER type =
(INTERP_FILTER)vp9_read_tree(r, vp9_switchable_interp_tree,
cm->fc->switchable_interp_prob[ctx]);
if (!cm->frame_parallel_decoding_mode)
- ++cm->counts.switchable_interp[ctx][type];
+ ++counts->switchable_interp[ctx][type];
return type;
}
-static void read_intra_block_mode_info(VP9_COMMON *const cm, MODE_INFO *mi,
+static void read_intra_block_mode_info(VP9_COMMON *const cm,
+ FRAME_COUNTS *counts, MODE_INFO *mi,
vp9_reader *r) {
MB_MODE_INFO *const mbmi = &mi->mbmi;
const BLOCK_SIZE bsize = mi->mbmi.sb_type;
@@ -361,24 +369,26 @@
switch (bsize) {
case BLOCK_4X4:
for (i = 0; i < 4; ++i)
- mi->bmi[i].as_mode = read_intra_mode_y(cm, r, 0);
+ mi->bmi[i].as_mode = read_intra_mode_y(cm, counts, r, 0);
mbmi->mode = mi->bmi[3].as_mode;
break;
case BLOCK_4X8:
- mi->bmi[0].as_mode = mi->bmi[2].as_mode = read_intra_mode_y(cm, r, 0);
+ mi->bmi[0].as_mode = mi->bmi[2].as_mode = read_intra_mode_y(cm, counts,
+ r, 0);
mi->bmi[1].as_mode = mi->bmi[3].as_mode = mbmi->mode =
- read_intra_mode_y(cm, r, 0);
+ read_intra_mode_y(cm, counts, r, 0);
break;
case BLOCK_8X4:
- mi->bmi[0].as_mode = mi->bmi[1].as_mode = read_intra_mode_y(cm, r, 0);
+ mi->bmi[0].as_mode = mi->bmi[1].as_mode = read_intra_mode_y(cm, counts,
+ r, 0);
mi->bmi[2].as_mode = mi->bmi[3].as_mode = mbmi->mode =
- read_intra_mode_y(cm, r, 0);
+ read_intra_mode_y(cm, counts, r, 0);
break;
default:
- mbmi->mode = read_intra_mode_y(cm, r, size_group_lookup[bsize]);
+ mbmi->mode = read_intra_mode_y(cm, counts, r, size_group_lookup[bsize]);
}
- mbmi->uv_mode = read_intra_mode_uv(cm, r, mbmi->mode);
+ mbmi->uv_mode = read_intra_mode_uv(cm, counts, r, mbmi->mode);
}
static INLINE int is_mv_valid(const MV *mv) {
@@ -386,7 +396,8 @@
mv->col > MV_LOW && mv->col < MV_UPP;
}
-static INLINE int assign_mv(VP9_COMMON *cm, PREDICTION_MODE mode,
+static INLINE int assign_mv(VP9_COMMON *cm, FRAME_COUNTS *counts,
+ PREDICTION_MODE mode,
int_mv mv[2], int_mv ref_mv[2],
int_mv nearest_mv[2], int_mv near_mv[2],
int is_compound, int allow_hp, vp9_reader *r) {
@@ -396,7 +407,7 @@
switch (mode) {
case NEWMV: {
nmv_context_counts *const mv_counts = cm->frame_parallel_decoding_mode ?
- NULL : &cm->counts.mv;
+ NULL : &counts->mv;
for (i = 0; i < 1 + is_compound; ++i) {
read_mv(r, &mv[i].as_mv, &ref_mv[i].as_mv, &cm->fc->nmvc, mv_counts,
allow_hp);
@@ -430,6 +441,7 @@
}
static int read_is_inter_block(VP9_COMMON *const cm, MACROBLOCKD *const xd,
+ FRAME_COUNTS *counts,
int segment_id, vp9_reader *r) {
if (vp9_segfeature_active(&cm->seg, segment_id, SEG_LVL_REF_FRAME)) {
return vp9_get_segdata(&cm->seg, segment_id, SEG_LVL_REF_FRAME) !=
@@ -438,7 +450,7 @@
const int ctx = vp9_get_intra_inter_context(xd);
const int is_inter = vp9_read(r, cm->fc->intra_inter_prob[ctx]);
if (!cm->frame_parallel_decoding_mode)
- ++cm->counts.intra_inter[ctx][is_inter];
+ ++counts->intra_inter[ctx][is_inter];
return is_inter;
}
}
@@ -451,6 +463,7 @@
static void read_inter_block_mode_info(VP9Decoder *const pbi,
MACROBLOCKD *const xd,
+ FRAME_COUNTS *counts,
const TileInfo *const tile,
MODE_INFO *const mi,
int mi_row, int mi_col, vp9_reader *r) {
@@ -461,7 +474,7 @@
int_mv nearestmv[2], nearmv[2];
int inter_mode_ctx, ref, is_compound;
- read_ref_frames(cm, xd, r, mbmi->segment_id, mbmi->ref_frame);
+ read_ref_frames(cm, xd, counts, r, mbmi->segment_id, mbmi->ref_frame);
is_compound = has_second_ref(mbmi);
for (ref = 0; ref < 1 + is_compound; ++ref) {
@@ -488,7 +501,7 @@
}
} else {
if (bsize >= BLOCK_8X8)
- mbmi->mode = read_inter_mode(cm, r, inter_mode_ctx);
+ mbmi->mode = read_inter_mode(cm, counts, r, inter_mode_ctx);
}
if (bsize < BLOCK_8X8 || mbmi->mode != ZEROMV) {
@@ -499,7 +512,7 @@
}
mbmi->interp_filter = (cm->interp_filter == SWITCHABLE)
- ? read_switchable_interp_filter(cm, xd, r)
+ ? read_switchable_interp_filter(cm, xd, counts, r)
: cm->interp_filter;
if (bsize < BLOCK_8X8) {
@@ -512,7 +525,7 @@
for (idx = 0; idx < 2; idx += num_4x4_w) {
int_mv block[2];
const int j = idy * 2 + idx;
- b_mode = read_inter_mode(cm, r, inter_mode_ctx);
+ b_mode = read_inter_mode(cm, counts, r, inter_mode_ctx);
if (b_mode == NEARESTMV || b_mode == NEARMV)
for (ref = 0; ref < 1 + is_compound; ++ref)
@@ -520,7 +533,7 @@
&nearest_sub8x8[ref],
&near_sub8x8[ref]);
- if (!assign_mv(cm, b_mode, block, nearestmv,
+ if (!assign_mv(cm, counts, b_mode, block, nearestmv,
nearest_sub8x8, near_sub8x8,
is_compound, allow_hp, r)) {
xd->corrupted |= 1;
@@ -543,13 +556,14 @@
mbmi->mv[0].as_int = mi->bmi[3].as_mv[0].as_int;
mbmi->mv[1].as_int = mi->bmi[3].as_mv[1].as_int;
} else {
- xd->corrupted |= !assign_mv(cm, mbmi->mode, mbmi->mv, nearestmv,
+ xd->corrupted |= !assign_mv(cm, counts, mbmi->mode, mbmi->mv, nearestmv,
nearestmv, nearmv, is_compound, allow_hp, r);
}
}
static void read_inter_frame_mode_info(VP9Decoder *const pbi,
MACROBLOCKD *const xd,
+ FRAME_COUNTS *counts,
const TileInfo *const tile,
int mi_row, int mi_col, vp9_reader *r) {
VP9_COMMON *const cm = &pbi->common;
@@ -560,17 +574,18 @@
mbmi->mv[0].as_int = 0;
mbmi->mv[1].as_int = 0;
mbmi->segment_id = read_inter_segment_id(cm, xd, mi_row, mi_col, r);
- mbmi->skip = read_skip(cm, xd, mbmi->segment_id, r);
- inter_block = read_is_inter_block(cm, xd, mbmi->segment_id, r);
- mbmi->tx_size = read_tx_size(cm, xd, !mbmi->skip || !inter_block, r);
+ mbmi->skip = read_skip(cm, xd, counts, mbmi->segment_id, r);
+ inter_block = read_is_inter_block(cm, xd, counts, mbmi->segment_id, r);
+ mbmi->tx_size = read_tx_size(cm, xd, counts, !mbmi->skip || !inter_block, r);
if (inter_block)
- read_inter_block_mode_info(pbi, xd, tile, mi, mi_row, mi_col, r);
+ read_inter_block_mode_info(pbi, xd, counts, tile, mi, mi_row, mi_col, r);
else
- read_intra_block_mode_info(cm, mi, r);
+ read_intra_block_mode_info(cm, counts, mi, r);
}
void vp9_read_mode_info(VP9Decoder *const pbi, MACROBLOCKD *xd,
+ FRAME_COUNTS *counts,
const TileInfo *const tile,
int mi_row, int mi_col, vp9_reader *r) {
VP9_COMMON *const cm = &pbi->common;
@@ -583,9 +598,9 @@
int w, h;
if (frame_is_intra_only(cm))
- read_intra_frame_mode_info(cm, xd, mi_row, mi_col, r);
+ read_intra_frame_mode_info(cm, xd, counts, mi_row, mi_col, r);
else
- read_inter_frame_mode_info(pbi, xd, tile, mi_row, mi_col, r);
+ read_inter_frame_mode_info(pbi, xd, counts, tile, mi_row, mi_col, r);
for (h = 0; h < y_mis; ++h) {
MV_REF *const frame_mv = frame_mvs + h * cm->mi_cols;
diff --git a/vp9/decoder/vp9_decodemv.h b/vp9/decoder/vp9_decodemv.h
index dd97d8d..c79dff7 100644
--- a/vp9/decoder/vp9_decodemv.h
+++ b/vp9/decoder/vp9_decodemv.h
@@ -21,6 +21,7 @@
struct TileInfo;
void vp9_read_mode_info(VP9Decoder *const pbi, MACROBLOCKD *xd,
+ FRAME_COUNTS *counts,
const struct TileInfo *const tile,
int mi_row, int mi_col, vp9_reader *r);
diff --git a/vp9/decoder/vp9_detokenize.c b/vp9/decoder/vp9_detokenize.c
index 23d622d..28ef711 100644
--- a/vp9/decoder/vp9_detokenize.c
+++ b/vp9/decoder/vp9_detokenize.c
@@ -56,13 +56,13 @@
-CATEGORY5_TOKEN, -CATEGORY6_TOKEN /* 7 = CAT_FIVE */
};
-static int decode_coefs(VP9_COMMON *cm, const MACROBLOCKD *xd, PLANE_TYPE type,
+static int decode_coefs(VP9_COMMON *cm, const MACROBLOCKD *xd,
+ FRAME_COUNTS *counts, PLANE_TYPE type,
tran_low_t *dqcoeff, TX_SIZE tx_size, const int16_t *dq,
int ctx, const int16_t *scan, const int16_t *nb,
vp9_reader *r) {
const int max_eob = 16 << (tx_size << 1);
const FRAME_CONTEXT *const fc = cm->fc;
- FRAME_COUNTS *const counts = &cm->counts;
const int ref = is_inter_block(&xd->mi[0].src_mi->mbmi);
int band, c = 0;
const vp9_prob (*coef_probs)[COEFF_CONTEXTS][UNCONSTRAINED_NODES] =
@@ -213,13 +213,14 @@
}
int vp9_decode_block_tokens(VP9_COMMON *cm, MACROBLOCKD *xd,
- int plane, int block, BLOCK_SIZE plane_bsize,
- int x, int y, TX_SIZE tx_size, vp9_reader *r) {
+ FRAME_COUNTS *counts, int plane, int block,
+ BLOCK_SIZE plane_bsize, int x, int y,
+ TX_SIZE tx_size, vp9_reader *r) {
struct macroblockd_plane *const pd = &xd->plane[plane];
const int ctx = get_entropy_context(tx_size, pd->above_context + x,
pd->left_context + y);
const scan_order *so = get_scan(xd, tx_size, pd->plane_type, block);
- const int eob = decode_coefs(cm, xd, pd->plane_type,
+ const int eob = decode_coefs(cm, xd, counts, pd->plane_type,
BLOCK_OFFSET(pd->dqcoeff, block), tx_size,
pd->dequant, ctx, so->scan, so->neighbors, r);
vp9_set_contexts(xd, pd, plane_bsize, tx_size, eob > 0, x, y);
diff --git a/vp9/decoder/vp9_detokenize.h b/vp9/decoder/vp9_detokenize.h
index 5278e97..30d157c 100644
--- a/vp9/decoder/vp9_detokenize.h
+++ b/vp9/decoder/vp9_detokenize.h
@@ -20,8 +20,9 @@
#endif
int vp9_decode_block_tokens(VP9_COMMON *cm, MACROBLOCKD *xd,
- int plane, int block, BLOCK_SIZE plane_bsize,
- int x, int y, TX_SIZE tx_size, vp9_reader *r);
+ FRAME_COUNTS *counts, int plane, int block,
+ BLOCK_SIZE plane_bsize, int x, int y,
+ TX_SIZE tx_size, vp9_reader *r);
#ifdef __cplusplus
} // extern "C"
diff --git a/vp9/encoder/vp9_encoder.c b/vp9/encoder/vp9_encoder.c
index 368aa49..a4c77dd 100644
--- a/vp9/encoder/vp9_encoder.c
+++ b/vp9/encoder/vp9_encoder.c
@@ -469,8 +469,9 @@
VP9_COMMON *cm = &cpi->common;
const VP9EncoderConfig *oxcf = &cpi->oxcf;
- cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height,
- cm->subsampling_x, cm->subsampling_y,
+ if (!cpi->lookahead)
+ cpi->lookahead = vp9_lookahead_init(oxcf->width, oxcf->height,
+ cm->subsampling_x, cm->subsampling_y,
#if CONFIG_VP9_HIGHBITDEPTH
cm->use_highbitdepth,
#endif
@@ -1314,11 +1315,11 @@
cm->height = cpi->oxcf.height;
if (cpi->initial_width) {
- // Increasing the size of the frame beyond the first seen frame, or some
- // otherwise signaled maximum size, is not supported.
- // TODO(jkoleszar): exit gracefully.
- assert(cm->width <= cpi->initial_width);
- assert(cm->height <= cpi->initial_height);
+ if (cm->width > cpi->initial_width || cm->height > cpi->initial_height) {
+ vp9_free_context_buffers(cm);
+ vp9_alloc_context_buffers(cm, cm->width, cm->height);
+ cpi->initial_width = cpi->initial_height = 0;
+ }
}
update_frame_size(cpi);
@@ -3441,7 +3442,11 @@
#endif
vpx_usec_timer_start(&timer);
- if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time, frame_flags))
+ if (vp9_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
+#if CONFIG_VP9_HIGHBITDEPTH
+ use_highbitdepth,
+#endif // CONFIG_VP9_HIGHBITDEPTH
+ frame_flags))
res = -1;
vpx_usec_timer_mark(&timer);
cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
diff --git a/vp9/encoder/vp9_lookahead.c b/vp9/encoder/vp9_lookahead.c
index 708072e..b8e2ca8 100644
--- a/vp9/encoder/vp9_lookahead.c
+++ b/vp9/encoder/vp9_lookahead.c
@@ -90,19 +90,40 @@
#define USE_PARTIAL_COPY 0
int vp9_lookahead_push(struct lookahead_ctx *ctx, YV12_BUFFER_CONFIG *src,
- int64_t ts_start, int64_t ts_end, unsigned int flags) {
+ int64_t ts_start, int64_t ts_end,
+#if CONFIG_VP9_HIGHBITDEPTH
+ int use_highbitdepth,
+#endif
+ unsigned int flags) {
struct lookahead_entry *buf;
#if USE_PARTIAL_COPY
int row, col, active_end;
int mb_rows = (src->y_height + 15) >> 4;
int mb_cols = (src->y_width + 15) >> 4;
#endif
+ int width = src->y_crop_width;
+ int height = src->y_crop_height;
+ int uv_width = src->uv_crop_width;
+ int uv_height = src->uv_crop_height;
+ int subsampling_x = src->subsampling_x;
+ int subsampling_y = src->subsampling_y;
+ int larger_dimensions, new_dimensions;
if (ctx->sz + 1 + MAX_PRE_FRAMES > ctx->max_sz)
return 1;
ctx->sz++;
buf = pop(ctx, &ctx->write_idx);
+ new_dimensions = width != buf->img.y_crop_width ||
+ height != buf->img.y_crop_height ||
+ uv_width != buf->img.uv_crop_width ||
+ uv_height != buf->img.uv_crop_height;
+ larger_dimensions = width > buf->img.y_width ||
+ height > buf->img.y_height ||
+ uv_width > buf->img.uv_width ||
+ uv_height > buf->img.uv_height;
+ assert(!larger_dimensions || new_dimensions);
+
#if USE_PARTIAL_COPY
// TODO(jkoleszar): This is disabled for now, as
// vp9_copy_and_extend_frame_with_rect is not subsampling/alpha aware.
@@ -111,7 +132,7 @@
// 1. Lookahead queue has has size of 1.
// 2. Active map is provided.
// 3. This is not a key frame, golden nor altref frame.
- if (ctx->max_sz == 1 && active_map && !flags) {
+ if (!new_dimensions && ctx->max_sz == 1 && active_map && !flags) {
for (row = 0; row < mb_rows; ++row) {
col = 0;
@@ -147,11 +168,32 @@
active_map += mb_cols;
}
} else {
+#endif
+ if (larger_dimensions) {
+ YV12_BUFFER_CONFIG new_img;
+ memset(&new_img, 0, sizeof(new_img));
+ if (vp9_alloc_frame_buffer(&new_img,
+ width, height, subsampling_x, subsampling_y,
+#if CONFIG_VP9_HIGHBITDEPTH
+ use_highbitdepth,
+#endif
+ VP9_ENC_BORDER_IN_PIXELS,
+ 0))
+ return 1;
+ vp9_free_frame_buffer(&buf->img);
+ buf->img = new_img;
+ } else if (new_dimensions) {
+ buf->img.y_crop_width = src->y_crop_width;
+ buf->img.y_crop_height = src->y_crop_height;
+ buf->img.uv_crop_width = src->uv_crop_width;
+ buf->img.uv_crop_height = src->uv_crop_height;
+ buf->img.subsampling_x = src->subsampling_x;
+ buf->img.subsampling_y = src->subsampling_y;
+ }
+ // Partial copy not implemented yet
vp9_copy_and_extend_frame(src, &buf->img);
+#if USE_PARTIAL_COPY
}
-#else
- // Partial copy not implemented yet
- vp9_copy_and_extend_frame(src, &buf->img);
#endif
buf->ts_start = ts_start;
diff --git a/vp9/encoder/vp9_lookahead.h b/vp9/encoder/vp9_lookahead.h
index a33d300..1382038 100644
--- a/vp9/encoder/vp9_lookahead.h
+++ b/vp9/encoder/vp9_lookahead.h
@@ -79,7 +79,11 @@
* \param[in] active_map Map that specifies which macroblock is active
*/
int vp9_lookahead_push(struct lookahead_ctx *ctx, YV12_BUFFER_CONFIG *src,
- int64_t ts_start, int64_t ts_end, unsigned int flags);
+ int64_t ts_start, int64_t ts_end,
+#if CONFIG_VP9_HIGHBITDEPTH
+ int use_highbitdepth,
+#endif
+ unsigned int flags);
/**\brief Get the next source buffer to encode
diff --git a/vp9/vp9_cx_iface.c b/vp9/vp9_cx_iface.c
index 4df9730..251d240 100644
--- a/vp9/vp9_cx_iface.c
+++ b/vp9/vp9_cx_iface.c
@@ -532,10 +532,9 @@
if (cfg->g_w != ctx->cfg.g_w || cfg->g_h != ctx->cfg.g_h) {
if (cfg->g_lag_in_frames > 1 || cfg->g_pass != VPX_RC_ONE_PASS)
ERROR("Cannot change width or height after initialization");
- if ((ctx->cpi->initial_width && (int)cfg->g_w > ctx->cpi->initial_width) ||
+ if (!valid_ref_frame_size(ctx->cfg.g_w, ctx->cfg.g_h, cfg->g_w, cfg->g_h) ||
+ (ctx->cpi->initial_width && (int)cfg->g_w > ctx->cpi->initial_width) ||
(ctx->cpi->initial_height && (int)cfg->g_h > ctx->cpi->initial_height))
- ERROR("Cannot increase width or height larger than their initial values");
- if (!valid_ref_frame_size(ctx->cfg.g_w, ctx->cfg.g_h, cfg->g_w, cfg->g_h))
force_key = 1;
}
@@ -744,6 +743,12 @@
if (priv->buffer_pool == NULL)
return VPX_CODEC_MEM_ERROR;
+#if CONFIG_MULTITHREAD
+ if (pthread_mutex_init(&priv->buffer_pool->pool_mutex, NULL)) {
+ return VPX_CODEC_MEM_ERROR;
+ }
+#endif
+
if (ctx->config.enc) {
// Update the reference to the config structure to an internal copy.
priv->cfg = *ctx->config.enc;
@@ -775,6 +780,9 @@
static vpx_codec_err_t encoder_destroy(vpx_codec_alg_priv_t *ctx) {
free(ctx->cx_data);
vp9_remove_compressor(ctx->cpi);
+#if CONFIG_MULTITHREAD
+ pthread_mutex_destroy(&ctx->buffer_pool->pool_mutex);
+#endif
vpx_free(ctx->buffer_pool);
vpx_free(ctx);
return VPX_CODEC_OK;
diff --git a/vpxenc.c b/vpxenc.c
index 944dfa8..f42e02c 100644
--- a/vpxenc.c
+++ b/vpxenc.c
@@ -183,8 +183,10 @@
NULL, "test-decode", 1, "Test encode/decode mismatch", test_decode_enum);
static const arg_def_t framerate = ARG_DEF(
NULL, "fps", 1, "Stream frame rate (rate/scale)");
+static const arg_def_t use_webm = ARG_DEF(
+ NULL, "webm", 0, "Output WebM (default when WebM IO is enabled)");
static const arg_def_t use_ivf = ARG_DEF(
- NULL, "ivf", 0, "Output IVF (default is WebM if WebM IO is enabled)");
+ NULL, "ivf", 0, "Output IVF");
static const arg_def_t out_part = ARG_DEF(
"P", "output-partitions", 0,
"Makes encoder output partitions. Requires IVF output!");
@@ -208,7 +210,7 @@
&debugmode,
&outputfile, &codecarg, &passes, &pass_arg, &fpf_name, &limit, &skip,
&deadline, &best_dl, &good_dl, &rt_dl,
- &quietarg, &verbosearg, &psnrarg, &use_ivf, &out_part, &q_hist_n,
+ &quietarg, &verbosearg, &psnrarg, &use_webm, &use_ivf, &out_part, &q_hist_n,
&rate_hist_n, &disable_warnings, &disable_warning_prompt,
NULL
};
@@ -1059,6 +1061,12 @@
} else if (arg_match(&arg, &fpmbf_name, argi)) {
config->fpmb_stats_fn = arg.val;
#endif
+ } else if (arg_match(&arg, &use_webm, argi)) {
+#if CONFIG_WEBM_IO
+ config->write_webm = 1;
+#else
+ die("Error: --webm specified but webm is disabled.");
+#endif
} else if (arg_match(&arg, &use_ivf, argi)) {
config->write_webm = 0;
} else if (arg_match(&arg, &threads, argi)) {
