ref: 98526433737e388ebe576e9f7631b6763e58a2f9
parent: 39f03bf9c672b8e7c4b483d4e919a695707c90dd
author: Debargha Mukherjee <[email protected]>
date: Wed Apr 1 12:39:06 EDT 2015
Expose params min-gf-interval/max-gf-interval Adds two new vp9 parameters --min-gf-interval and --max-gf-interval to enable testing based on frequency of alt-ref frames. Also adds a unit-test to test enforcement of min-gf-interval. For both these parameters the default value is 0, which indicates they are picked by the encoder, based on resolution and framerate considerations. If they are greater than zero, the specified parameter is honored. (Additional note by paulwilkins) Note that there is a slight oddity in that key frames are also GFs and considered part of GF only group. However they are treated as not being part of an arf group because for arf groups the previous GF is assumed to be the terminal or overlay frame for the previous group. (end note) Change-Id: Ibf0c30b72074b3f71918ab278ccccc02a95a70a0
--- a/test/test.mk
+++ b/test/test.mk
@@ -159,6 +159,7 @@
ifeq ($(CONFIG_VP9_ENCODER)$(CONFIG_VP9_TEMPORAL_DENOISING),yesyes)
LIBVPX_TEST_SRCS-$(HAVE_SSE2) += vp9_denoiser_sse2_test.cc
endif
+LIBVPX_TEST_SRCS-$(CONFIG_VP9_ENCODER) += vp9_arf_freq_test.cc
endif # VP9
--- /dev/null
+++ b/test/vp9_arf_freq_test.cc
@@ -1,0 +1,230 @@
+/*
+ * Copyright (c) 2015 The WebM project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "test/codec_factory.h"
+#include "test/encode_test_driver.h"
+#include "test/y4m_video_source.h"
+#include "test/yuv_video_source.h"
+#include "test/util.h"
+#include "third_party/googletest/src/include/gtest/gtest.h"
+#include "vp9/encoder/vp9_ratectrl.h"
+
+namespace {+
+const unsigned int kFrames = 100;
+const int kBitrate = 500;
+
+#define ARF_NOT_SEEN 1000001
+#define ARF_SEEN_ONCE 1000000
+
+typedef struct {+ const char *filename;
+ unsigned int width;
+ unsigned int height;
+ unsigned int framerate_num;
+ unsigned int framerate_den;
+ unsigned int input_bit_depth;
+ vpx_img_fmt fmt;
+ vpx_bit_depth_t bit_depth;
+ unsigned int profile;
+} TestVideoParam;
+
+typedef struct {+ libvpx_test::TestMode mode;
+ int cpu_used;
+} TestEncodeParam;
+
+const TestVideoParam kTestVectors[] = {+ // artificially increase framerate to trigger default check
+ {"hantro_collage_w352h288.yuv", 352, 288, 5000, 1,+ 8, VPX_IMG_FMT_I420, VPX_BITS_8, 0},
+ {"hantro_collage_w352h288.yuv", 352, 288, 30, 1,+ 8, VPX_IMG_FMT_I420, VPX_BITS_8, 0},
+ {"rush_hour_444.y4m", 352, 288, 30, 1,+ 8, VPX_IMG_FMT_I444, VPX_BITS_8, 1},
+#if CONFIG_VP9_HIGHBITDEPTH
+ // Add list of profile 2/3 test videos here ...
+#endif // CONFIG_VP9_HIGHBITDEPTH
+};
+
+const TestEncodeParam kEncodeVectors[] = {+ {::libvpx_test::kOnePassGood, 2},+ {::libvpx_test::kOnePassGood, 5},+ {::libvpx_test::kTwoPassGood, 1},+ {::libvpx_test::kTwoPassGood, 2},+ {::libvpx_test::kTwoPassGood, 5},+ {::libvpx_test::kRealTime, 5},+};
+
+const int kMinArfVectors[] = {+ // NOTE: 0 refers to the default built-in logic in:
+ // vp9_rc_get_default_min_gf_interval(...)
+ 0, 4, 8, 12, 15
+};
+
+int is_extension_y4m(const char *filename) {+ const char *dot = strrchr(filename, '.');
+ if (!dot || dot == filename)
+ return 0;
+ else
+ return !strcmp(dot, ".y4m");
+}
+
+class ArfFreqTest
+ : public ::libvpx_test::EncoderTest,
+ public ::libvpx_test::CodecTestWith3Params<TestVideoParam, \
+ TestEncodeParam, int> {+ protected:
+ ArfFreqTest()
+ : EncoderTest(GET_PARAM(0)),
+ test_video_param_(GET_PARAM(1)),
+ test_encode_param_(GET_PARAM(2)),
+ min_arf_requested_(GET_PARAM(3)) {+ }
+
+ virtual ~ArfFreqTest() {}+
+ virtual void SetUp() {+ InitializeConfig();
+ SetMode(test_encode_param_.mode);
+ if (test_encode_param_.mode != ::libvpx_test::kRealTime) {+ cfg_.g_lag_in_frames = 25;
+ cfg_.rc_end_usage = VPX_VBR;
+ } else {+ cfg_.g_lag_in_frames = 0;
+ cfg_.rc_end_usage = VPX_CBR;
+ cfg_.rc_buf_sz = 1000;
+ cfg_.rc_buf_initial_sz = 500;
+ cfg_.rc_buf_optimal_sz = 600;
+ }
+ dec_cfg_.threads = 4;
+ }
+
+ virtual void BeginPassHook(unsigned int) {+ min_arf_ = ARF_NOT_SEEN;
+ run_of_visible_frames_ = 0;
+ }
+
+ int GetNumFramesInPkt(const vpx_codec_cx_pkt_t *pkt) {+ const uint8_t *buffer = reinterpret_cast<uint8_t*>(pkt->data.frame.buf);
+ const uint8_t marker = buffer[pkt->data.frame.sz - 1];
+ const int mag = ((marker >> 3) & 3) + 1;
+ int frames = (marker & 0x7) + 1;
+ const unsigned int index_sz = 2 + mag * frames;
+ // Check for superframe or not.
+ // Assume superframe has only one visible frame, the rest being
+ // invisible. If superframe index is not found, then there is only
+ // one frame.
+ if (!((marker & 0xe0) == 0xc0 &&
+ pkt->data.frame.sz >= index_sz &&
+ buffer[pkt->data.frame.sz - index_sz] == marker)) {+ frames = 1;
+ }
+ return frames;
+ }
+
+ virtual void FramePktHook(const vpx_codec_cx_pkt_t *pkt) {+ if (pkt->kind != VPX_CODEC_CX_FRAME_PKT)
+ return;
+ const int frames = GetNumFramesInPkt(pkt);
+ if (frames == 1) {+ run_of_visible_frames_++;
+ } else if (frames == 2) {+ if (min_arf_ == ARF_NOT_SEEN) {+ min_arf_ = ARF_SEEN_ONCE;
+ } else if (min_arf_ == ARF_SEEN_ONCE ||
+ run_of_visible_frames_ < min_arf_) {+ min_arf_ = run_of_visible_frames_;
+ }
+ run_of_visible_frames_ = 1;
+ } else {+ min_arf_ = 0;
+ run_of_visible_frames_ = 1;
+ }
+ }
+
+ virtual void PreEncodeFrameHook(::libvpx_test::VideoSource *video,
+ ::libvpx_test::Encoder *encoder) {+ if (video->frame() == 0) {+ encoder->Control(VP9E_SET_FRAME_PARALLEL_DECODING, 1);
+ encoder->Control(VP9E_SET_TILE_COLUMNS, 4);
+ encoder->Control(VP8E_SET_CPUUSED, test_encode_param_.cpu_used);
+ encoder->Control(VP9E_SET_MIN_GF_INTERVAL, min_arf_requested_);
+ if (test_encode_param_.mode != ::libvpx_test::kRealTime) {+ encoder->Control(VP8E_SET_ENABLEAUTOALTREF, 1);
+ encoder->Control(VP8E_SET_ARNR_MAXFRAMES, 7);
+ encoder->Control(VP8E_SET_ARNR_STRENGTH, 5);
+ encoder->Control(VP8E_SET_ARNR_TYPE, 3);
+ }
+ }
+ }
+
+ int GetMinArfDistance() const {+ return min_arf_;
+ }
+
+ int GetMinArfDistanceRequested() const {+ if (min_arf_requested_)
+ return min_arf_requested_;
+ else
+ return vp9_rc_get_default_min_gf_interval(
+ test_video_param_.width, test_video_param_.height,
+ (double)test_video_param_.framerate_num /
+ test_video_param_.framerate_den);
+ }
+
+ TestVideoParam test_video_param_;
+ TestEncodeParam test_encode_param_;
+
+ private:
+ int min_arf_requested_;
+ int min_arf_;
+ int run_of_visible_frames_;
+};
+
+TEST_P(ArfFreqTest, MinArfFreqTest) {+ cfg_.rc_target_bitrate = kBitrate;
+ cfg_.g_error_resilient = 0;
+ cfg_.g_profile = test_video_param_.profile;
+ cfg_.g_input_bit_depth = test_video_param_.input_bit_depth;
+ cfg_.g_bit_depth = test_video_param_.bit_depth;
+ init_flags_ = VPX_CODEC_USE_PSNR;
+ if (cfg_.g_bit_depth > 8)
+ init_flags_ |= VPX_CODEC_USE_HIGHBITDEPTH;
+
+ libvpx_test::VideoSource *video;
+ if (is_extension_y4m(test_video_param_.filename)) {+ video = new libvpx_test::Y4mVideoSource(test_video_param_.filename,
+ 0, kFrames);
+ } else {+ video = new libvpx_test::YUVVideoSource(test_video_param_.filename,
+ test_video_param_.fmt,
+ test_video_param_.width,
+ test_video_param_.height,
+ test_video_param_.framerate_num,
+ test_video_param_.framerate_den,
+ 0, kFrames);
+ }
+
+ ASSERT_NO_FATAL_FAILURE(RunLoop(video));
+ const int min_arf_dist = GetMinArfDistance();
+ const int min_arf_dist_requested = GetMinArfDistanceRequested();
+ if (min_arf_dist != ARF_NOT_SEEN && min_arf_dist != ARF_SEEN_ONCE) {+ EXPECT_GE(min_arf_dist, min_arf_dist_requested);
+ }
+ delete(video);
+}
+
+VP9_INSTANTIATE_TEST_CASE(
+ ArfFreqTest,
+ ::testing::ValuesIn(kTestVectors),
+ ::testing::ValuesIn(kEncodeVectors),
+ ::testing::ValuesIn(kMinArfVectors));
+} // namespace
--- a/vp9/encoder/vp9_encoder.c
+++ b/vp9/encoder/vp9_encoder.c
@@ -1467,7 +1467,7 @@
cpi->td.mb.e_mbd.bd = (int)cm->bit_depth;
#endif // CONFIG_VP9_HIGHBITDEPTH
- rc->baseline_gf_interval = DEFAULT_GF_INTERVAL;
+ rc->baseline_gf_interval = (MIN_GF_INTERVAL + MAX_GF_INTERVAL) / 2;
cpi->refresh_golden_frame = 0;
cpi->refresh_last_frame = 1;
--- a/vp9/encoder/vp9_encoder.h
+++ b/vp9/encoder/vp9_encoder.h
@@ -50,8 +50,6 @@
extern "C" {#endif
-#define DEFAULT_GF_INTERVAL 10
-
typedef struct {int nmvjointcost[MV_JOINTS];
int nmvcosts[2][MV_VALS];
@@ -218,6 +216,9 @@
int arnr_max_frames;
int arnr_strength;
+
+ int min_gf_interval;
+ int max_gf_interval;
int tile_columns;
int tile_rows;
--- a/vp9/encoder/vp9_firstpass.c
+++ b/vp9/encoder/vp9_firstpass.c
@@ -1851,7 +1851,8 @@
int64_t gf_group_bits;
double gf_group_error_left;
int gf_arf_bits;
- int is_key_frame = frame_is_intra_only(cm);
+ const int is_key_frame = frame_is_intra_only(cm);
+ const int kf_or_arf_active = is_key_frame || rc->source_alt_ref_active;
// Reset the GF group data structures unless this is a key
// frame in which case it will already have been done.
@@ -1904,7 +1905,10 @@
// bits to spare and are better with a smaller interval and smaller boost.
// At high Q when there are few bits to spare we are better with a longer
// interval to spread the cost of the GF.
- active_max_gf_interval = 12 + MIN(4, (int_lbq / 6));
+ active_max_gf_interval = rc->max_gf_interval - 4 + MIN(4, (int_lbq / 6));
+ if (active_max_gf_interval < active_min_gf_interval)
+ active_max_gf_interval = active_min_gf_interval;
+
if (active_max_gf_interval > rc->max_gf_interval)
active_max_gf_interval = rc->max_gf_interval;
if (active_max_gf_interval < active_min_gf_interval)
@@ -1966,10 +1970,11 @@
// Break out conditions.
if (
// Break at active_max_gf_interval unless almost totally static.
- (i >= active_max_gf_interval && (zero_motion_accumulator < 0.995)) ||
+ ((i >= active_max_gf_interval + kf_or_arf_active) &&
+ (zero_motion_accumulator < 0.995)) ||
(
// Don't break out with a very short interval.
- (i > active_min_gf_interval) &&
+ (i >= active_min_gf_interval + kf_or_arf_active) &&
(!flash_detected) &&
((mv_ratio_accumulator > mv_ratio_accumulator_thresh) ||
(abs_mv_in_out_accumulator > 3.0) ||
--- a/vp9/encoder/vp9_ratectrl.c
+++ b/vp9/encoder/vp9_ratectrl.c
@@ -276,6 +276,27 @@
}
}
+int vp9_rc_get_default_min_gf_interval(
+ int width, int height, double framerate) {+ // Assume we do not need any constraint lower than 4K 20 fps
+ static const double factor_safe = 3840 * 2160 * 20.0;
+ const double factor = width * height * framerate;
+
+ if (factor <= factor_safe)
+ return MIN_GF_INTERVAL;
+ else
+ return (int)(MIN_GF_INTERVAL * factor / factor_safe + 0.5);
+ // Note this logic makes:
+ // 4K24: 5
+ // 4K30: 6
+ // 4K60: 12
+}
+
+int vp9_rc_get_default_max_gf_interval(double framerate, int min_gf_interval) {+ int interval = MIN(MAX_GF_INTERVAL, (int)(framerate * 0.75));
+ return MAX(interval, min_gf_interval);
+}
+
void vp9_rc_init(const VP9EncoderConfig *oxcf, int pass, RATE_CONTROL *rc) {int i;
@@ -284,9 +305,9 @@
rc->avg_frame_qindex[INTER_FRAME] = oxcf->worst_allowed_q;
} else {rc->avg_frame_qindex[KEY_FRAME] = (oxcf->worst_allowed_q +
- oxcf->best_allowed_q) / 2;
+ oxcf->best_allowed_q) / 2;
rc->avg_frame_qindex[INTER_FRAME] = (oxcf->worst_allowed_q +
- oxcf->best_allowed_q) / 2;
+ oxcf->best_allowed_q) / 2;
}
rc->last_q[KEY_FRAME] = oxcf->best_allowed_q;
@@ -304,7 +325,6 @@
rc->total_target_bits = 0;
rc->total_target_vs_actual = 0;
- rc->baseline_gf_interval = DEFAULT_GF_INTERVAL;
rc->frames_since_key = 8; // Sensible default for first frame.
rc->this_key_frame_forced = 0;
rc->next_key_frame_forced = 0;
@@ -322,6 +342,16 @@
for (i = 0; i < RATE_FACTOR_LEVELS; ++i) {rc->rate_correction_factors[i] = 1.0;
}
+
+ rc->min_gf_interval = oxcf->min_gf_interval;
+ rc->max_gf_interval = oxcf->max_gf_interval;
+ if (rc->min_gf_interval == 0)
+ rc->min_gf_interval = vp9_rc_get_default_min_gf_interval(
+ oxcf->width, oxcf->height, oxcf->init_framerate);
+ if (rc->max_gf_interval == 0)
+ rc->max_gf_interval = vp9_rc_get_default_max_gf_interval(
+ oxcf->init_framerate, rc->min_gf_interval);
+ rc->baseline_gf_interval = (rc->min_gf_interval + rc->max_gf_interval) / 2;
}
int vp9_rc_drop_frame(VP9_COMP *cpi) {@@ -1382,7 +1412,7 @@
cm->frame_type = INTER_FRAME;
}
if (rc->frames_till_gf_update_due == 0) {- rc->baseline_gf_interval = DEFAULT_GF_INTERVAL;
+ rc->baseline_gf_interval = (rc->min_gf_interval + rc->max_gf_interval) / 2;
rc->frames_till_gf_update_due = rc->baseline_gf_interval;
// NOTE: frames_till_gf_update_due must be <= frames_to_key.
if (rc->frames_till_gf_update_due > rc->frames_to_key) {@@ -1576,7 +1606,8 @@
if (cpi->oxcf.aq_mode == CYCLIC_REFRESH_AQ)
vp9_cyclic_refresh_set_golden_update(cpi);
else
- rc->baseline_gf_interval = DEFAULT_GF_INTERVAL;
+ rc->baseline_gf_interval =
+ (rc->min_gf_interval + rc->max_gf_interval) / 2;
rc->frames_till_gf_update_due = rc->baseline_gf_interval;
// NOTE: frames_till_gf_update_due must be <= frames_to_key.
if (rc->frames_till_gf_update_due > rc->frames_to_key)
@@ -1649,20 +1680,19 @@
return target_index - qindex;
}
-#define MIN_GF_INTERVAL 4
-#define MAX_GF_INTERVAL 16
void vp9_rc_set_gf_interval_range(const VP9_COMP *const cpi,
RATE_CONTROL *const rc) {const VP9EncoderConfig *const oxcf = &cpi->oxcf;
- // Set a minimum interval.
- rc->min_gf_interval =
- MIN(MAX_GF_INTERVAL, MAX(MIN_GF_INTERVAL, (int)(cpi->framerate * 0.125)));
-
- // Set Maximum gf/arf interval.
- rc->max_gf_interval =
- MIN(MAX_GF_INTERVAL, (int)(cpi->framerate * 0.75));
- // Round up to next even number if odd.
+ // Set Maximum gf/arf interval
+ rc->max_gf_interval = oxcf->max_gf_interval;
+ rc->min_gf_interval = oxcf->min_gf_interval;
+ if (rc->min_gf_interval == 0)
+ rc->min_gf_interval = vp9_rc_get_default_min_gf_interval(
+ oxcf->width, oxcf->height, cpi->framerate);
+ if (rc->max_gf_interval == 0)
+ rc->max_gf_interval = vp9_rc_get_default_max_gf_interval(
+ cpi->framerate, rc->min_gf_interval);
rc->max_gf_interval += (rc->max_gf_interval & 0x01);
// Extended interval for genuinely static scenes
--- a/vp9/encoder/vp9_ratectrl.h
+++ b/vp9/encoder/vp9_ratectrl.h
@@ -24,6 +24,9 @@
// Bits Per MB at different Q (Multiplied by 512)
#define BPER_MB_NORMBITS 9
+#define MIN_GF_INTERVAL 4
+#define MAX_GF_INTERVAL 16
+
typedef enum {INTER_NORMAL = 0,
INTER_HIGH = 1,
@@ -154,6 +157,12 @@
double vp9_convert_qindex_to_q(int qindex, vpx_bit_depth_t bit_depth);
void vp9_rc_init_minq_luts(void);
+
+int vp9_rc_get_default_min_gf_interval(int width, int height, double framerate);
+// Note vp9_rc_get_default_max_gf_interval() requires the min_gf_interval to
+// be passed in to ensure that the max_gf_interval returned is at least as bis
+// as that.
+int vp9_rc_get_default_max_gf_interval(double framerate, int min_frame_rate);
// Generally at the high level, the following flow is expected
// to be enforced for rate control:
--- a/vp9/vp9_cx_iface.c
+++ b/vp9/vp9_cx_iface.c
@@ -31,6 +31,8 @@
unsigned int tile_rows;
unsigned int arnr_max_frames;
unsigned int arnr_strength;
+ unsigned int min_gf_interval;
+ unsigned int max_gf_interval;
vp8e_tuning tuning;
unsigned int cq_level; // constrained quality level
unsigned int rc_max_intra_bitrate_pct;
@@ -55,6 +57,8 @@
0, // tile_rows
7, // arnr_max_frames
5, // arnr_strength
+ 0, // min_gf_interval; 0 -> default decision
+ 0, // max_gf_interval; 0 -> default decision
VP8_TUNE_PSNR, // tuning
10, // cq_level
0, // rc_max_intra_bitrate_pct
@@ -167,6 +171,12 @@
RANGE_CHECK_HI(cfg, rc_resize_up_thresh, 100);
RANGE_CHECK_HI(cfg, rc_resize_down_thresh, 100);
RANGE_CHECK(cfg, g_pass, VPX_RC_ONE_PASS, VPX_RC_LAST_PASS);
+ RANGE_CHECK(extra_cfg, min_gf_interval, 0, (MAX_LAG_BUFFERS - 1));
+ RANGE_CHECK(extra_cfg, max_gf_interval, 0, (MAX_LAG_BUFFERS - 1));
+ if (extra_cfg->min_gf_interval > 0 && extra_cfg->max_gf_interval > 0) {+ RANGE_CHECK(extra_cfg, max_gf_interval, extra_cfg->min_gf_interval,
+ (MAX_LAG_BUFFERS - 1));
+ }
if (cfg->rc_resize_allowed == 1) {RANGE_CHECK(cfg, rc_scaled_width, 0, cfg->g_w);
@@ -454,6 +464,8 @@
oxcf->color_space = extra_cfg->color_space;
oxcf->arnr_max_frames = extra_cfg->arnr_max_frames;
oxcf->arnr_strength = extra_cfg->arnr_strength;
+ oxcf->min_gf_interval = extra_cfg->min_gf_interval;
+ oxcf->max_gf_interval = extra_cfg->max_gf_interval;
oxcf->tuning = extra_cfg->tuning;
oxcf->content = extra_cfg->content;
@@ -727,6 +739,20 @@
return update_extra_cfg(ctx, &extra_cfg);
}
+static vpx_codec_err_t ctrl_set_min_gf_interval(vpx_codec_alg_priv_t *ctx,
+ va_list args) {+ struct vp9_extracfg extra_cfg = ctx->extra_cfg;
+ extra_cfg.min_gf_interval = CAST(VP9E_SET_MIN_GF_INTERVAL, args);
+ return update_extra_cfg(ctx, &extra_cfg);
+}
+
+static vpx_codec_err_t ctrl_set_max_gf_interval(vpx_codec_alg_priv_t *ctx,
+ va_list args) {+ struct vp9_extracfg extra_cfg = ctx->extra_cfg;
+ extra_cfg.max_gf_interval = CAST(VP9E_SET_MAX_GF_INTERVAL, args);
+ return update_extra_cfg(ctx, &extra_cfg);
+}
+
static vpx_codec_err_t ctrl_set_frame_periodic_boost(vpx_codec_alg_priv_t *ctx,
va_list args) {struct vp9_extracfg extra_cfg = ctx->extra_cfg;
@@ -1444,6 +1470,8 @@
{VP9E_SET_TUNE_CONTENT, ctrl_set_tune_content}, {VP9E_SET_COLOR_SPACE, ctrl_set_color_space}, {VP9E_SET_NOISE_SENSITIVITY, ctrl_set_noise_sensitivity},+ {VP9E_SET_MIN_GF_INTERVAL, ctrl_set_min_gf_interval},+ {VP9E_SET_MAX_GF_INTERVAL, ctrl_set_max_gf_interval},// Getters
{VP8E_GET_LAST_QUANTIZER, ctrl_get_quantizer},--- a/vpx/vp8cx.h
+++ b/vpx/vp8cx.h
@@ -518,6 +518,22 @@
*/
VP9E_SET_TEMPORAL_LAYERING_MODE,
+ /*!\brief Codec control function to set minimum interval between GF/ARF frames
+ *
+ * By default the value is set as 4.
+ *
+ * Supported in codecs: VP9
+ */
+ VP9E_SET_MIN_GF_INTERVAL,
+
+ /*!\brief Codec control function to set minimum interval between GF/ARF frames
+ *
+ * By default the value is set as 16.
+ *
+ * Supported in codecs: VP9
+ */
+ VP9E_SET_MAX_GF_INTERVAL,
+
/*!\brief Codec control function to get an Active map back from the encoder.
*
* Supported in codecs: VP9
@@ -715,6 +731,10 @@
VPX_CTRL_USE_TYPE(VP9E_SET_TUNE_CONTENT, int) /* vp9e_tune_content */
VPX_CTRL_USE_TYPE(VP9E_SET_COLOR_SPACE, int)
+
+VPX_CTRL_USE_TYPE(VP9E_SET_MIN_GF_INTERVAL, unsigned int)
+
+VPX_CTRL_USE_TYPE(VP9E_SET_MAX_GF_INTERVAL, unsigned int)
VPX_CTRL_USE_TYPE(VP9E_GET_ACTIVEMAP, vpx_active_map_t *)
/*! @} - end defgroup vp8_encoder */
--- a/vpxenc.c
+++ b/vpxenc.c
@@ -396,6 +396,12 @@
NULL, "gf-cbr-boost", 1, "Boost for Golden Frame in CBR mode (pct)");
static const arg_def_t max_inter_rate_pct = ARG_DEF(
NULL, "max-inter-rate", 1, "Max P-frame bitrate (pct)");
+static const arg_def_t min_gf_interval = ARG_DEF(
+ NULL, "min-gf-interval", 1,
+ "min gf/arf frame interval (default 0, indicating in-built behavior)");
+static const arg_def_t max_gf_interval = ARG_DEF(
+ NULL, "max-gf-interval", 1,
+ "max gf/arf frame interval (default 0, indicating in-built behavior)");
static const struct arg_enum_list color_space_enum[] = { { "unknown", VPX_CS_UNKNOWN },@@ -445,6 +451,7 @@
&gf_cbr_boost_pct, &lossless,
&frame_parallel_decoding, &aq_mode, &frame_periodic_boost,
&noise_sens, &tune_content, &input_color_space,
+ &min_gf_interval, &max_gf_interval,
#if CONFIG_VP9 && CONFIG_VP9_HIGHBITDEPTH
&bitdeptharg, &inbitdeptharg,
#endif
@@ -460,6 +467,7 @@
VP9E_SET_LOSSLESS, VP9E_SET_FRAME_PARALLEL_DECODING, VP9E_SET_AQ_MODE,
VP9E_SET_FRAME_PERIODIC_BOOST, VP9E_SET_NOISE_SENSITIVITY,
VP9E_SET_TUNE_CONTENT, VP9E_SET_COLOR_SPACE,
+ VP9E_SET_MIN_GF_INTERVAL, VP9E_SET_MAX_GF_INTERVAL,
0
};
#endif