2010-05-18 17:58:33 +02:00
|
|
|
/*
|
2010-09-09 14:16:39 +02:00
|
|
|
* Copyright (c) 2010 The WebM project authors. All Rights Reserved.
|
2010-05-18 17:58:33 +02:00
|
|
|
*
|
2010-06-18 18:39:21 +02:00
|
|
|
* Use of this source code is governed by a BSD-style license
|
2010-06-04 22:19:40 +02:00
|
|
|
* that can be found in the LICENSE file in the root of the source
|
|
|
|
* tree. An additional intellectual property rights grant can be found
|
2010-06-18 18:39:21 +02:00
|
|
|
* in the file PATENTS. All contributing project authors may
|
2010-06-04 22:19:40 +02:00
|
|
|
* be found in the AUTHORS file in the root of the source tree.
|
2010-05-18 17:58:33 +02:00
|
|
|
*/
|
|
|
|
|
2013-10-05 02:16:20 +02:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-07-14 20:24:17 +02:00
|
|
|
#include "./vpx_config.h"
|
2010-05-24 17:39:59 +02:00
|
|
|
#include "vpx/vpx_codec.h"
|
|
|
|
#include "vpx/internal/vpx_codec_internal.h"
|
2013-10-05 02:16:20 +02:00
|
|
|
#include "./vpx_version.h"
|
2014-04-19 03:27:47 +02:00
|
|
|
#include "vp9/encoder/vp9_encoder.h"
|
2012-11-05 21:37:14 +01:00
|
|
|
#include "vpx/vp8cx.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/encoder/vp9_firstpass.h"
|
2013-03-13 20:15:43 +01:00
|
|
|
#include "vp9/vp9_iface_common.h"
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-05-23 03:04:08 +02:00
|
|
|
struct vp9_extracfg {
|
2012-07-14 00:21:29 +02:00
|
|
|
struct vpx_codec_pkt_list *pkt_list;
|
2014-04-02 02:14:55 +02:00
|
|
|
int cpu_used; // available cpu percentage in 1/16
|
2013-10-05 02:16:20 +02:00
|
|
|
unsigned int enable_auto_alt_ref;
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned int noise_sensitivity;
|
2014-01-08 23:19:14 +01:00
|
|
|
unsigned int sharpness;
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned int static_thresh;
|
[WIP] Add column-based tiling.
This patch adds column-based tiling. The idea is to make each tile
independently decodable (after reading the common frame header) and
also independendly encodable (minus within-frame cost adjustments in
the RD loop) to speed-up hardware & software en/decoders if they used
multi-threading. Column-based tiling has the added advantage (over
other tiling methods) that it minimizes realtime use-case latency,
since all threads can start encoding data as soon as the first SB-row
worth of data is available to the encoder.
There is some test code that does random tile ordering in the decoder,
to confirm that each tile is indeed independently decodable from other
tiles in the same frame. At tile edges, all contexts assume default
values (i.e. 0, 0 motion vector, no coefficients, DC intra4x4 mode),
and motion vector search and ordering do not cross tiles in the same
frame.
t log
Tile independence is not maintained between frames ATM, i.e. tile 0 of
frame 1 is free to use motion vectors that point into any tile of frame
0. We support 1 (i.e. no tiling), 2 or 4 column-tiles.
The loopfilter crosses tile boundaries. I discussed this briefly with Aki
and he says that's OK. An in-loop loopfilter would need to do some sync
between tile threads, but that shouldn't be a big issue.
Resuls: with tiling disabled, we go up slightly because of improved edge
use in the intra4x4 prediction. With 2 tiles, we lose about ~1% on derf,
~0.35% on HD and ~0.55% on STD/HD. With 4 tiles, we lose another ~1.5%
on derf ~0.77% on HD and ~0.85% on STD/HD. Most of this loss is
concentrated in the low-bitrate end of clips, and most of it is because
of the loss of edges at tile boundaries and the resulting loss of intra
predictors.
TODO:
- more tiles (perhaps allow row-based tiling also, and max. 8 tiles)?
- maybe optionally (for EC purposes), motion vectors themselves
should not cross tile edges, or we should emulate such borders as
if they were off-frame, to limit error propagation to within one
tile only. This doesn't have to be the default behaviour but could
be an optional bitstream flag.
Change-Id: I5951c3a0742a767b20bc9fb5af685d9892c2c96f
2013-02-01 18:35:28 +01:00
|
|
|
unsigned int tile_columns;
|
2013-02-08 20:33:11 +01:00
|
|
|
unsigned int tile_rows;
|
2013-10-05 02:16:20 +02:00
|
|
|
unsigned int arnr_max_frames;
|
|
|
|
unsigned int arnr_strength;
|
2014-04-28 23:28:58 +02:00
|
|
|
unsigned int arnr_type;
|
2012-07-14 00:21:29 +02:00
|
|
|
vp8e_tuning tuning;
|
2014-04-02 02:14:55 +02:00
|
|
|
unsigned int cq_level; // constrained quality level
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned int rc_max_intra_bitrate_pct;
|
2012-11-05 21:37:14 +01:00
|
|
|
unsigned int lossless;
|
2013-03-27 19:07:26 +01:00
|
|
|
unsigned int frame_parallel_decoding_mode;
|
2014-03-18 18:47:51 +01:00
|
|
|
AQ_MODE aq_mode;
|
2014-04-04 00:49:03 +02:00
|
|
|
unsigned int frame_periodic_boost;
|
2014-04-05 02:30:16 +02:00
|
|
|
BIT_DEPTH bit_depth;
|
2014-07-31 17:27:32 +02:00
|
|
|
vp9e_tune_content content;
|
2010-05-18 17:58:33 +02:00
|
|
|
};
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
struct extraconfig_map {
|
2014-05-12 18:40:11 +02:00
|
|
|
unsigned int usage;
|
2013-05-23 03:04:08 +02:00
|
|
|
struct vp9_extracfg cfg;
|
2010-05-18 17:58:33 +02:00
|
|
|
};
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
static const struct extraconfig_map extracfg_map[] = {
|
|
|
|
{
|
|
|
|
0,
|
2013-10-05 02:16:20 +02:00
|
|
|
{ // NOLINT
|
2012-07-14 00:21:29 +02:00
|
|
|
NULL,
|
2014-04-02 02:14:55 +02:00
|
|
|
0, // cpu_used
|
|
|
|
1, // enable_auto_alt_ref
|
|
|
|
0, // noise_sensitivity
|
|
|
|
0, // sharpness
|
|
|
|
0, // static_thresh
|
|
|
|
0, // tile_columns
|
|
|
|
0, // tile_rows
|
|
|
|
7, // arnr_max_frames
|
|
|
|
5, // arnr_strength
|
2014-04-28 23:28:58 +02:00
|
|
|
3, // arnr_type
|
2014-04-02 02:14:55 +02:00
|
|
|
VP8_TUNE_PSNR, // tuning
|
|
|
|
10, // cq_level
|
|
|
|
0, // rc_max_intra_bitrate_pct
|
|
|
|
0, // lossless
|
|
|
|
0, // frame_parallel_decoding_mode
|
|
|
|
NO_AQ, // aq_mode
|
2014-04-04 00:49:03 +02:00
|
|
|
0, // frame_periodic_delta_q
|
2014-04-05 02:30:16 +02:00
|
|
|
BITS_8, // Bit depth
|
2014-08-07 15:53:24 +02:00
|
|
|
VP9E_CONTENT_DEFAULT // content
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
};
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
struct vpx_codec_alg_priv {
|
|
|
|
vpx_codec_priv_t base;
|
|
|
|
vpx_codec_enc_cfg_t cfg;
|
2014-03-12 23:49:49 +01:00
|
|
|
struct vp9_extracfg extra_cfg;
|
2014-04-18 20:01:36 +02:00
|
|
|
VP9EncoderConfig oxcf;
|
2014-03-04 01:50:16 +01:00
|
|
|
VP9_COMP *cpi;
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned char *cx_data;
|
2013-12-06 02:20:01 +01:00
|
|
|
size_t cx_data_sz;
|
2012-11-15 21:19:07 +01:00
|
|
|
unsigned char *pending_cx_data;
|
2013-12-06 02:20:01 +01:00
|
|
|
size_t pending_cx_data_sz;
|
2013-03-05 21:23:34 +01:00
|
|
|
int pending_frame_count;
|
2013-12-06 02:20:01 +01:00
|
|
|
size_t pending_frame_sizes[8];
|
|
|
|
size_t pending_frame_magnitude;
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_image_t preview_img;
|
|
|
|
vp8_postproc_cfg_t preview_ppcfg;
|
2014-07-14 20:24:17 +02:00
|
|
|
vpx_codec_pkt_list_decl(256) pkt_list;
|
2014-06-24 23:01:17 +02:00
|
|
|
unsigned int fixed_kf_cntr;
|
2010-05-18 17:58:33 +02:00
|
|
|
};
|
|
|
|
|
2013-09-26 19:33:21 +02:00
|
|
|
static VP9_REFFRAME ref_frame_to_vp9_reframe(vpx_ref_frame_type_t frame) {
|
2013-09-06 19:13:35 +02:00
|
|
|
switch (frame) {
|
|
|
|
case VP8_LAST_FRAME:
|
|
|
|
return VP9_LAST_FLAG;
|
|
|
|
case VP8_GOLD_FRAME:
|
|
|
|
return VP9_GOLD_FLAG;
|
|
|
|
case VP8_ALTR_FRAME:
|
|
|
|
return VP9_ALT_FLAG;
|
|
|
|
}
|
2013-12-13 04:44:08 +01:00
|
|
|
assert(0 && "Invalid Reference Frame");
|
2013-09-06 19:13:35 +02:00
|
|
|
return VP9_LAST_FLAG;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
static vpx_codec_err_t update_error_state(vpx_codec_alg_priv_t *ctx,
|
|
|
|
const struct vpx_internal_error_info *error) {
|
|
|
|
const vpx_codec_err_t res = error->error_code;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
if (res != VPX_CODEC_OK)
|
|
|
|
ctx->base.err_detail = error->has_detail ? error->detail : NULL;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return res;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-11-17 15:08:47 +01:00
|
|
|
#undef ERROR
|
2010-05-18 17:58:33 +02:00
|
|
|
#define ERROR(str) do {\
|
2012-07-14 00:21:29 +02:00
|
|
|
ctx->base.err_detail = str;\
|
|
|
|
return VPX_CODEC_INVALID_PARAM;\
|
2013-10-05 02:16:20 +02:00
|
|
|
} while (0)
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-10-05 02:16:20 +02:00
|
|
|
#define RANGE_CHECK(p, memb, lo, hi) do {\
|
|
|
|
if (!(((p)->memb == lo || (p)->memb > (lo)) && (p)->memb <= hi)) \
|
2012-07-14 00:21:29 +02:00
|
|
|
ERROR(#memb " out of range ["#lo".."#hi"]");\
|
2013-10-05 02:16:20 +02:00
|
|
|
} while (0)
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-10-05 02:16:20 +02:00
|
|
|
#define RANGE_CHECK_HI(p, memb, hi) do {\
|
|
|
|
if (!((p)->memb <= (hi))) \
|
2012-07-14 00:21:29 +02:00
|
|
|
ERROR(#memb " out of range [.."#hi"]");\
|
2013-10-05 02:16:20 +02:00
|
|
|
} while (0)
|
2010-06-11 20:33:49 +02:00
|
|
|
|
2013-10-05 02:16:20 +02:00
|
|
|
#define RANGE_CHECK_LO(p, memb, lo) do {\
|
|
|
|
if (!((p)->memb >= (lo))) \
|
2012-07-14 00:21:29 +02:00
|
|
|
ERROR(#memb " out of range ["#lo"..]");\
|
2013-10-05 02:16:20 +02:00
|
|
|
} while (0)
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-10-05 02:16:20 +02:00
|
|
|
#define RANGE_CHECK_BOOL(p, memb) do {\
|
|
|
|
if (!!((p)->memb) != (p)->memb) ERROR(#memb " expected boolean");\
|
|
|
|
} while (0)
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
static vpx_codec_err_t validate_config(vpx_codec_alg_priv_t *ctx,
|
2010-05-18 17:58:33 +02:00
|
|
|
const vpx_codec_enc_cfg_t *cfg,
|
2014-03-12 23:49:49 +01:00
|
|
|
const struct vp9_extracfg *extra_cfg) {
|
2014-04-02 02:14:55 +02:00
|
|
|
RANGE_CHECK(cfg, g_w, 1, 65535); // 16 bits available
|
|
|
|
RANGE_CHECK(cfg, g_h, 1, 65535); // 16 bits available
|
2012-07-14 00:21:29 +02:00
|
|
|
RANGE_CHECK(cfg, g_timebase.den, 1, 1000000000);
|
|
|
|
RANGE_CHECK(cfg, g_timebase.num, 1, cfg->g_timebase.den);
|
|
|
|
RANGE_CHECK_HI(cfg, g_profile, 3);
|
2012-11-05 21:37:14 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
RANGE_CHECK_HI(cfg, rc_max_quantizer, 63);
|
|
|
|
RANGE_CHECK_HI(cfg, rc_min_quantizer, cfg->rc_max_quantizer);
|
2014-03-12 23:49:49 +01:00
|
|
|
RANGE_CHECK_BOOL(extra_cfg, lossless);
|
|
|
|
RANGE_CHECK(extra_cfg, aq_mode, 0, AQ_MODE_COUNT - 1);
|
2014-04-04 00:49:03 +02:00
|
|
|
RANGE_CHECK(extra_cfg, frame_periodic_boost, 0, 1);
|
2012-07-14 00:21:29 +02:00
|
|
|
RANGE_CHECK_HI(cfg, g_threads, 64);
|
|
|
|
RANGE_CHECK_HI(cfg, g_lag_in_frames, MAX_LAG_BUFFERS);
|
2013-08-30 01:21:44 +02:00
|
|
|
RANGE_CHECK(cfg, rc_end_usage, VPX_VBR, VPX_Q);
|
2012-07-14 00:21:29 +02:00
|
|
|
RANGE_CHECK_HI(cfg, rc_undershoot_pct, 1000);
|
|
|
|
RANGE_CHECK_HI(cfg, rc_overshoot_pct, 1000);
|
|
|
|
RANGE_CHECK_HI(cfg, rc_2pass_vbr_bias_pct, 100);
|
|
|
|
RANGE_CHECK(cfg, kf_mode, VPX_KF_DISABLED, VPX_KF_AUTO);
|
|
|
|
RANGE_CHECK_BOOL(cfg, rc_resize_allowed);
|
|
|
|
RANGE_CHECK_HI(cfg, rc_dropframe_thresh, 100);
|
|
|
|
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);
|
|
|
|
|
2014-04-09 23:51:29 +02:00
|
|
|
if (cfg->rc_resize_allowed == 1) {
|
|
|
|
RANGE_CHECK(cfg, rc_scaled_width, 1, cfg->g_w);
|
|
|
|
RANGE_CHECK(cfg, rc_scaled_height, 1, cfg->g_h);
|
|
|
|
}
|
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
RANGE_CHECK(cfg, ss_number_layers, 1, VPX_SS_MAX_LAYERS);
|
2014-07-14 20:24:17 +02:00
|
|
|
|
2014-07-22 19:05:40 +02:00
|
|
|
#if CONFIG_SPATIAL_SVC
|
2014-07-14 20:24:17 +02:00
|
|
|
if (cfg->ss_number_layers > 1) {
|
2014-07-15 20:22:28 +02:00
|
|
|
unsigned int i, alt_ref_sum = 0;
|
2014-07-14 20:24:17 +02:00
|
|
|
for (i = 0; i < cfg->ss_number_layers; ++i) {
|
|
|
|
if (cfg->ss_enable_auto_alt_ref[i])
|
|
|
|
++alt_ref_sum;
|
|
|
|
}
|
|
|
|
if (alt_ref_sum > REF_FRAMES - cfg->ss_number_layers)
|
|
|
|
ERROR("Not enough ref buffers for svc alt ref frames");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-02-06 18:23:17 +01:00
|
|
|
RANGE_CHECK(cfg, ts_number_layers, 1, VPX_TS_MAX_LAYERS);
|
|
|
|
if (cfg->ts_number_layers > 1) {
|
2014-02-13 03:31:25 +01:00
|
|
|
unsigned int i;
|
2014-04-02 02:14:55 +02:00
|
|
|
for (i = 1; i < cfg->ts_number_layers; ++i)
|
|
|
|
if (cfg->ts_target_bitrate[i] < cfg->ts_target_bitrate[i - 1])
|
2014-02-06 18:23:17 +01:00
|
|
|
ERROR("ts_target_bitrate entries are not increasing");
|
2014-04-02 02:14:55 +02:00
|
|
|
|
|
|
|
RANGE_CHECK(cfg, ts_rate_decimator[cfg->ts_number_layers - 1], 1, 1);
|
|
|
|
for (i = cfg->ts_number_layers - 2; i > 0; --i)
|
|
|
|
if (cfg->ts_rate_decimator[i - 1] != 2 * cfg->ts_rate_decimator[i])
|
2014-02-06 18:23:17 +01:00
|
|
|
ERROR("ts_rate_decimator factors are not powers of 2");
|
|
|
|
}
|
|
|
|
|
2014-04-23 19:08:31 +02:00
|
|
|
// VP9 does not support a lower bound on the keyframe interval in
|
2014-04-02 02:14:55 +02:00
|
|
|
// automatic keyframe placement mode.
|
|
|
|
if (cfg->kf_mode != VPX_KF_DISABLED &&
|
|
|
|
cfg->kf_min_dist != cfg->kf_max_dist &&
|
|
|
|
cfg->kf_min_dist > 0)
|
2012-07-14 00:21:29 +02:00
|
|
|
ERROR("kf_min_dist not supported in auto mode, use 0 "
|
|
|
|
"or kf_max_dist instead.");
|
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
RANGE_CHECK_BOOL(extra_cfg, enable_auto_alt_ref);
|
|
|
|
RANGE_CHECK(extra_cfg, cpu_used, -16, 16);
|
|
|
|
RANGE_CHECK_HI(extra_cfg, noise_sensitivity, 6);
|
|
|
|
RANGE_CHECK(extra_cfg, tile_columns, 0, 6);
|
|
|
|
RANGE_CHECK(extra_cfg, tile_rows, 0, 2);
|
|
|
|
RANGE_CHECK_HI(extra_cfg, sharpness, 7);
|
|
|
|
RANGE_CHECK(extra_cfg, arnr_max_frames, 0, 15);
|
|
|
|
RANGE_CHECK_HI(extra_cfg, arnr_strength, 6);
|
2014-04-28 23:28:58 +02:00
|
|
|
RANGE_CHECK(extra_cfg, arnr_type, 1, 3);
|
2014-03-12 23:49:49 +01:00
|
|
|
RANGE_CHECK(extra_cfg, cq_level, 0, 63);
|
2014-07-31 17:27:32 +02:00
|
|
|
RANGE_CHECK(extra_cfg, content,
|
|
|
|
VP9E_CONTENT_DEFAULT, VP9E_CONTENT_INVALID - 1);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2013-12-04 21:36:42 +01:00
|
|
|
// TODO(yaowu): remove this when ssim tuning is implemented for vp9
|
2014-03-12 23:49:49 +01:00
|
|
|
if (extra_cfg->tuning == VP8_TUNE_SSIM)
|
2013-12-04 21:36:42 +01:00
|
|
|
ERROR("Option --tune=ssim is not currently supported in VP9.");
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cfg->g_pass == VPX_RC_LAST_PASS) {
|
2014-05-14 21:11:51 +02:00
|
|
|
const size_t packet_sz = sizeof(FIRSTPASS_STATS);
|
|
|
|
const int n_packets = (int)(cfg->rc_twopass_stats_in.sz / packet_sz);
|
2014-03-18 18:47:51 +01:00
|
|
|
const FIRSTPASS_STATS *stats;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-02-05 18:45:13 +01:00
|
|
|
if (cfg->rc_twopass_stats_in.buf == NULL)
|
2012-07-14 00:21:29 +02:00
|
|
|
ERROR("rc_twopass_stats_in.buf not set.");
|
|
|
|
|
|
|
|
if (cfg->rc_twopass_stats_in.sz % packet_sz)
|
|
|
|
ERROR("rc_twopass_stats_in.sz indicates truncated packet.");
|
|
|
|
|
2014-03-27 21:43:20 +01:00
|
|
|
if (cfg->ss_number_layers > 1) {
|
|
|
|
int i;
|
|
|
|
unsigned int n_packets_per_layer[VPX_SS_MAX_LAYERS] = {0};
|
|
|
|
|
|
|
|
stats = cfg->rc_twopass_stats_in.buf;
|
|
|
|
for (i = 0; i < n_packets; ++i) {
|
2014-03-28 19:42:26 +01:00
|
|
|
const int layer_id = (int)stats[i].spatial_layer_id;
|
2014-03-27 21:43:20 +01:00
|
|
|
if (layer_id >= 0 && layer_id < (int)cfg->ss_number_layers) {
|
|
|
|
++n_packets_per_layer[layer_id];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < (int)cfg->ss_number_layers; ++i) {
|
|
|
|
unsigned int layer_id;
|
|
|
|
if (n_packets_per_layer[i] < 2) {
|
|
|
|
ERROR("rc_twopass_stats_in requires at least two packets for each "
|
|
|
|
"layer.");
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-03-27 21:43:20 +01:00
|
|
|
stats = (const FIRSTPASS_STATS *)cfg->rc_twopass_stats_in.buf +
|
|
|
|
n_packets - cfg->ss_number_layers + i;
|
2014-03-28 19:42:26 +01:00
|
|
|
layer_id = (int)stats->spatial_layer_id;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-03-27 21:43:20 +01:00
|
|
|
if (layer_id >= cfg->ss_number_layers
|
2014-05-12 18:40:11 +02:00
|
|
|
||(unsigned int)(stats->count + 0.5) !=
|
|
|
|
n_packets_per_layer[layer_id] - 1)
|
2014-03-27 21:43:20 +01:00
|
|
|
ERROR("rc_twopass_stats_in missing EOS stats packet");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (cfg->rc_twopass_stats_in.sz < 2 * packet_sz)
|
|
|
|
ERROR("rc_twopass_stats_in requires at least two packets.");
|
|
|
|
|
|
|
|
stats =
|
|
|
|
(const FIRSTPASS_STATS *)cfg->rc_twopass_stats_in.buf + n_packets - 1;
|
|
|
|
|
|
|
|
if ((int)(stats->count + 0.5) != n_packets - 1)
|
|
|
|
ERROR("rc_twopass_stats_in missing EOS stats packet");
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2014-07-14 18:13:38 +02:00
|
|
|
|
2014-04-05 02:30:16 +02:00
|
|
|
if (cfg->g_profile <= (unsigned int)PROFILE_1 &&
|
|
|
|
extra_cfg->bit_depth > BITS_8)
|
|
|
|
ERROR("High bit-depth not supported in profile < 2");
|
|
|
|
if (cfg->g_profile > (unsigned int)PROFILE_1 &&
|
|
|
|
extra_cfg->bit_depth == BITS_8)
|
|
|
|
ERROR("Bit-depth 8 not supported in profile > 1");
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
return VPX_CODEC_OK;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static vpx_codec_err_t validate_img(vpx_codec_alg_priv_t *ctx,
|
2014-04-02 02:14:55 +02:00
|
|
|
const vpx_image_t *img) {
|
2012-07-14 00:21:29 +02:00
|
|
|
switch (img->fmt) {
|
2010-05-21 05:22:39 +02:00
|
|
|
case VPX_IMG_FMT_YV12:
|
|
|
|
case VPX_IMG_FMT_I420:
|
2013-05-07 00:52:06 +02:00
|
|
|
case VPX_IMG_FMT_I422:
|
|
|
|
case VPX_IMG_FMT_I444:
|
2012-07-14 00:21:29 +02:00
|
|
|
break;
|
2010-05-18 17:58:33 +02:00
|
|
|
default:
|
2013-05-07 00:52:06 +02:00
|
|
|
ERROR("Invalid image format. Only YV12, I420, I422, I444 images are "
|
|
|
|
"supported.");
|
2014-08-04 17:52:53 +02:00
|
|
|
break;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
if (img->d_w != ctx->cfg.g_w || img->d_h != ctx->cfg.g_h)
|
2012-07-14 00:21:29 +02:00
|
|
|
ERROR("Image size must match encoder init configuration size");
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return VPX_CODEC_OK;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-07-22 03:27:58 +02:00
|
|
|
static int get_image_bps(const vpx_image_t *img) {
|
|
|
|
switch (img->fmt) {
|
|
|
|
case VPX_IMG_FMT_YV12:
|
|
|
|
case VPX_IMG_FMT_I420: return 12;
|
|
|
|
case VPX_IMG_FMT_I422: return 16;
|
|
|
|
case VPX_IMG_FMT_I444: return 24;
|
2014-08-04 17:52:53 +02:00
|
|
|
default: assert(0 && "Invalid image format"); break;
|
2014-07-22 03:27:58 +02:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-05 02:30:16 +02:00
|
|
|
static vpx_codec_err_t set_encoder_config(
|
2014-04-18 20:01:36 +02:00
|
|
|
VP9EncoderConfig *oxcf,
|
2014-04-05 02:30:16 +02:00
|
|
|
const vpx_codec_enc_cfg_t *cfg,
|
|
|
|
const struct vp9_extracfg *extra_cfg) {
|
|
|
|
oxcf->profile = cfg->g_profile;
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->width = cfg->g_w;
|
|
|
|
oxcf->height = cfg->g_h;
|
2014-04-05 02:30:16 +02:00
|
|
|
oxcf->bit_depth = extra_cfg->bit_depth;
|
2014-03-12 23:49:49 +01:00
|
|
|
// guess a frame rate if out of whack, use 30
|
|
|
|
oxcf->framerate = (double)cfg->g_timebase.den / cfg->g_timebase.num;
|
|
|
|
if (oxcf->framerate > 180)
|
2013-07-13 02:12:46 +02:00
|
|
|
oxcf->framerate = 30;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
switch (cfg->g_pass) {
|
2010-05-18 17:58:33 +02:00
|
|
|
case VPX_RC_ONE_PASS:
|
2014-04-14 23:09:39 +02:00
|
|
|
oxcf->mode = ONE_PASS_GOOD;
|
2014-08-08 23:27:34 +02:00
|
|
|
oxcf->pass = 0;
|
2012-07-14 00:21:29 +02:00
|
|
|
break;
|
2010-05-18 17:58:33 +02:00
|
|
|
case VPX_RC_FIRST_PASS:
|
2014-04-14 23:09:39 +02:00
|
|
|
oxcf->mode = TWO_PASS_FIRST;
|
2014-08-08 23:27:34 +02:00
|
|
|
oxcf->pass = 1;
|
2012-07-14 00:21:29 +02:00
|
|
|
break;
|
2010-05-18 17:58:33 +02:00
|
|
|
case VPX_RC_LAST_PASS:
|
2014-04-14 23:09:39 +02:00
|
|
|
oxcf->mode = TWO_PASS_SECOND_BEST;
|
2014-08-08 23:27:34 +02:00
|
|
|
oxcf->pass = 2;
|
2012-07-14 00:21:29 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->lag_in_frames = cfg->g_pass == VPX_RC_FIRST_PASS ? 0
|
|
|
|
: cfg->g_lag_in_frames;
|
2014-06-13 21:22:35 +02:00
|
|
|
oxcf->rc_mode = cfg->rc_end_usage;
|
2013-08-30 01:21:44 +02:00
|
|
|
|
2014-05-24 03:11:07 +02:00
|
|
|
// Convert target bandwidth from Kbit/s to Bit/s
|
|
|
|
oxcf->target_bandwidth = 1000 * cfg->rc_target_bitrate;
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->rc_max_intra_bitrate_pct = extra_cfg->rc_max_intra_bitrate_pct;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-06-03 21:52:49 +02:00
|
|
|
oxcf->best_allowed_q =
|
|
|
|
extra_cfg->lossless ? 0 : vp9_quantizer_to_qindex(cfg->rc_min_quantizer);
|
|
|
|
oxcf->worst_allowed_q =
|
|
|
|
extra_cfg->lossless ? 0 : vp9_quantizer_to_qindex(cfg->rc_max_quantizer);
|
2014-04-09 22:35:39 +02:00
|
|
|
oxcf->cq_level = vp9_quantizer_to_qindex(extra_cfg->cq_level);
|
2012-07-14 00:21:29 +02:00
|
|
|
oxcf->fixed_q = -1;
|
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->under_shoot_pct = cfg->rc_undershoot_pct;
|
|
|
|
oxcf->over_shoot_pct = cfg->rc_overshoot_pct;
|
|
|
|
|
2014-04-09 23:51:29 +02:00
|
|
|
oxcf->allow_spatial_resampling = cfg->rc_resize_allowed;
|
|
|
|
oxcf->scaled_frame_width = cfg->rc_scaled_width;
|
|
|
|
oxcf->scaled_frame_height = cfg->rc_scaled_height;
|
|
|
|
|
2014-06-03 22:56:46 +02:00
|
|
|
oxcf->maximum_buffer_size_ms = cfg->rc_buf_sz;
|
|
|
|
oxcf->starting_buffer_level_ms = cfg->rc_buf_initial_sz;
|
|
|
|
oxcf->optimal_buffer_level_ms = cfg->rc_buf_optimal_sz;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->drop_frames_water_mark = cfg->rc_dropframe_thresh;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->two_pass_vbrbias = cfg->rc_2pass_vbr_bias_pct;
|
|
|
|
oxcf->two_pass_vbrmin_section = cfg->rc_2pass_vbr_minsection_pct;
|
|
|
|
oxcf->two_pass_vbrmax_section = cfg->rc_2pass_vbr_maxsection_pct;
|
2013-12-18 00:45:30 +01:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->auto_key = cfg->kf_mode == VPX_KF_AUTO &&
|
|
|
|
cfg->kf_min_dist != cfg->kf_max_dist;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->key_freq = cfg->kf_max_dist;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-07-08 15:52:33 +02:00
|
|
|
oxcf->speed = abs(extra_cfg->cpu_used);
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->encode_breakout = extra_cfg->static_thresh;
|
|
|
|
oxcf->play_alternate = extra_cfg->enable_auto_alt_ref;
|
|
|
|
oxcf->noise_sensitivity = extra_cfg->noise_sensitivity;
|
|
|
|
oxcf->sharpness = extra_cfg->sharpness;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->two_pass_stats_in = cfg->rc_twopass_stats_in;
|
|
|
|
oxcf->output_pkt_list = extra_cfg->pkt_list;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-07-14 18:13:38 +02:00
|
|
|
#if CONFIG_FP_MB_STATS
|
|
|
|
oxcf->firstpass_mb_stats_in = cfg->rc_firstpass_mb_stats_in;
|
|
|
|
#endif
|
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->arnr_max_frames = extra_cfg->arnr_max_frames;
|
|
|
|
oxcf->arnr_strength = extra_cfg->arnr_strength;
|
2014-04-28 23:28:58 +02:00
|
|
|
oxcf->arnr_type = extra_cfg->arnr_type;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->tuning = extra_cfg->tuning;
|
2014-07-31 17:27:32 +02:00
|
|
|
oxcf->content = extra_cfg->content;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->tile_columns = extra_cfg->tile_columns;
|
|
|
|
oxcf->tile_rows = extra_cfg->tile_rows;
|
[WIP] Add column-based tiling.
This patch adds column-based tiling. The idea is to make each tile
independently decodable (after reading the common frame header) and
also independendly encodable (minus within-frame cost adjustments in
the RD loop) to speed-up hardware & software en/decoders if they used
multi-threading. Column-based tiling has the added advantage (over
other tiling methods) that it minimizes realtime use-case latency,
since all threads can start encoding data as soon as the first SB-row
worth of data is available to the encoder.
There is some test code that does random tile ordering in the decoder,
to confirm that each tile is indeed independently decodable from other
tiles in the same frame. At tile edges, all contexts assume default
values (i.e. 0, 0 motion vector, no coefficients, DC intra4x4 mode),
and motion vector search and ordering do not cross tiles in the same
frame.
t log
Tile independence is not maintained between frames ATM, i.e. tile 0 of
frame 1 is free to use motion vectors that point into any tile of frame
0. We support 1 (i.e. no tiling), 2 or 4 column-tiles.
The loopfilter crosses tile boundaries. I discussed this briefly with Aki
and he says that's OK. An in-loop loopfilter would need to do some sync
between tile threads, but that shouldn't be a big issue.
Resuls: with tiling disabled, we go up slightly because of improved edge
use in the intra4x4 prediction. With 2 tiles, we lose about ~1% on derf,
~0.35% on HD and ~0.55% on STD/HD. With 4 tiles, we lose another ~1.5%
on derf ~0.77% on HD and ~0.85% on STD/HD. Most of this loss is
concentrated in the low-bitrate end of clips, and most of it is because
of the loss of edges at tile boundaries and the resulting loss of intra
predictors.
TODO:
- more tiles (perhaps allow row-based tiling also, and max. 8 tiles)?
- maybe optionally (for EC purposes), motion vectors themselves
should not cross tile edges, or we should emulate such borders as
if they were off-frame, to limit error propagation to within one
tile only. This doesn't have to be the default behaviour but could
be an optional bitstream flag.
Change-Id: I5951c3a0742a767b20bc9fb5af685d9892c2c96f
2013-02-01 18:35:28 +01:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->error_resilient_mode = cfg->g_error_resilient;
|
|
|
|
oxcf->frame_parallel_decoding_mode = extra_cfg->frame_parallel_decoding_mode;
|
2013-09-05 17:55:47 +02:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->aq_mode = extra_cfg->aq_mode;
|
2013-11-14 19:23:57 +01:00
|
|
|
|
2014-04-04 00:49:03 +02:00
|
|
|
oxcf->frame_periodic_boost = extra_cfg->frame_periodic_boost;
|
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->ss_number_layers = cfg->ss_number_layers;
|
2014-02-06 18:23:17 +01:00
|
|
|
|
2014-02-26 22:30:50 +01:00
|
|
|
if (oxcf->ss_number_layers > 1) {
|
2014-05-24 03:11:07 +02:00
|
|
|
int i;
|
2014-07-14 20:24:17 +02:00
|
|
|
for (i = 0; i < VPX_SS_MAX_LAYERS; ++i) {
|
2014-05-24 03:11:07 +02:00
|
|
|
oxcf->ss_target_bitrate[i] = 1000 * cfg->ss_target_bitrate[i];
|
2014-07-22 19:05:40 +02:00
|
|
|
#if CONFIG_SPATIAL_SVC
|
2014-07-14 20:24:17 +02:00
|
|
|
oxcf->ss_play_alternate[i] = cfg->ss_enable_auto_alt_ref[i];
|
|
|
|
#endif
|
|
|
|
}
|
2014-02-26 22:30:50 +01:00
|
|
|
} else if (oxcf->ss_number_layers == 1) {
|
2014-03-03 16:30:13 +01:00
|
|
|
oxcf->ss_target_bitrate[0] = (int)oxcf->target_bandwidth;
|
2014-02-26 22:30:50 +01:00
|
|
|
}
|
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
oxcf->ts_number_layers = cfg->ts_number_layers;
|
2014-02-06 18:23:17 +01:00
|
|
|
|
|
|
|
if (oxcf->ts_number_layers > 1) {
|
2014-05-24 03:11:07 +02:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < VPX_TS_MAX_LAYERS; ++i) {
|
|
|
|
oxcf->ts_target_bitrate[i] = 1000 * cfg->ts_target_bitrate[i];
|
|
|
|
oxcf->ts_rate_decimator[i] = cfg->ts_rate_decimator[i];
|
|
|
|
}
|
2014-02-06 18:23:17 +01:00
|
|
|
} else if (oxcf->ts_number_layers == 1) {
|
2014-02-14 16:27:10 +01:00
|
|
|
oxcf->ts_target_bitrate[0] = (int)oxcf->target_bandwidth;
|
2014-02-06 18:23:17 +01:00
|
|
|
oxcf->ts_rate_decimator[0] = 1;
|
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
/*
|
2013-01-15 15:43:35 +01:00
|
|
|
printf("Current VP9 Settings: \n");
|
|
|
|
printf("target_bandwidth: %d\n", oxcf->target_bandwidth);
|
|
|
|
printf("noise_sensitivity: %d\n", oxcf->noise_sensitivity);
|
2014-01-08 23:19:14 +01:00
|
|
|
printf("sharpness: %d\n", oxcf->sharpness);
|
2013-01-15 15:43:35 +01:00
|
|
|
printf("cpu_used: %d\n", oxcf->cpu_used);
|
2014-01-08 23:33:59 +01:00
|
|
|
printf("Mode: %d\n", oxcf->mode);
|
2013-01-15 15:43:35 +01:00
|
|
|
printf("auto_key: %d\n", oxcf->auto_key);
|
|
|
|
printf("key_freq: %d\n", oxcf->key_freq);
|
|
|
|
printf("end_usage: %d\n", oxcf->end_usage);
|
|
|
|
printf("under_shoot_pct: %d\n", oxcf->under_shoot_pct);
|
|
|
|
printf("over_shoot_pct: %d\n", oxcf->over_shoot_pct);
|
|
|
|
printf("starting_buffer_level: %d\n", oxcf->starting_buffer_level);
|
|
|
|
printf("optimal_buffer_level: %d\n", oxcf->optimal_buffer_level);
|
|
|
|
printf("maximum_buffer_size: %d\n", oxcf->maximum_buffer_size);
|
|
|
|
printf("fixed_q: %d\n", oxcf->fixed_q);
|
|
|
|
printf("worst_allowed_q: %d\n", oxcf->worst_allowed_q);
|
|
|
|
printf("best_allowed_q: %d\n", oxcf->best_allowed_q);
|
2014-04-09 23:51:29 +02:00
|
|
|
printf("allow_spatial_resampling: %d\n", oxcf->allow_spatial_resampling);
|
|
|
|
printf("scaled_frame_width: %d\n", oxcf->scaled_frame_width);
|
|
|
|
printf("scaled_frame_height: %d\n", oxcf->scaled_frame_height);
|
2013-01-15 15:43:35 +01:00
|
|
|
printf("two_pass_vbrbias: %d\n", oxcf->two_pass_vbrbias);
|
|
|
|
printf("two_pass_vbrmin_section: %d\n", oxcf->two_pass_vbrmin_section);
|
|
|
|
printf("two_pass_vbrmax_section: %d\n", oxcf->two_pass_vbrmax_section);
|
|
|
|
printf("lag_in_frames: %d\n", oxcf->lag_in_frames);
|
|
|
|
printf("play_alternate: %d\n", oxcf->play_alternate);
|
|
|
|
printf("Version: %d\n", oxcf->Version);
|
|
|
|
printf("encode_breakout: %d\n", oxcf->encode_breakout);
|
|
|
|
printf("error resilient: %d\n", oxcf->error_resilient_mode);
|
2013-01-25 20:30:28 +01:00
|
|
|
printf("frame parallel detokenization: %d\n",
|
|
|
|
oxcf->frame_parallel_decoding_mode);
|
2012-07-14 00:21:29 +02:00
|
|
|
*/
|
|
|
|
return VPX_CODEC_OK;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t encoder_set_config(vpx_codec_alg_priv_t *ctx,
|
|
|
|
const vpx_codec_enc_cfg_t *cfg) {
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_codec_err_t res;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
if (cfg->g_w != ctx->cfg.g_w || cfg->g_h != ctx->cfg.g_h)
|
2012-07-14 00:21:29 +02:00
|
|
|
ERROR("Cannot change width or height after initialization");
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
// Prevent increasing lag_in_frames. This check is stricter than it needs
|
|
|
|
// to be -- the limit is not increasing past the first lag_in_frames
|
|
|
|
// value, but we don't track the initial config, only the last successful
|
|
|
|
// config.
|
|
|
|
if (cfg->g_lag_in_frames > ctx->cfg.g_lag_in_frames)
|
2012-07-14 00:21:29 +02:00
|
|
|
ERROR("Cannot increase lag_in_frames");
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
res = validate_config(ctx, cfg, &ctx->extra_cfg);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-02-05 18:45:13 +01:00
|
|
|
if (res == VPX_CODEC_OK) {
|
2012-07-14 00:21:29 +02:00
|
|
|
ctx->cfg = *cfg;
|
2014-04-07 19:38:51 +02:00
|
|
|
set_encoder_config(&ctx->oxcf, &ctx->cfg, &ctx->extra_cfg);
|
2012-10-30 20:58:42 +01:00
|
|
|
vp9_change_config(ctx->cpi, &ctx->oxcf);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return res;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-05-28 01:45:58 +02:00
|
|
|
static vpx_codec_err_t ctrl_get_quantizer(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
int *const arg = va_arg(args, int *);
|
|
|
|
if (arg == NULL)
|
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
|
|
|
*arg = vp9_get_quantizer(ctx->cpi);
|
|
|
|
return VPX_CODEC_OK;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-05-28 01:45:58 +02:00
|
|
|
static vpx_codec_err_t ctrl_get_quantizer64(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
int *const arg = va_arg(args, int *);
|
2014-04-02 02:14:55 +02:00
|
|
|
if (arg == NULL)
|
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
2014-05-28 01:45:58 +02:00
|
|
|
*arg = vp9_qindex_to_quantizer(vp9_get_quantizer(ctx->cpi));
|
|
|
|
return VPX_CODEC_OK;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-05-28 01:45:58 +02:00
|
|
|
static vpx_codec_err_t update_extra_cfg(vpx_codec_alg_priv_t *ctx,
|
|
|
|
const struct vp9_extracfg *extra_cfg) {
|
|
|
|
const vpx_codec_err_t res = validate_config(ctx, &ctx->cfg, extra_cfg);
|
|
|
|
if (res == VPX_CODEC_OK) {
|
|
|
|
ctx->extra_cfg = *extra_cfg;
|
|
|
|
set_encoder_config(&ctx->oxcf, &ctx->cfg, &ctx->extra_cfg);
|
|
|
|
vp9_change_config(ctx->cpi, &ctx->oxcf);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2014-05-28 01:45:58 +02:00
|
|
|
return res;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-05-28 01:45:58 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_cpuused(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.cpu_used = CAST(VP8E_SET_CPUUSED, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-05-28 01:45:58 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_enable_auto_alt_ref(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.enable_auto_alt_ref = CAST(VP8E_SET_ENABLEAUTOALTREF, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-05-28 01:45:58 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_noise_sensitivity(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
2014-03-12 23:49:49 +01:00
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
2014-05-28 01:45:58 +02:00
|
|
|
extra_cfg.noise_sensitivity = CAST(VP8E_SET_NOISE_SENSITIVITY, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-05-28 01:45:58 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_sharpness(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.sharpness = CAST(VP8E_SET_SHARPNESS, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-05-28 01:45:58 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_static_thresh(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.static_thresh = CAST(VP8E_SET_STATIC_THRESHOLD, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-05-28 01:45:58 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_tile_columns(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.tile_columns = CAST(VP9E_SET_TILE_COLUMNS, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-05-28 01:45:58 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_tile_rows(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.tile_rows = CAST(VP9E_SET_TILE_ROWS, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static vpx_codec_err_t ctrl_set_arnr_max_frames(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.arnr_max_frames = CAST(VP8E_SET_ARNR_MAXFRAMES, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static vpx_codec_err_t ctrl_set_arnr_strength(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.arnr_strength = CAST(VP8E_SET_ARNR_STRENGTH, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static vpx_codec_err_t ctrl_set_arnr_type(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.arnr_type = CAST(VP8E_SET_ARNR_TYPE, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static vpx_codec_err_t ctrl_set_tuning(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.tuning = CAST(VP8E_SET_TUNING, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static vpx_codec_err_t ctrl_set_cq_level(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.cq_level = CAST(VP8E_SET_CQ_LEVEL, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static vpx_codec_err_t ctrl_set_rc_max_intra_bitrate_pct(
|
|
|
|
vpx_codec_alg_priv_t *ctx, va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.rc_max_intra_bitrate_pct =
|
|
|
|
CAST(VP8E_SET_MAX_INTRA_BITRATE_PCT, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static vpx_codec_err_t ctrl_set_lossless(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.lossless = CAST(VP9E_SET_LOSSLESS, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static vpx_codec_err_t ctrl_set_frame_parallel_decoding_mode(
|
|
|
|
vpx_codec_alg_priv_t *ctx, va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.frame_parallel_decoding_mode =
|
|
|
|
CAST(VP9E_SET_FRAME_PARALLEL_DECODING, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static vpx_codec_err_t ctrl_set_aq_mode(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
|
|
|
extra_cfg.aq_mode = CAST(VP9E_SET_AQ_MODE, 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;
|
|
|
|
extra_cfg.frame_periodic_boost = CAST(VP9E_SET_FRAME_PERIODIC_BOOST, args);
|
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2010-06-01 17:14:25 +02:00
|
|
|
|
2014-04-19 03:17:43 +02:00
|
|
|
static vpx_codec_err_t encoder_init(vpx_codec_ctx_t *ctx,
|
|
|
|
vpx_codec_priv_enc_mr_cfg_t *data) {
|
2014-04-02 02:14:55 +02:00
|
|
|
vpx_codec_err_t res = VPX_CODEC_OK;
|
2014-05-14 21:11:51 +02:00
|
|
|
(void)data;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-02-05 18:45:13 +01:00
|
|
|
if (ctx->priv == NULL) {
|
2014-04-02 02:14:55 +02:00
|
|
|
int i;
|
|
|
|
vpx_codec_enc_cfg_t *cfg;
|
|
|
|
struct vpx_codec_alg_priv *priv = calloc(1, sizeof(*priv));
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-19 03:17:43 +02:00
|
|
|
if (priv == NULL)
|
|
|
|
return VPX_CODEC_MEM_ERROR;
|
2011-02-22 14:02:05 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
ctx->priv = &priv->base;
|
|
|
|
ctx->priv->sz = sizeof(*ctx->priv);
|
|
|
|
ctx->priv->iface = ctx->iface;
|
|
|
|
ctx->priv->alg_priv = priv;
|
|
|
|
ctx->priv->init_flags = ctx->init_flags;
|
2012-11-05 21:37:14 +01:00
|
|
|
ctx->priv->enc.total_encoders = 1;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
if (ctx->config.enc) {
|
2014-04-19 03:17:43 +02:00
|
|
|
// Update the reference to the config structure to an internal copy.
|
2012-07-14 00:21:29 +02:00
|
|
|
ctx->priv->alg_priv->cfg = *ctx->config.enc;
|
|
|
|
ctx->config.enc = &ctx->priv->alg_priv->cfg;
|
|
|
|
}
|
2011-02-22 14:02:05 +01:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
cfg = &ctx->priv->alg_priv->cfg;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
// Select the extra vp6 configuration table based on the current
|
|
|
|
// usage value. If the current usage value isn't found, use the
|
|
|
|
// values for usage case 0.
|
2012-07-14 00:21:29 +02:00
|
|
|
for (i = 0;
|
|
|
|
extracfg_map[i].usage && extracfg_map[i].usage != cfg->g_usage;
|
2014-04-02 02:14:55 +02:00
|
|
|
++i) {}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
priv->extra_cfg = extracfg_map[i].cfg;
|
|
|
|
priv->extra_cfg.pkt_list = &priv->pkt_list.head;
|
2014-07-14 18:13:38 +02:00
|
|
|
|
2012-10-30 22:25:33 +01:00
|
|
|
vp9_initialize_enc();
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-03-12 23:49:49 +01:00
|
|
|
res = validate_config(priv, &priv->cfg, &priv->extra_cfg);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-02-05 18:45:13 +01:00
|
|
|
if (res == VPX_CODEC_OK) {
|
2014-03-04 01:50:16 +01:00
|
|
|
VP9_COMP *cpi;
|
2014-04-07 19:38:51 +02:00
|
|
|
set_encoder_config(&ctx->priv->alg_priv->oxcf,
|
2014-04-19 03:17:43 +02:00
|
|
|
&ctx->priv->alg_priv->cfg,
|
|
|
|
&ctx->priv->alg_priv->extra_cfg);
|
2014-03-04 01:50:16 +01:00
|
|
|
cpi = vp9_create_compressor(&ctx->priv->alg_priv->oxcf);
|
|
|
|
if (cpi == NULL)
|
2012-07-14 00:21:29 +02:00
|
|
|
res = VPX_CODEC_MEM_ERROR;
|
|
|
|
else
|
2014-03-04 01:50:16 +01:00
|
|
|
ctx->priv->alg_priv->cpi = cpi;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return res;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t encoder_destroy(vpx_codec_alg_priv_t *ctx) {
|
2012-07-14 00:21:29 +02:00
|
|
|
free(ctx->cx_data);
|
2014-03-04 01:50:16 +01:00
|
|
|
vp9_remove_compressor(ctx->cpi);
|
2012-07-14 00:21:29 +02:00
|
|
|
free(ctx);
|
|
|
|
return VPX_CODEC_OK;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pick_quickcompress_mode(vpx_codec_alg_priv_t *ctx,
|
2014-03-11 02:33:08 +01:00
|
|
|
unsigned long duration,
|
|
|
|
unsigned long deadline) {
|
|
|
|
// Use best quality mode if no deadline is given.
|
2014-04-14 23:09:39 +02:00
|
|
|
MODE new_qc = ONE_PASS_BEST;
|
2014-01-29 17:39:39 +01:00
|
|
|
|
|
|
|
if (deadline) {
|
2014-03-11 02:33:08 +01:00
|
|
|
// Convert duration parameter from stream timebase to microseconds
|
|
|
|
const uint64_t duration_us = (uint64_t)duration * 1000000 *
|
|
|
|
(uint64_t)ctx->cfg.g_timebase.num /
|
|
|
|
(uint64_t)ctx->cfg.g_timebase.den;
|
|
|
|
|
|
|
|
// If the deadline is more that the duration this frame is to be shown,
|
|
|
|
// use good quality mode. Otherwise use realtime mode.
|
2014-04-14 23:09:39 +02:00
|
|
|
new_qc = (deadline > duration_us) ? ONE_PASS_GOOD : REALTIME;
|
2014-01-29 17:39:39 +01:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
|
|
|
|
if (ctx->cfg.g_pass == VPX_RC_FIRST_PASS)
|
2014-04-14 23:09:39 +02:00
|
|
|
new_qc = TWO_PASS_FIRST;
|
2012-07-14 00:21:29 +02:00
|
|
|
else if (ctx->cfg.g_pass == VPX_RC_LAST_PASS)
|
2014-04-14 23:09:39 +02:00
|
|
|
new_qc = (new_qc == ONE_PASS_BEST) ? TWO_PASS_SECOND_BEST
|
|
|
|
: TWO_PASS_SECOND_GOOD;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-01-08 23:33:59 +01:00
|
|
|
if (ctx->oxcf.mode != new_qc) {
|
|
|
|
ctx->oxcf.mode = new_qc;
|
2012-10-30 20:58:42 +01:00
|
|
|
vp9_change_config(ctx->cpi, &ctx->oxcf);
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-04 23:38:29 +02:00
|
|
|
// Turn on to test if supplemental superframe data breaks decoding
|
|
|
|
// #define TEST_SUPPLEMENTAL_SUPERFRAME_DATA
|
2013-03-13 00:33:38 +01:00
|
|
|
static int write_superframe_index(vpx_codec_alg_priv_t *ctx) {
|
2013-03-05 21:23:34 +01:00
|
|
|
uint8_t marker = 0xc0;
|
2013-09-17 18:45:13 +02:00
|
|
|
unsigned int mask;
|
|
|
|
int mag, index_sz;
|
2013-03-05 21:23:34 +01:00
|
|
|
|
|
|
|
assert(ctx->pending_frame_count);
|
|
|
|
assert(ctx->pending_frame_count <= 8);
|
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
// Add the number of frames to the marker byte
|
2013-03-05 21:23:34 +01:00
|
|
|
marker |= ctx->pending_frame_count - 1;
|
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
// Choose the magnitude
|
2013-03-05 21:23:34 +01:00
|
|
|
for (mag = 0, mask = 0xff; mag < 4; mag++) {
|
|
|
|
if (ctx->pending_frame_magnitude < mask)
|
|
|
|
break;
|
|
|
|
mask <<= 8;
|
|
|
|
mask |= 0xff;
|
|
|
|
}
|
|
|
|
marker |= mag << 3;
|
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
// Write the index
|
2013-03-05 21:23:34 +01:00
|
|
|
index_sz = 2 + (mag + 1) * ctx->pending_frame_count;
|
|
|
|
if (ctx->pending_cx_data_sz + index_sz < ctx->cx_data_sz) {
|
|
|
|
uint8_t *x = ctx->pending_cx_data + ctx->pending_cx_data_sz;
|
|
|
|
int i, j;
|
2014-04-04 23:38:29 +02:00
|
|
|
#ifdef TEST_SUPPLEMENTAL_SUPERFRAME_DATA
|
|
|
|
uint8_t marker_test = 0xc0;
|
|
|
|
int mag_test = 2; // 1 - 4
|
|
|
|
int frames_test = 4; // 1 - 8
|
|
|
|
int index_sz_test = 2 + mag_test * frames_test;
|
|
|
|
marker_test |= frames_test - 1;
|
|
|
|
marker_test |= (mag_test - 1) << 3;
|
|
|
|
*x++ = marker_test;
|
|
|
|
for (i = 0; i < mag_test * frames_test; ++i)
|
|
|
|
*x++ = 0; // fill up with arbitrary data
|
|
|
|
*x++ = marker_test;
|
|
|
|
ctx->pending_cx_data_sz += index_sz_test;
|
|
|
|
printf("Added supplemental superframe data\n");
|
|
|
|
#endif
|
2013-03-05 21:23:34 +01:00
|
|
|
|
|
|
|
*x++ = marker;
|
|
|
|
for (i = 0; i < ctx->pending_frame_count; i++) {
|
2014-02-14 16:27:10 +01:00
|
|
|
unsigned int this_sz = (unsigned int)ctx->pending_frame_sizes[i];
|
2013-03-05 21:23:34 +01:00
|
|
|
|
|
|
|
for (j = 0; j <= mag; j++) {
|
|
|
|
*x++ = this_sz & 0xff;
|
|
|
|
this_sz >>= 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*x++ = marker;
|
|
|
|
ctx->pending_cx_data_sz += index_sz;
|
2014-04-04 23:38:29 +02:00
|
|
|
#ifdef TEST_SUPPLEMENTAL_SUPERFRAME_DATA
|
|
|
|
index_sz += index_sz_test;
|
|
|
|
#endif
|
2013-03-05 21:23:34 +01:00
|
|
|
}
|
2013-03-13 00:33:38 +01:00
|
|
|
return index_sz;
|
2013-03-05 21:23:34 +01:00
|
|
|
}
|
|
|
|
|
2014-08-06 23:58:53 +02:00
|
|
|
// vp9 uses 10,000,000 ticks/second as time stamp
|
|
|
|
#define TICKS_PER_SEC 10000000
|
|
|
|
|
|
|
|
static int64_t timebase_units_to_ticks(const vpx_rational_t *timebase,
|
|
|
|
int64_t n) {
|
|
|
|
return n * TICKS_PER_SEC * timebase->num / timebase->den;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t ticks_to_timebase_units(const vpx_rational_t *timebase,
|
|
|
|
int64_t n) {
|
|
|
|
const int64_t round = TICKS_PER_SEC * timebase->num / 2 - 1;
|
|
|
|
return (n * timebase->den + round) / timebase->num / TICKS_PER_SEC;
|
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t encoder_encode(vpx_codec_alg_priv_t *ctx,
|
|
|
|
const vpx_image_t *img,
|
|
|
|
vpx_codec_pts_t pts,
|
|
|
|
unsigned long duration,
|
|
|
|
vpx_enc_frame_flags_t flags,
|
|
|
|
unsigned long deadline) {
|
2012-07-14 00:21:29 +02:00
|
|
|
vpx_codec_err_t res = VPX_CODEC_OK;
|
2014-08-06 23:58:53 +02:00
|
|
|
const vpx_rational_t *const timebase = &ctx->cfg.g_timebase;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-07-22 03:27:58 +02:00
|
|
|
if (img != NULL) {
|
2012-07-14 00:21:29 +02:00
|
|
|
res = validate_img(ctx, img);
|
2014-07-22 03:27:58 +02:00
|
|
|
// TODO(jzern) the checks related to cpi's validity should be treated as a
|
|
|
|
// failure condition, encoder setup is done fully in init() currently.
|
|
|
|
if (res == VPX_CODEC_OK && ctx->cpi != NULL && ctx->cx_data == NULL) {
|
|
|
|
// There's no codec control for multiple alt-refs so check the encoder
|
|
|
|
// instance for its status to determine the compressed data size.
|
|
|
|
ctx->cx_data_sz = ctx->cfg.g_w * ctx->cfg.g_h *
|
|
|
|
get_image_bps(img) / 8 *
|
|
|
|
(ctx->cpi->multi_arf_allowed ? 8 : 2);
|
|
|
|
if (ctx->cx_data_sz < 4096) ctx->cx_data_sz = 4096;
|
|
|
|
|
|
|
|
ctx->cx_data = (unsigned char *)malloc(ctx->cx_data_sz);
|
|
|
|
if (ctx->cx_data == NULL) {
|
|
|
|
return VPX_CODEC_MEM_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
pick_quickcompress_mode(ctx, duration, deadline);
|
|
|
|
vpx_codec_pkt_list_init(&ctx->pkt_list);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
// Handle Flags
|
|
|
|
if (((flags & VP8_EFLAG_NO_UPD_GF) && (flags & VP8_EFLAG_FORCE_GF)) ||
|
|
|
|
((flags & VP8_EFLAG_NO_UPD_ARF) && (flags & VP8_EFLAG_FORCE_ARF))) {
|
2012-07-14 00:21:29 +02:00
|
|
|
ctx->base.err_detail = "Conflicting flags.";
|
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-06-24 23:01:17 +02:00
|
|
|
vp9_apply_encoding_flags(ctx->cpi, flags);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
// Handle fixed keyframe intervals
|
|
|
|
if (ctx->cfg.kf_mode == VPX_KF_AUTO &&
|
|
|
|
ctx->cfg.kf_min_dist == ctx->cfg.kf_max_dist) {
|
2012-07-14 00:21:29 +02:00
|
|
|
if (++ctx->fixed_kf_cntr > ctx->cfg.kf_min_dist) {
|
|
|
|
flags |= VPX_EFLAG_FORCE_KF;
|
|
|
|
ctx->fixed_kf_cntr = 1;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
// Initialize the encoder instance on the first frame.
|
2014-02-05 18:45:13 +01:00
|
|
|
if (res == VPX_CODEC_OK && ctx->cpi != NULL) {
|
2014-06-24 23:01:17 +02:00
|
|
|
unsigned int lib_flags = 0;
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG sd;
|
2014-08-06 23:58:53 +02:00
|
|
|
int64_t dst_time_stamp = timebase_units_to_ticks(timebase, pts);
|
|
|
|
int64_t dst_end_time_stamp =
|
|
|
|
timebase_units_to_ticks(timebase, pts + duration);
|
2013-12-06 02:20:01 +01:00
|
|
|
size_t size, cx_data_sz;
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned char *cx_data;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
// Set up internal flags
|
2012-07-14 00:21:29 +02:00
|
|
|
if (ctx->base.init_flags & VPX_CODEC_USE_PSNR)
|
2012-10-31 01:53:32 +01:00
|
|
|
((VP9_COMP *)ctx->cpi)->b_calculate_psnr = 1;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (img != NULL) {
|
|
|
|
res = image2yuvconfig(img, &sd);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-06-24 23:01:17 +02:00
|
|
|
// Store the original flags in to the frame buffer. Will extract the
|
|
|
|
// key frame flag when we actually encode this frame.
|
|
|
|
if (vp9_receive_raw_frame(ctx->cpi, flags,
|
2012-07-14 00:21:29 +02:00
|
|
|
&sd, dst_time_stamp, dst_end_time_stamp)) {
|
2012-10-31 01:53:32 +01:00
|
|
|
VP9_COMP *cpi = (VP9_COMP *)ctx->cpi;
|
2012-07-14 00:21:29 +02:00
|
|
|
res = update_error_state(ctx, &cpi->common.error);
|
|
|
|
}
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-11-15 21:19:07 +01:00
|
|
|
cx_data = ctx->cx_data;
|
|
|
|
cx_data_sz = ctx->cx_data_sz;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2012-11-15 21:19:07 +01:00
|
|
|
/* Any pending invisible frames? */
|
|
|
|
if (ctx->pending_cx_data) {
|
|
|
|
memmove(cx_data, ctx->pending_cx_data, ctx->pending_cx_data_sz);
|
|
|
|
ctx->pending_cx_data = cx_data;
|
|
|
|
cx_data += ctx->pending_cx_data_sz;
|
|
|
|
cx_data_sz -= ctx->pending_cx_data_sz;
|
|
|
|
|
|
|
|
/* TODO: this is a minimal check, the underlying codec doesn't respect
|
|
|
|
* the buffer size anyway.
|
|
|
|
*/
|
|
|
|
if (cx_data_sz < ctx->cx_data_sz / 2) {
|
|
|
|
ctx->base.err_detail = "Compressed data buffer too small";
|
|
|
|
return VPX_CODEC_ERROR;
|
|
|
|
}
|
2012-10-29 23:57:44 +01:00
|
|
|
}
|
|
|
|
|
2012-10-30 22:25:33 +01:00
|
|
|
while (cx_data_sz >= ctx->cx_data_sz / 2 &&
|
|
|
|
-1 != vp9_get_compressed_data(ctx->cpi, &lib_flags, &size,
|
|
|
|
cx_data, &dst_time_stamp,
|
|
|
|
&dst_end_time_stamp, !img)) {
|
2012-07-14 00:21:29 +02:00
|
|
|
if (size) {
|
2014-04-02 02:14:55 +02:00
|
|
|
VP9_COMP *const cpi = (VP9_COMP *)ctx->cpi;
|
2014-08-06 23:58:53 +02:00
|
|
|
vpx_codec_cx_pkt_t pkt;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-07-22 19:05:40 +02:00
|
|
|
#if CONFIG_SPATIAL_SVC
|
2014-08-07 00:20:51 +02:00
|
|
|
if (is_spatial_svc(cpi))
|
2014-07-14 20:24:17 +02:00
|
|
|
cpi->svc.layer_context[cpi->svc.spatial_layer_id].layer_size += size;
|
|
|
|
#endif
|
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
// Pack invisible frames with the next visible frame
|
2014-06-24 23:01:17 +02:00
|
|
|
if (cpi->common.show_frame == 0
|
2014-07-22 19:05:40 +02:00
|
|
|
#if CONFIG_SPATIAL_SVC
|
2014-08-07 00:20:51 +02:00
|
|
|
|| (is_spatial_svc(cpi) &&
|
2014-06-24 23:01:17 +02:00
|
|
|
cpi->svc.spatial_layer_id < cpi->svc.number_spatial_layers - 1)
|
|
|
|
#endif
|
|
|
|
) {
|
2014-02-05 18:45:13 +01:00
|
|
|
if (ctx->pending_cx_data == 0)
|
2012-11-15 21:19:07 +01:00
|
|
|
ctx->pending_cx_data = cx_data;
|
|
|
|
ctx->pending_cx_data_sz += size;
|
2013-03-05 21:23:34 +01:00
|
|
|
ctx->pending_frame_sizes[ctx->pending_frame_count++] = size;
|
|
|
|
ctx->pending_frame_magnitude |= size;
|
2012-10-29 23:57:44 +01:00
|
|
|
cx_data += size;
|
|
|
|
cx_data_sz -= size;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
// Add the frame packet to the list of returned packets.
|
2012-07-14 00:21:29 +02:00
|
|
|
pkt.kind = VPX_CODEC_CX_FRAME_PKT;
|
2014-08-06 23:58:53 +02:00
|
|
|
pkt.data.frame.pts = ticks_to_timebase_units(timebase, dst_time_stamp);
|
|
|
|
pkt.data.frame.duration =
|
|
|
|
(unsigned long)ticks_to_timebase_units(timebase,
|
|
|
|
dst_end_time_stamp - dst_time_stamp);
|
2012-07-14 00:21:29 +02:00
|
|
|
pkt.data.frame.flags = lib_flags << 16;
|
|
|
|
|
2014-06-24 23:01:17 +02:00
|
|
|
if (lib_flags & FRAMEFLAGS_KEY
|
2014-07-22 19:05:40 +02:00
|
|
|
#if CONFIG_SPATIAL_SVC
|
2014-08-07 00:20:51 +02:00
|
|
|
|| (is_spatial_svc(cpi) &&
|
2014-06-24 23:01:17 +02:00
|
|
|
cpi->svc.layer_context[0].is_key_frame)
|
|
|
|
#endif
|
|
|
|
)
|
2012-07-14 00:21:29 +02:00
|
|
|
pkt.data.frame.flags |= VPX_FRAME_IS_KEY;
|
|
|
|
|
2014-02-05 18:45:13 +01:00
|
|
|
if (cpi->common.show_frame == 0) {
|
2012-07-14 00:21:29 +02:00
|
|
|
pkt.data.frame.flags |= VPX_FRAME_IS_INVISIBLE;
|
|
|
|
|
|
|
|
// This timestamp should be as close as possible to the
|
|
|
|
// prior PTS so that if a decoder uses pts to schedule when
|
|
|
|
// to do this, we start right after last frame was decoded.
|
|
|
|
// Invisible frames have no duration.
|
2014-08-06 23:58:53 +02:00
|
|
|
pkt.data.frame.pts =
|
|
|
|
ticks_to_timebase_units(timebase, cpi->last_time_stamp_seen) + 1;
|
2012-07-14 00:21:29 +02:00
|
|
|
pkt.data.frame.duration = 0;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (cpi->droppable)
|
|
|
|
pkt.data.frame.flags |= VPX_FRAME_IS_DROPPABLE;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-03-22 00:10:51 +01:00
|
|
|
if (ctx->pending_cx_data) {
|
|
|
|
ctx->pending_frame_sizes[ctx->pending_frame_count++] = size;
|
|
|
|
ctx->pending_frame_magnitude |= size;
|
|
|
|
ctx->pending_cx_data_sz += size;
|
|
|
|
size += write_superframe_index(ctx);
|
|
|
|
pkt.data.frame.buf = ctx->pending_cx_data;
|
|
|
|
pkt.data.frame.sz = ctx->pending_cx_data_sz;
|
|
|
|
ctx->pending_cx_data = NULL;
|
|
|
|
ctx->pending_cx_data_sz = 0;
|
|
|
|
ctx->pending_frame_count = 0;
|
|
|
|
ctx->pending_frame_magnitude = 0;
|
|
|
|
} else {
|
|
|
|
pkt.data.frame.buf = cx_data;
|
|
|
|
pkt.data.frame.sz = size;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2014-03-22 00:10:51 +01:00
|
|
|
pkt.data.frame.partition_id = -1;
|
|
|
|
vpx_codec_pkt_list_add(&ctx->pkt_list.head, &pkt);
|
|
|
|
cx_data += size;
|
|
|
|
cx_data_sz -= size;
|
2014-07-22 19:05:40 +02:00
|
|
|
#if CONFIG_SPATIAL_SVC
|
2014-08-07 00:20:51 +02:00
|
|
|
if (is_spatial_svc(cpi)) {
|
2014-07-14 20:24:17 +02:00
|
|
|
vpx_codec_cx_pkt_t pkt = {0};
|
|
|
|
int i;
|
|
|
|
pkt.kind = VPX_CODEC_SPATIAL_SVC_LAYER_SIZES;
|
|
|
|
for (i = 0; i < cpi->svc.number_spatial_layers; ++i) {
|
|
|
|
pkt.data.layer_sizes[i] = cpi->svc.layer_context[i].layer_size;
|
|
|
|
cpi->svc.layer_context[i].layer_size = 0;
|
|
|
|
}
|
|
|
|
vpx_codec_pkt_list_add(&ctx->pkt_list.head, &pkt);
|
|
|
|
}
|
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
return res;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-05-14 21:11:51 +02:00
|
|
|
static const vpx_codec_cx_pkt_t *encoder_get_cxdata(vpx_codec_alg_priv_t *ctx,
|
2014-04-07 19:38:51 +02:00
|
|
|
vpx_codec_iter_t *iter) {
|
2012-07-14 00:21:29 +02:00
|
|
|
return vpx_codec_pkt_list_get(&ctx->pkt_list.head, iter);
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_reference(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2014-04-02 02:14:55 +02:00
|
|
|
vpx_ref_frame_t *const frame = va_arg(args, vpx_ref_frame_t *);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-02-05 18:47:14 +01:00
|
|
|
if (frame != NULL) {
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG sd;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
image2yuvconfig(&frame->img, &sd);
|
2013-09-06 19:13:35 +02:00
|
|
|
vp9_set_reference_enc(ctx->cpi, ref_frame_to_vp9_reframe(frame->frame_type),
|
|
|
|
&sd);
|
2012-07-14 00:21:29 +02:00
|
|
|
return VPX_CODEC_OK;
|
2013-10-05 02:16:20 +02:00
|
|
|
} else {
|
2012-07-14 00:21:29 +02:00
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
2013-10-05 02:16:20 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_copy_reference(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2014-04-02 02:14:55 +02:00
|
|
|
vpx_ref_frame_t *const frame = va_arg(args, vpx_ref_frame_t *);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-02-05 18:47:14 +01:00
|
|
|
if (frame != NULL) {
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG sd;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
image2yuvconfig(&frame->img, &sd);
|
2013-09-06 19:13:35 +02:00
|
|
|
vp9_copy_reference_enc(ctx->cpi,
|
|
|
|
ref_frame_to_vp9_reframe(frame->frame_type), &sd);
|
2012-07-14 00:21:29 +02:00
|
|
|
return VPX_CODEC_OK;
|
2013-10-05 02:16:20 +02:00
|
|
|
} else {
|
2012-07-14 00:21:29 +02:00
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
2013-10-05 02:16:20 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_get_reference(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2014-05-14 21:11:51 +02:00
|
|
|
vp9_ref_frame_t *const frame = va_arg(args, vp9_ref_frame_t *);
|
2013-03-13 20:15:43 +01:00
|
|
|
|
2014-02-05 18:47:14 +01:00
|
|
|
if (frame != NULL) {
|
2014-08-08 17:59:05 +02:00
|
|
|
YV12_BUFFER_CONFIG *fb = get_ref_frame(&ctx->cpi->common, frame->idx);
|
|
|
|
if (fb == NULL) return VPX_CODEC_ERROR;
|
2013-03-13 20:15:43 +01:00
|
|
|
|
2014-02-05 18:47:14 +01:00
|
|
|
yuvconfig2image(&frame->img, fb, NULL);
|
2013-03-13 20:15:43 +01:00
|
|
|
return VPX_CODEC_OK;
|
|
|
|
} else {
|
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_previewpp(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2013-09-04 19:02:08 +02:00
|
|
|
#if CONFIG_VP9_POSTPROC
|
2014-02-05 18:47:14 +01:00
|
|
|
vp8_postproc_cfg_t *config = va_arg(args, vp8_postproc_cfg_t *);
|
|
|
|
if (config != NULL) {
|
|
|
|
ctx->preview_ppcfg = *config;
|
2012-07-14 00:21:29 +02:00
|
|
|
return VPX_CODEC_OK;
|
2013-10-05 02:16:20 +02:00
|
|
|
} else {
|
2012-07-14 00:21:29 +02:00
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
2013-10-05 02:16:20 +02:00
|
|
|
}
|
2010-08-20 22:06:56 +02:00
|
|
|
#else
|
2012-07-14 00:21:29 +02:00
|
|
|
(void)ctx;
|
|
|
|
(void)args;
|
|
|
|
return VPX_CODEC_INCAPABLE;
|
2010-08-20 22:06:56 +02:00
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_image_t *encoder_get_preview(vpx_codec_alg_priv_t *ctx) {
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG sd;
|
2014-05-14 21:11:51 +02:00
|
|
|
vp9_ppflags_t flags;
|
|
|
|
vp9_zero(flags);
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
if (ctx->preview_ppcfg.post_proc_flag) {
|
2014-04-02 02:14:55 +02:00
|
|
|
flags.post_proc_flag = ctx->preview_ppcfg.post_proc_flag;
|
|
|
|
flags.deblocking_level = ctx->preview_ppcfg.deblocking_level;
|
|
|
|
flags.noise_level = ctx->preview_ppcfg.noise_level;
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
2010-11-05 00:03:36 +01:00
|
|
|
|
2014-03-13 00:57:15 +01:00
|
|
|
if (vp9_get_preview_raw_frame(ctx->cpi, &sd, &flags) == 0) {
|
2013-05-07 00:52:06 +02:00
|
|
|
yuvconfig2image(&ctx->preview_img, &sd, NULL);
|
2012-07-14 00:21:29 +02:00
|
|
|
return &ctx->preview_img;
|
2013-10-05 02:16:20 +02:00
|
|
|
} else {
|
2012-07-14 00:21:29 +02:00
|
|
|
return NULL;
|
2013-10-05 02:16:20 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_update_entropy(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2014-03-13 00:57:15 +01:00
|
|
|
const int update = va_arg(args, int);
|
2014-05-14 21:11:51 +02:00
|
|
|
|
2012-10-30 20:58:42 +01:00
|
|
|
vp9_update_entropy(ctx->cpi, update);
|
2012-07-14 00:21:29 +02:00
|
|
|
return VPX_CODEC_OK;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_update_reference(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2014-03-18 19:49:23 +01:00
|
|
|
const int ref_frame_flags = va_arg(args, int);
|
2014-05-14 21:11:51 +02:00
|
|
|
|
2014-03-18 19:49:23 +01:00
|
|
|
vp9_update_reference(ctx->cpi, ref_frame_flags);
|
2012-07-14 00:21:29 +02:00
|
|
|
return VPX_CODEC_OK;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_use_reference(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2014-03-13 00:57:15 +01:00
|
|
|
const int reference_flag = va_arg(args, int);
|
2014-05-14 21:11:51 +02:00
|
|
|
|
2012-10-30 20:58:42 +01:00
|
|
|
vp9_use_as_reference(ctx->cpi, reference_flag);
|
2012-07-14 00:21:29 +02:00
|
|
|
return VPX_CODEC_OK;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_roi_map(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2014-05-14 21:11:51 +02:00
|
|
|
(void)ctx;
|
|
|
|
(void)args;
|
|
|
|
|
2013-10-24 01:57:25 +02:00
|
|
|
// TODO(yaowu): Need to re-implement and test for VP9.
|
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_active_map(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2014-03-13 00:57:15 +01:00
|
|
|
vpx_active_map_t *const map = va_arg(args, vpx_active_map_t *);
|
2014-03-08 03:15:33 +01:00
|
|
|
|
2014-03-13 00:57:15 +01:00
|
|
|
if (map) {
|
2014-05-14 14:27:16 +02:00
|
|
|
if (!vp9_set_active_map(ctx->cpi, map->active_map,
|
|
|
|
(int)map->rows, (int)map->cols))
|
2014-03-08 03:15:33 +01:00
|
|
|
return VPX_CODEC_OK;
|
|
|
|
else
|
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
|
|
|
} else {
|
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_scale_mode(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2014-03-13 00:57:15 +01:00
|
|
|
vpx_scaling_mode_t *const mode = va_arg(args, vpx_scaling_mode_t *);
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2014-03-13 00:57:15 +01:00
|
|
|
if (mode) {
|
|
|
|
const int res = vp9_set_internal_size(ctx->cpi,
|
|
|
|
(VPX_SCALING)mode->h_scaling_mode,
|
|
|
|
(VPX_SCALING)mode->v_scaling_mode);
|
2014-02-05 18:45:13 +01:00
|
|
|
return (res == 0) ? VPX_CODEC_OK : VPX_CODEC_INVALID_PARAM;
|
2013-10-05 02:16:20 +02:00
|
|
|
} else {
|
2012-07-14 00:21:29 +02:00
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
2013-10-05 02:16:20 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
}
|
|
|
|
|
2014-05-28 01:45:58 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_svc(vpx_codec_alg_priv_t *ctx, va_list args) {
|
2013-10-23 20:53:37 +02:00
|
|
|
int data = va_arg(args, int);
|
2014-04-02 02:14:55 +02:00
|
|
|
const vpx_codec_enc_cfg_t *cfg = &ctx->cfg;
|
2014-05-14 21:11:51 +02:00
|
|
|
|
2013-10-23 20:53:37 +02:00
|
|
|
vp9_set_svc(ctx->cpi, data);
|
2014-03-27 21:43:20 +01:00
|
|
|
// CBR or two pass mode for SVC with both temporal and spatial layers
|
|
|
|
// not yet supported.
|
2014-02-06 18:23:17 +01:00
|
|
|
if (data == 1 &&
|
2014-04-02 02:14:55 +02:00
|
|
|
(cfg->rc_end_usage == VPX_CBR ||
|
|
|
|
cfg->g_pass == VPX_RC_FIRST_PASS ||
|
|
|
|
cfg->g_pass == VPX_RC_LAST_PASS) &&
|
|
|
|
cfg->ss_number_layers > 1 &&
|
|
|
|
cfg->ts_number_layers > 1) {
|
2014-02-06 18:23:17 +01:00
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
|
|
|
}
|
|
|
|
return VPX_CODEC_OK;
|
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_svc_layer_id(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2014-04-02 02:14:55 +02:00
|
|
|
vpx_svc_layer_id_t *const data = va_arg(args, vpx_svc_layer_id_t *);
|
|
|
|
VP9_COMP *const cpi = (VP9_COMP *)ctx->cpi;
|
|
|
|
SVC *const svc = &cpi->svc;
|
2014-05-14 21:11:51 +02:00
|
|
|
|
2014-04-02 02:14:55 +02:00
|
|
|
svc->spatial_layer_id = data->spatial_layer_id;
|
|
|
|
svc->temporal_layer_id = data->temporal_layer_id;
|
2014-02-06 18:23:17 +01:00
|
|
|
// Checks on valid layer_id input.
|
2014-04-02 02:14:55 +02:00
|
|
|
if (svc->temporal_layer_id < 0 ||
|
|
|
|
svc->temporal_layer_id >= (int)ctx->cfg.ts_number_layers) {
|
2014-02-06 18:23:17 +01:00
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
|
|
|
}
|
2014-04-02 02:14:55 +02:00
|
|
|
if (svc->spatial_layer_id < 0 ||
|
|
|
|
svc->spatial_layer_id >= (int)ctx->cfg.ss_number_layers) {
|
2014-02-06 18:23:17 +01:00
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
|
|
|
}
|
2013-10-23 20:53:37 +02:00
|
|
|
return VPX_CODEC_OK;
|
2013-09-05 17:55:47 +02:00
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_svc_parameters(vpx_codec_alg_priv_t *ctx,
|
2014-05-28 01:45:58 +02:00
|
|
|
va_list args) {
|
2014-03-13 00:57:15 +01:00
|
|
|
VP9_COMP *const cpi = ctx->cpi;
|
|
|
|
vpx_svc_parameters_t *const params = va_arg(args, vpx_svc_parameters_t *);
|
2013-09-05 17:55:47 +02:00
|
|
|
|
2014-06-24 23:01:17 +02:00
|
|
|
if (params == NULL || params->spatial_layer < 0 ||
|
|
|
|
params->spatial_layer >= cpi->svc.number_spatial_layers)
|
2013-09-05 17:55:47 +02:00
|
|
|
return VPX_CODEC_INVALID_PARAM;
|
|
|
|
|
2014-06-24 23:01:17 +02:00
|
|
|
if (params->spatial_layer == 0) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < cpi->svc.number_spatial_layers; ++i) {
|
|
|
|
cpi->svc.layer_context[i].svc_params_received.spatial_layer = -1;
|
|
|
|
}
|
|
|
|
}
|
2013-10-23 20:53:37 +02:00
|
|
|
|
2014-06-24 23:01:17 +02:00
|
|
|
cpi->svc.layer_context[params->spatial_layer].svc_params_received =
|
|
|
|
*params;
|
2013-10-23 20:53:37 +02:00
|
|
|
|
2013-09-05 17:55:47 +02:00
|
|
|
return VPX_CODEC_OK;
|
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-07-31 17:27:32 +02:00
|
|
|
static vpx_codec_err_t ctrl_set_tune_content(vpx_codec_alg_priv_t *ctx,
|
|
|
|
va_list args) {
|
|
|
|
struct vp9_extracfg extra_cfg = ctx->extra_cfg;
|
2014-08-06 19:59:16 +02:00
|
|
|
extra_cfg.content = CAST(VP9E_SET_TUNE_CONTENT, args);
|
2014-07-31 17:27:32 +02:00
|
|
|
return update_extra_cfg(ctx, &extra_cfg);
|
|
|
|
}
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_ctrl_fn_map_t encoder_ctrl_maps[] = {
|
|
|
|
{VP8_COPY_REFERENCE, ctrl_copy_reference},
|
|
|
|
{VP8E_UPD_ENTROPY, ctrl_update_entropy},
|
|
|
|
{VP8E_UPD_REFERENCE, ctrl_update_reference},
|
|
|
|
{VP8E_USE_REFERENCE, ctrl_use_reference},
|
|
|
|
|
|
|
|
// Setters
|
|
|
|
{VP8_SET_REFERENCE, ctrl_set_reference},
|
|
|
|
{VP8_SET_POSTPROC, ctrl_set_previewpp},
|
|
|
|
{VP8E_SET_ROI_MAP, ctrl_set_roi_map},
|
|
|
|
{VP8E_SET_ACTIVEMAP, ctrl_set_active_map},
|
|
|
|
{VP8E_SET_SCALEMODE, ctrl_set_scale_mode},
|
2014-05-28 01:45:58 +02:00
|
|
|
{VP8E_SET_CPUUSED, ctrl_set_cpuused},
|
|
|
|
{VP8E_SET_NOISE_SENSITIVITY, ctrl_set_noise_sensitivity},
|
|
|
|
{VP8E_SET_ENABLEAUTOALTREF, ctrl_set_enable_auto_alt_ref},
|
|
|
|
{VP8E_SET_SHARPNESS, ctrl_set_sharpness},
|
|
|
|
{VP8E_SET_STATIC_THRESHOLD, ctrl_set_static_thresh},
|
|
|
|
{VP9E_SET_TILE_COLUMNS, ctrl_set_tile_columns},
|
|
|
|
{VP9E_SET_TILE_ROWS, ctrl_set_tile_rows},
|
|
|
|
{VP8E_SET_ARNR_MAXFRAMES, ctrl_set_arnr_max_frames},
|
|
|
|
{VP8E_SET_ARNR_STRENGTH, ctrl_set_arnr_strength},
|
|
|
|
{VP8E_SET_ARNR_TYPE, ctrl_set_arnr_type},
|
|
|
|
{VP8E_SET_TUNING, ctrl_set_tuning},
|
|
|
|
{VP8E_SET_CQ_LEVEL, ctrl_set_cq_level},
|
|
|
|
{VP8E_SET_MAX_INTRA_BITRATE_PCT, ctrl_set_rc_max_intra_bitrate_pct},
|
|
|
|
{VP9E_SET_LOSSLESS, ctrl_set_lossless},
|
|
|
|
{VP9E_SET_FRAME_PARALLEL_DECODING, ctrl_set_frame_parallel_decoding_mode},
|
|
|
|
{VP9E_SET_AQ_MODE, ctrl_set_aq_mode},
|
|
|
|
{VP9E_SET_FRAME_PERIODIC_BOOST, ctrl_set_frame_periodic_boost},
|
2014-04-07 19:38:51 +02:00
|
|
|
{VP9E_SET_SVC, ctrl_set_svc},
|
|
|
|
{VP9E_SET_SVC_PARAMETERS, ctrl_set_svc_parameters},
|
|
|
|
{VP9E_SET_SVC_LAYER_ID, ctrl_set_svc_layer_id},
|
2014-07-31 17:27:32 +02:00
|
|
|
{VP9E_SET_TUNE_CONTENT, ctrl_set_tune_content},
|
2014-04-07 19:38:51 +02:00
|
|
|
|
|
|
|
// Getters
|
2014-05-28 01:45:58 +02:00
|
|
|
{VP8E_GET_LAST_QUANTIZER, ctrl_get_quantizer},
|
|
|
|
{VP8E_GET_LAST_QUANTIZER_64, ctrl_get_quantizer64},
|
2014-04-07 19:38:51 +02:00
|
|
|
{VP9_GET_REFERENCE, ctrl_get_reference},
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
{ -1, NULL},
|
2010-05-18 17:58:33 +02:00
|
|
|
};
|
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
static vpx_codec_enc_cfg_map_t encoder_usage_cfg_map[] = {
|
2012-07-14 00:21:29 +02:00
|
|
|
{
|
2010-05-18 17:58:33 +02:00
|
|
|
0,
|
2013-10-05 02:16:20 +02:00
|
|
|
{ // NOLINT
|
2014-04-07 19:38:51 +02:00
|
|
|
0, // g_usage
|
|
|
|
0, // g_threads
|
|
|
|
0, // g_profile
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
320, // g_width
|
|
|
|
240, // g_height
|
|
|
|
{1, 30}, // g_timebase
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
0, // g_error_resilient
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
VPX_RC_ONE_PASS, // g_pass
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
25, // g_lag_in_frames
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
0, // rc_dropframe_thresh
|
|
|
|
0, // rc_resize_allowed
|
2014-04-09 23:51:29 +02:00
|
|
|
1, // rc_scaled_width
|
|
|
|
1, // rc_scaled_height
|
2014-04-07 19:38:51 +02:00
|
|
|
60, // rc_resize_down_thresold
|
|
|
|
30, // rc_resize_up_thresold
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-04-07 19:38:51 +02:00
|
|
|
VPX_VBR, // rc_end_usage
|
2010-05-18 17:58:33 +02:00
|
|
|
#if VPX_ENCODER_ABI_VERSION > (1 + VPX_CODEC_ABI_VERSION)
|
2014-05-28 20:15:43 +02:00
|
|
|
{NULL, 0}, // rc_twopass_stats_in
|
2014-07-14 18:13:38 +02:00
|
|
|
{NULL, 0}, // rc_firstpass_mb_stats_in
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
2014-04-07 19:38:51 +02:00
|
|
|
256, // rc_target_bandwidth
|
|
|
|
0, // rc_min_quantizer
|
|
|
|
63, // rc_max_quantizer
|
|
|
|
100, // rc_undershoot_pct
|
|
|
|
100, // rc_overshoot_pct
|
|
|
|
|
|
|
|
6000, // rc_max_buffer_size
|
|
|
|
4000, // rc_buffer_initial_size
|
|
|
|
5000, // rc_buffer_optimal_size
|
|
|
|
|
|
|
|
50, // rc_two_pass_vbrbias
|
|
|
|
0, // rc_two_pass_vbrmin_section
|
|
|
|
2000, // rc_two_pass_vbrmax_section
|
|
|
|
|
|
|
|
// keyframing settings (kf)
|
|
|
|
VPX_KF_AUTO, // g_kfmode
|
|
|
|
0, // kf_min_dist
|
|
|
|
9999, // kf_max_dist
|
|
|
|
|
|
|
|
VPX_SS_DEFAULT_LAYERS, // ss_number_layers
|
2014-07-14 20:24:17 +02:00
|
|
|
{0},
|
2014-04-07 19:38:51 +02:00
|
|
|
{0}, // ss_target_bitrate
|
|
|
|
1, // ts_number_layers
|
|
|
|
{0}, // ts_target_bitrate
|
|
|
|
{0}, // ts_rate_decimator
|
|
|
|
0, // ts_periodicity
|
|
|
|
{0}, // ts_layer_id
|
2010-05-18 17:58:33 +02:00
|
|
|
#if VPX_ENCODER_ABI_VERSION == (1 + VPX_CODEC_ABI_VERSION)
|
2014-04-07 19:38:51 +02:00
|
|
|
"vp8.fpf" // first pass filename
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
}
|
|
|
|
},
|
2010-05-18 17:58:33 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
#ifndef VERSION_STRING
|
|
|
|
#define VERSION_STRING
|
|
|
|
#endif
|
2012-11-09 02:09:30 +01:00
|
|
|
CODEC_INTERFACE(vpx_codec_vp9_cx) = {
|
|
|
|
"WebM Project VP9 Encoder" VERSION_STRING,
|
2012-07-14 00:21:29 +02:00
|
|
|
VPX_CODEC_INTERNAL_ABI_VERSION,
|
2014-04-07 19:38:51 +02:00
|
|
|
VPX_CODEC_CAP_ENCODER | VPX_CODEC_CAP_PSNR, // vpx_codec_caps_t
|
|
|
|
encoder_init, // vpx_codec_init_fn_t
|
|
|
|
encoder_destroy, // vpx_codec_destroy_fn_t
|
|
|
|
encoder_ctrl_maps, // vpx_codec_ctrl_fn_map_t
|
2013-10-05 02:16:20 +02:00
|
|
|
{ // NOLINT
|
2014-04-07 19:38:51 +02:00
|
|
|
NOT_IMPLEMENTED, // vpx_codec_peek_si_fn_t
|
|
|
|
NOT_IMPLEMENTED, // vpx_codec_get_si_fn_t
|
|
|
|
NOT_IMPLEMENTED, // vpx_codec_decode_fn_t
|
|
|
|
NOT_IMPLEMENTED, // vpx_codec_frame_get_fn_t
|
2014-05-14 21:11:51 +02:00
|
|
|
NOT_IMPLEMENTED // vpx_codec_set_fb_fn_t
|
2012-07-14 00:21:29 +02:00
|
|
|
},
|
2013-10-05 02:16:20 +02:00
|
|
|
{ // NOLINT
|
2014-07-31 15:27:57 +02:00
|
|
|
1, // 1 cfg map
|
2014-04-07 19:38:51 +02:00
|
|
|
encoder_usage_cfg_map, // vpx_codec_enc_cfg_map_t
|
|
|
|
encoder_encode, // vpx_codec_encode_fn_t
|
|
|
|
encoder_get_cxdata, // vpx_codec_get_cx_data_fn_t
|
|
|
|
encoder_set_config, // vpx_codec_enc_config_set_fn_t
|
|
|
|
NOT_IMPLEMENTED, // vpx_codec_get_global_headers_fn_t
|
|
|
|
encoder_get_preview, // vpx_codec_get_preview_frame_fn_t
|
2014-05-14 21:11:51 +02:00
|
|
|
NOT_IMPLEMENTED // vpx_codec_enc_mr_get_mem_loc_fn_t
|
2014-04-07 19:38:51 +02:00
|
|
|
}
|
2010-05-18 17:58:33 +02:00
|
|
|
};
|