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
|
|
|
*/
|
|
|
|
|
2014-04-19 03:27:47 +02:00
|
|
|
#ifndef VP9_ENCODER_VP9_ENCODER_H_
|
|
|
|
#define VP9_ENCODER_VP9_ENCODER_H_
|
2010-05-18 17:58:33 +02:00
|
|
|
|
|
|
|
#include <stdio.h>
|
2014-01-28 21:57:49 +01:00
|
|
|
|
2012-12-23 16:20:10 +01:00
|
|
|
#include "./vpx_config.h"
|
2014-01-28 21:57:49 +01:00
|
|
|
#include "vpx/internal/vpx_codec_internal.h"
|
2014-03-06 08:33:22 +01:00
|
|
|
#include "vpx/vp8cx.h"
|
2014-01-28 21:57:49 +01:00
|
|
|
|
2014-03-06 08:33:22 +01:00
|
|
|
#include "vp9/common/vp9_ppflags.h"
|
2014-01-28 21:57:49 +01:00
|
|
|
#include "vp9/common/vp9_entropymode.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_onyxc_int.h"
|
2014-12-03 00:47:41 +01:00
|
|
|
#include "vp9/common/vp9_thread.h"
|
2014-01-28 21:57:49 +01:00
|
|
|
|
2014-03-21 22:31:53 +01:00
|
|
|
#include "vp9/encoder/vp9_aq_cyclicrefresh.h"
|
2014-05-15 21:01:34 +02:00
|
|
|
#include "vp9/encoder/vp9_context_tree.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/encoder/vp9_encodemb.h"
|
2014-02-06 03:28:28 +01:00
|
|
|
#include "vp9/encoder/vp9_firstpass.h"
|
2012-11-28 19:41:40 +01:00
|
|
|
#include "vp9/encoder/vp9_lookahead.h"
|
2014-02-03 21:35:06 +01:00
|
|
|
#include "vp9/encoder/vp9_mbgraph.h"
|
2014-01-28 21:57:49 +01:00
|
|
|
#include "vp9/encoder/vp9_mcomp.h"
|
|
|
|
#include "vp9/encoder/vp9_quantize.h"
|
|
|
|
#include "vp9/encoder/vp9_ratectrl.h"
|
2014-07-02 21:36:48 +02:00
|
|
|
#include "vp9/encoder/vp9_rd.h"
|
2014-03-28 18:30:28 +01:00
|
|
|
#include "vp9/encoder/vp9_speed_features.h"
|
2014-03-13 18:26:52 +01:00
|
|
|
#include "vp9/encoder/vp9_svc_layercontext.h"
|
2014-01-28 21:57:49 +01:00
|
|
|
#include "vp9/encoder/vp9_tokenize.h"
|
|
|
|
#include "vp9/encoder/vp9_variance.h"
|
2014-07-24 22:30:00 +02:00
|
|
|
#if CONFIG_VP9_TEMPORAL_DENOISING
|
2014-06-05 23:00:08 +02:00
|
|
|
#include "vp9/encoder/vp9_denoiser.h"
|
|
|
|
#endif
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-01-18 21:16:11 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif
|
|
|
|
|
2014-02-08 00:52:41 +01:00
|
|
|
#define DEFAULT_GF_INTERVAL 10
|
2014-10-18 00:12:43 +02:00
|
|
|
#define INVALID_REF_BUFFER_IDX -1 // Marks an invalid reference buffer id.
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
typedef struct {
|
2012-07-26 22:42:07 +02:00
|
|
|
int nmvjointcost[MV_JOINTS];
|
|
|
|
int nmvcosts[2][MV_VALS];
|
|
|
|
int nmvcosts_hp[2][MV_VALS];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_prob segment_pred_probs[PREDICTION_PROBS];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned char *last_frame_seg_map_copy;
|
2012-04-11 16:44:14 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// 0 = Intra, Last, GF, ARF
|
|
|
|
signed char last_ref_lf_deltas[MAX_REF_LF_DELTAS];
|
2013-06-07 07:55:31 +02:00
|
|
|
// 0 = ZERO_MV, MV
|
2012-07-14 00:21:29 +02:00
|
|
|
signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-09-28 01:41:20 +02:00
|
|
|
FRAME_CONTEXT fc;
|
2010-05-18 17:58:33 +02:00
|
|
|
} CODING_CONTEXT;
|
|
|
|
|
2013-09-28 01:02:49 +02:00
|
|
|
|
2014-02-04 20:09:34 +01:00
|
|
|
typedef enum {
|
|
|
|
// encode_breakout is disabled.
|
|
|
|
ENCODE_BREAKOUT_DISABLED = 0,
|
|
|
|
// encode_breakout is enabled.
|
|
|
|
ENCODE_BREAKOUT_ENABLED = 1,
|
|
|
|
// encode_breakout is enabled with small max_thresh limit.
|
|
|
|
ENCODE_BREAKOUT_LIMITED = 2
|
|
|
|
} ENCODE_BREAKOUT_TYPE;
|
|
|
|
|
2014-03-06 08:33:22 +01:00
|
|
|
typedef enum {
|
|
|
|
NORMAL = 0,
|
|
|
|
FOURFIVE = 1,
|
|
|
|
THREEFIVE = 2,
|
|
|
|
ONETWO = 3
|
|
|
|
} VPX_SCALING;
|
|
|
|
|
|
|
|
typedef enum {
|
2014-08-19 00:06:14 +02:00
|
|
|
// Good Quality Fast Encoding. The encoder balances quality with the amount of
|
|
|
|
// time it takes to encode the output. Speed setting controls how fast.
|
|
|
|
GOOD,
|
|
|
|
|
|
|
|
// The encoder places priority on the quality of the output over encoding
|
|
|
|
// speed. The output is compressed at the highest possible quality. This
|
|
|
|
// option takes the longest amount of time to encode. Speed setting ignored.
|
|
|
|
BEST,
|
|
|
|
|
|
|
|
// Realtime/Live Encoding. This mode is optimized for realtime encoding (for
|
|
|
|
// example, capturing a television signal or feed from a live camera). Speed
|
|
|
|
// setting controls how fast.
|
|
|
|
REALTIME
|
2014-03-06 08:33:22 +01:00
|
|
|
} MODE;
|
|
|
|
|
|
|
|
typedef enum {
|
2014-03-15 01:38:15 +01:00
|
|
|
FRAMEFLAGS_KEY = 1 << 0,
|
|
|
|
FRAMEFLAGS_GOLDEN = 1 << 1,
|
|
|
|
FRAMEFLAGS_ALTREF = 1 << 2,
|
2014-03-06 08:33:22 +01:00
|
|
|
} FRAMETYPE_FLAGS;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
NO_AQ = 0,
|
|
|
|
VARIANCE_AQ = 1,
|
|
|
|
COMPLEXITY_AQ = 2,
|
2014-03-14 22:35:47 +01:00
|
|
|
CYCLIC_REFRESH_AQ = 3,
|
2014-03-10 18:58:32 +01:00
|
|
|
AQ_MODE_COUNT // This should always be the last member of the enum
|
|
|
|
} AQ_MODE;
|
2014-03-06 08:33:22 +01:00
|
|
|
|
2014-11-10 18:51:38 +01:00
|
|
|
typedef enum {
|
|
|
|
RESIZE_NONE = 0, // No frame resizing allowed (except for SVC).
|
|
|
|
RESIZE_FIXED = 1, // All frames are coded at the specified dimension.
|
|
|
|
RESIZE_DYNAMIC = 2 // Coded size of each frame is determined by the codec.
|
|
|
|
} RESIZE_TYPE;
|
2014-04-10 00:00:14 +02:00
|
|
|
|
2014-04-18 20:01:36 +02:00
|
|
|
typedef struct VP9EncoderConfig {
|
2014-04-05 02:30:16 +02:00
|
|
|
BITSTREAM_PROFILE profile;
|
2014-08-26 21:35:15 +02:00
|
|
|
vpx_bit_depth_t bit_depth; // Codec bit-depth.
|
2014-03-06 08:33:22 +01:00
|
|
|
int width; // width of data passed to the compressor
|
|
|
|
int height; // height of data passed to the compressor
|
2014-08-26 21:35:15 +02:00
|
|
|
unsigned int input_bit_depth; // Input bit depth.
|
2014-08-09 00:29:37 +02:00
|
|
|
double init_framerate; // set to passed in framerate
|
2014-03-06 08:33:22 +01:00
|
|
|
int64_t target_bandwidth; // bandwidth to be used in kilobits per second
|
|
|
|
|
|
|
|
int noise_sensitivity; // pre processing blur: recommendation 0
|
|
|
|
int sharpness; // sharpening output: recommendation 0:
|
2014-04-17 03:31:42 +02:00
|
|
|
int speed;
|
2014-10-24 18:31:16 +02:00
|
|
|
// maximum allowed bitrate for any intra frame in % of bitrate target.
|
2014-03-06 08:33:22 +01:00
|
|
|
unsigned int rc_max_intra_bitrate_pct;
|
2014-10-24 18:31:16 +02:00
|
|
|
// maximum allowed bitrate for any inter frame in % of bitrate target.
|
|
|
|
unsigned int rc_max_inter_bitrate_pct;
|
2014-10-27 21:13:14 +01:00
|
|
|
// percent of rate boost for golden frame in CBR mode.
|
|
|
|
unsigned int gf_cbr_boost_pct;
|
2014-03-06 08:33:22 +01:00
|
|
|
|
2014-03-11 02:33:08 +01:00
|
|
|
MODE mode;
|
2014-08-08 23:27:34 +02:00
|
|
|
int pass;
|
2014-03-06 08:33:22 +01:00
|
|
|
|
|
|
|
// Key Framing Operations
|
|
|
|
int auto_key; // autodetect cut scenes and set the keyframes
|
|
|
|
int key_freq; // maximum distance to key frame.
|
|
|
|
|
|
|
|
int lag_in_frames; // how many frames lag before we start encoding
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------
|
|
|
|
// DATARATE CONTROL OPTIONS
|
|
|
|
|
2014-06-13 21:22:35 +02:00
|
|
|
// vbr, cbr, constrained quality or constant quality
|
|
|
|
enum vpx_rc_mode rc_mode;
|
2014-03-06 08:33:22 +01:00
|
|
|
|
|
|
|
// buffer targeting aggressiveness
|
|
|
|
int under_shoot_pct;
|
|
|
|
int over_shoot_pct;
|
|
|
|
|
|
|
|
// buffering parameters
|
2014-06-03 22:56:46 +02:00
|
|
|
int64_t starting_buffer_level_ms;
|
|
|
|
int64_t optimal_buffer_level_ms;
|
|
|
|
int64_t maximum_buffer_size_ms;
|
2014-03-06 08:33:22 +01:00
|
|
|
|
|
|
|
// Frame drop threshold.
|
|
|
|
int drop_frames_water_mark;
|
|
|
|
|
|
|
|
// controlling quality
|
|
|
|
int fixed_q;
|
|
|
|
int worst_allowed_q;
|
|
|
|
int best_allowed_q;
|
|
|
|
int cq_level;
|
2014-03-10 18:58:32 +01:00
|
|
|
AQ_MODE aq_mode; // Adaptive Quantization mode
|
2014-03-06 08:33:22 +01:00
|
|
|
|
2014-04-09 23:51:29 +02:00
|
|
|
// Internal frame size scaling.
|
2014-11-10 18:51:38 +01:00
|
|
|
RESIZE_TYPE resize_mode;
|
2014-04-09 23:51:29 +02:00
|
|
|
int scaled_frame_width;
|
|
|
|
int scaled_frame_height;
|
|
|
|
|
2014-04-04 00:49:03 +02:00
|
|
|
// Enable feature to reduce the frame quantization every x frames.
|
|
|
|
int frame_periodic_boost;
|
|
|
|
|
2014-03-06 08:33:22 +01:00
|
|
|
// two pass datarate control
|
|
|
|
int two_pass_vbrbias; // two pass datarate control tweaks
|
|
|
|
int two_pass_vbrmin_section;
|
|
|
|
int two_pass_vbrmax_section;
|
|
|
|
// END DATARATE CONTROL OPTIONS
|
|
|
|
// ----------------------------------------------------------------
|
|
|
|
|
|
|
|
// Spatial and temporal scalability.
|
|
|
|
int ss_number_layers; // Number of spatial layers.
|
|
|
|
int ts_number_layers; // Number of temporal layers.
|
|
|
|
// Bitrate allocation for spatial layers.
|
|
|
|
int ss_target_bitrate[VPX_SS_MAX_LAYERS];
|
2014-10-20 13:05:17 +02:00
|
|
|
int ss_enable_auto_arf[VPX_SS_MAX_LAYERS];
|
2014-03-06 08:33:22 +01:00
|
|
|
// Bitrate allocation (CBR mode) and framerate factor, for temporal layers.
|
|
|
|
int ts_target_bitrate[VPX_TS_MAX_LAYERS];
|
|
|
|
int ts_rate_decimator[VPX_TS_MAX_LAYERS];
|
|
|
|
|
2014-10-20 13:05:17 +02:00
|
|
|
int enable_auto_arf;
|
2014-03-06 08:33:22 +01:00
|
|
|
|
|
|
|
int encode_breakout; // early breakout : for video conf recommend 800
|
|
|
|
|
|
|
|
/* Bitfield defining the error resiliency features to enable.
|
|
|
|
* Can provide decodable frames after losses in previous
|
|
|
|
* frames and decodable partitions after losses in the same frame.
|
|
|
|
*/
|
|
|
|
unsigned int error_resilient_mode;
|
|
|
|
|
|
|
|
/* Bitfield defining the parallel decoding mode where the
|
|
|
|
* decoding in successive frames may be conducted in parallel
|
|
|
|
* just by decoding the frame headers.
|
|
|
|
*/
|
|
|
|
unsigned int frame_parallel_decoding_mode;
|
|
|
|
|
|
|
|
int arnr_max_frames;
|
|
|
|
int arnr_strength;
|
|
|
|
|
|
|
|
int tile_columns;
|
|
|
|
int tile_rows;
|
|
|
|
|
2014-12-03 00:47:41 +01:00
|
|
|
int max_threads;
|
|
|
|
|
2014-08-22 03:06:04 +02:00
|
|
|
vpx_fixed_buf_t two_pass_stats_in;
|
|
|
|
struct vpx_codec_pkt_list *output_pkt_list;
|
2014-03-06 08:33:22 +01:00
|
|
|
|
2014-07-14 18:13:38 +02:00
|
|
|
#if CONFIG_FP_MB_STATS
|
2014-08-22 03:06:04 +02:00
|
|
|
vpx_fixed_buf_t firstpass_mb_stats_in;
|
2014-07-14 18:13:38 +02:00
|
|
|
#endif
|
|
|
|
|
2014-03-06 08:33:22 +01:00
|
|
|
vp8e_tuning tuning;
|
2014-07-31 17:27:32 +02:00
|
|
|
vp9e_tune_content content;
|
2014-09-03 01:34:09 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
int use_highbitdepth;
|
|
|
|
#endif
|
2014-04-18 20:01:36 +02:00
|
|
|
} VP9EncoderConfig;
|
2014-03-06 08:33:22 +01:00
|
|
|
|
2014-06-03 21:52:49 +02:00
|
|
|
static INLINE int is_lossless_requested(const VP9EncoderConfig *cfg) {
|
|
|
|
return cfg->best_allowed_q == 0 && cfg->worst_allowed_q == 0;
|
|
|
|
}
|
|
|
|
|
Tile based adaptive mode search in RD loop
Make the spatially adaptive mode search in rate-distortion
optimization loop inter tile independent. Experiments suggest that
this does not significantly change the coding staticstics.
Single tile, speed 3:
pedestrian_area 1080p 1500 kbps
59192 b/f, 40.611 dB, 101689 ms
blue_sky 1080p 1500 kbps
58505 b/f, 36.347 dB, 62458 ms
mobile_cal 720p 1000 kbps
13335 b/f, 35.646 dB, 45655 ms
as compared to 4 column tiles, speed 3:
pedestrian_area 1080p 1500 kbps
59329 b/f, 40.597 dB, 101917 ms
blue_sky 1080p 1500 kbps
58712 b/f, 36.320 dB, 62693 ms
mobile_cal 720p 1000 kbps
13191 b/f, 35.485 dB, 45319 ms
Change-Id: I35c6e1e0a859fece8f4145dec28623cbc6a12325
2014-10-24 01:54:45 +02:00
|
|
|
// TODO(jingning) All spatially adaptive variables should go to TileDataEnc.
|
|
|
|
typedef struct TileDataEnc {
|
2014-10-27 19:11:50 +01:00
|
|
|
TileInfo tile_info;
|
Tile based adaptive mode search in RD loop
Make the spatially adaptive mode search in rate-distortion
optimization loop inter tile independent. Experiments suggest that
this does not significantly change the coding staticstics.
Single tile, speed 3:
pedestrian_area 1080p 1500 kbps
59192 b/f, 40.611 dB, 101689 ms
blue_sky 1080p 1500 kbps
58505 b/f, 36.347 dB, 62458 ms
mobile_cal 720p 1000 kbps
13335 b/f, 35.646 dB, 45655 ms
as compared to 4 column tiles, speed 3:
pedestrian_area 1080p 1500 kbps
59329 b/f, 40.597 dB, 101917 ms
blue_sky 1080p 1500 kbps
58712 b/f, 36.320 dB, 62693 ms
mobile_cal 720p 1000 kbps
13191 b/f, 35.485 dB, 45319 ms
Change-Id: I35c6e1e0a859fece8f4145dec28623cbc6a12325
2014-10-24 01:54:45 +02:00
|
|
|
int thresh_freq_fact[BLOCK_SIZES][MAX_MODES];
|
|
|
|
int mode_map[BLOCK_SIZES][MAX_MODES];
|
|
|
|
} TileDataEnc;
|
|
|
|
|
2014-11-21 20:11:06 +01:00
|
|
|
typedef struct RD_COUNTS {
|
2014-11-15 01:04:15 +01:00
|
|
|
vp9_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
|
|
|
|
int64_t comp_pred_diff[REFERENCE_MODES];
|
|
|
|
int64_t tx_select_diff[TX_MODES];
|
|
|
|
int64_t filter_diff[SWITCHABLE_FILTER_CONTEXTS];
|
2014-11-21 20:11:06 +01:00
|
|
|
} RD_COUNTS;
|
|
|
|
|
|
|
|
typedef struct ThreadData {
|
|
|
|
MACROBLOCK mb;
|
|
|
|
RD_COUNTS rd_counts;
|
|
|
|
FRAME_COUNTS *counts;
|
|
|
|
|
|
|
|
PICK_MODE_CONTEXT *leaf_tree;
|
|
|
|
PC_TREE *pc_tree;
|
|
|
|
PC_TREE *pc_root;
|
|
|
|
} ThreadData;
|
2014-11-15 01:04:15 +01:00
|
|
|
|
2012-10-31 01:53:32 +01:00
|
|
|
typedef struct VP9_COMP {
|
2014-03-29 00:46:41 +01:00
|
|
|
QUANTS quants;
|
2014-11-21 20:11:06 +01:00
|
|
|
ThreadData td;
|
2012-10-31 01:53:32 +01:00
|
|
|
VP9_COMMON common;
|
2014-04-18 20:01:36 +02:00
|
|
|
VP9EncoderConfig oxcf;
|
2012-07-14 00:21:29 +02:00
|
|
|
struct lookahead_ctx *lookahead;
|
|
|
|
struct lookahead_entry *alt_ref_source;
|
2011-04-13 20:00:18 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG *Source;
|
2014-03-28 18:47:36 +01:00
|
|
|
YV12_BUFFER_CONFIG *Last_Source; // NULL for first frame and alt_ref frames
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG *un_scaled_source;
|
|
|
|
YV12_BUFFER_CONFIG scaled_source;
|
2014-03-28 18:47:36 +01:00
|
|
|
YV12_BUFFER_CONFIG *unscaled_last_source;
|
|
|
|
YV12_BUFFER_CONFIG scaled_last_source;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
Tile based adaptive mode search in RD loop
Make the spatially adaptive mode search in rate-distortion
optimization loop inter tile independent. Experiments suggest that
this does not significantly change the coding staticstics.
Single tile, speed 3:
pedestrian_area 1080p 1500 kbps
59192 b/f, 40.611 dB, 101689 ms
blue_sky 1080p 1500 kbps
58505 b/f, 36.347 dB, 62458 ms
mobile_cal 720p 1000 kbps
13335 b/f, 35.646 dB, 45655 ms
as compared to 4 column tiles, speed 3:
pedestrian_area 1080p 1500 kbps
59329 b/f, 40.597 dB, 101917 ms
blue_sky 1080p 1500 kbps
58712 b/f, 36.320 dB, 62693 ms
mobile_cal 720p 1000 kbps
13191 b/f, 35.485 dB, 45319 ms
Change-Id: I35c6e1e0a859fece8f4145dec28623cbc6a12325
2014-10-24 01:54:45 +02:00
|
|
|
TileDataEnc *tile_data;
|
|
|
|
|
2014-09-24 21:12:25 +02:00
|
|
|
// For a still frame, this flag is set to 1 to skip partition search.
|
|
|
|
int partition_search_skippable_frame;
|
2014-06-23 22:00:16 +02:00
|
|
|
|
2014-10-18 00:12:43 +02:00
|
|
|
int scaled_ref_idx[MAX_REF_FRAMES];
|
2013-01-15 22:49:44 +01:00
|
|
|
int lst_fb_idx;
|
|
|
|
int gld_fb_idx;
|
|
|
|
int alt_fb_idx;
|
2013-09-05 17:55:47 +02:00
|
|
|
|
2013-01-15 22:49:44 +01:00
|
|
|
int refresh_last_frame;
|
|
|
|
int refresh_golden_frame;
|
|
|
|
int refresh_alt_ref_frame;
|
2014-01-09 02:55:07 +01:00
|
|
|
|
|
|
|
int ext_refresh_frame_flags_pending;
|
|
|
|
int ext_refresh_last_frame;
|
|
|
|
int ext_refresh_golden_frame;
|
|
|
|
int ext_refresh_alt_ref_frame;
|
|
|
|
|
|
|
|
int ext_refresh_frame_context_pending;
|
|
|
|
int ext_refresh_frame_context;
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG last_frame_uf;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-11-26 01:53:47 +01:00
|
|
|
TOKENEXTRA *tile_tok[4][1 << 6];
|
2013-06-12 19:30:06 +02:00
|
|
|
unsigned int tok_count[4][1 << 6];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// Ambient reconstruction err target for force key frames
|
|
|
|
int ambient_err;
|
2011-01-17 18:23:11 +01:00
|
|
|
|
2014-04-10 00:00:14 +02:00
|
|
|
RD_OPT rd;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
CODING_CONTEXT coding_context;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-08-22 18:19:20 +02:00
|
|
|
int *nmvcosts[2];
|
|
|
|
int *nmvcosts_hp[2];
|
|
|
|
int *nmvsadcosts[2];
|
|
|
|
int *nmvsadcosts_hp[2];
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int64_t last_time_stamp_seen;
|
|
|
|
int64_t last_end_time_stamp_seen;
|
|
|
|
int64_t first_time_stamp_ever;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-11-06 22:13:59 +01:00
|
|
|
RATE_CONTROL rc;
|
2014-08-09 00:29:37 +02:00
|
|
|
double framerate;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-08-20 20:17:05 +02:00
|
|
|
int interp_filter_selected[MAX_REF_FRAMES][SWITCHABLE];
|
32x32 transform for superblocks.
This adds Debargha's DCT/DWT hybrid and a regular 32x32 DCT, and adds
code all over the place to wrap that in the bitstream/encoder/decoder/RD.
Some implementation notes (these probably need careful review):
- token range is extended by 1 bit, since the value range out of this
transform is [-16384,16383].
- the coefficients coming out of the FDCT are manually scaled back by
1 bit, or else they won't fit in int16_t (they are 17 bits). Because
of this, the RD error scoring does not right-shift the MSE score by
two (unlike for 4x4/8x8/16x16).
- to compensate for this loss in precision, the quantizer is halved
also. This is currently a little hacky.
- FDCT and IDCT is double-only right now. Needs a fixed-point impl.
- There are no default probabilities for the 32x32 transform yet; I'm
simply using the 16x16 luma ones. A future commit will add newly
generated probabilities for all transforms.
- No ADST version. I don't think we'll add one for this level; if an
ADST is desired, transform-size selection can scale back to 16x16
or lower, and use an ADST at that level.
Additional notes specific to Debargha's DWT/DCT hybrid:
- coefficient scale is different for the top/left 16x16 (DCT-over-DWT)
block than for the rest (DWT pixel differences) of the block. Therefore,
RD error scoring isn't easily scalable between coefficient and pixel
domain. Thus, unfortunately, we need to compute the RD distortion in
the pixel domain until we figure out how to scale these appropriately.
Change-Id: I00386f20f35d7fabb19aba94c8162f8aee64ef2b
2012-12-07 23:45:05 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
struct vpx_codec_pkt_list *output_pkt_list;
|
2010-10-14 22:40:12 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
MBGRAPH_FRAME_STATS mbgraph_stats[MAX_LAG_BUFFERS];
|
|
|
|
int mbgraph_n_frames; // number of frames filled in the above
|
|
|
|
int static_mb_pct; // % forced skip mbs by segmentation
|
|
|
|
int ref_frame_flags;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
SPEED_FEATURES sf;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2013-06-26 18:06:25 +02:00
|
|
|
unsigned int max_mv_magnitude;
|
2013-07-12 18:52:24 +02:00
|
|
|
int mv_step_param;
|
2013-06-26 18:06:25 +02:00
|
|
|
|
2014-12-11 03:11:17 +01:00
|
|
|
int allow_comp_inter_inter;
|
|
|
|
|
2014-02-04 20:09:34 +01:00
|
|
|
// Default value is 1. From first pass stats, encode_breakout may be disabled.
|
|
|
|
ENCODE_BREAKOUT_TYPE allow_encode_breakout;
|
|
|
|
|
2014-05-07 19:39:00 +02:00
|
|
|
// Get threshold from external input. A suggested threshold is 800 for HD
|
|
|
|
// clips, and 300 for < HD clips.
|
2014-02-04 20:09:34 +01:00
|
|
|
int encode_breakout;
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned char *segmentation_map;
|
2011-09-13 12:26:39 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// segment threashold for encode breakout
|
2013-07-23 13:09:04 +02:00
|
|
|
int segment_encode_breakout[MAX_SEGMENTS];
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-03-26 19:00:35 +01:00
|
|
|
CYCLIC_REFRESH *cyclic_refresh;
|
2014-03-14 22:35:47 +01:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
fractional_mv_step_fp *find_fractional_mv_step;
|
2012-10-31 22:40:53 +01:00
|
|
|
vp9_full_search_fn_t full_search_sad;
|
|
|
|
vp9_diamond_search_fn_t diamond_search_sad;
|
2013-08-10 02:47:32 +02:00
|
|
|
vp9_variance_fn_ptr_t fn_ptr[BLOCK_SIZES];
|
2012-08-11 02:05:46 +02:00
|
|
|
uint64_t time_receive_data;
|
|
|
|
uint64_t time_compress_data;
|
|
|
|
uint64_t time_pick_lpf;
|
2013-07-30 19:16:03 +02:00
|
|
|
uint64_t time_encode_sb_row;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-06-30 18:52:27 +02:00
|
|
|
#if CONFIG_FP_MB_STATS
|
|
|
|
int use_fp_mb_stats;
|
|
|
|
#endif
|
|
|
|
|
2014-05-16 12:31:30 +02:00
|
|
|
TWO_PASS twopass;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG alt_ref_buffer;
|
2014-08-26 08:27:08 +02:00
|
|
|
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2011-04-29 18:37:59 +02:00
|
|
|
#if CONFIG_INTERNAL_STATS
|
2014-02-14 23:46:29 +01:00
|
|
|
unsigned int mode_chosen_counts[MAX_MODES];
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int count;
|
|
|
|
double total_y;
|
|
|
|
double total_u;
|
|
|
|
double total_v;
|
|
|
|
double total;
|
2014-01-11 01:09:56 +01:00
|
|
|
uint64_t total_sq_error;
|
|
|
|
uint64_t total_samples;
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
double totalp_y;
|
|
|
|
double totalp_u;
|
|
|
|
double totalp_v;
|
|
|
|
double totalp;
|
2014-01-11 01:09:56 +01:00
|
|
|
uint64_t totalp_sq_error;
|
|
|
|
uint64_t totalp_samples;
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int bytes;
|
|
|
|
double summed_quality;
|
|
|
|
double summed_weights;
|
2013-04-01 18:10:27 +02:00
|
|
|
double summedp_quality;
|
|
|
|
double summedp_weights;
|
2012-07-14 00:21:29 +02:00
|
|
|
unsigned int tot_recode_hits;
|
|
|
|
|
|
|
|
|
|
|
|
double total_ssimg_y;
|
|
|
|
double total_ssimg_u;
|
|
|
|
double total_ssimg_v;
|
|
|
|
double total_ssimg_all;
|
|
|
|
|
|
|
|
int b_calculate_ssimg;
|
2010-05-18 17:58:33 +02:00
|
|
|
#endif
|
2012-07-14 00:21:29 +02:00
|
|
|
int b_calculate_psnr;
|
2010-08-11 17:02:31 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int droppable;
|
2012-04-07 01:38:34 +02:00
|
|
|
|
2013-02-06 23:22:17 +01:00
|
|
|
int initial_width;
|
|
|
|
int initial_height;
|
2014-10-18 00:12:43 +02:00
|
|
|
int initial_mbs; // Number of MBs in the full-size frame; to be used to
|
|
|
|
// normalize the firstpass stats. This will differ from the
|
|
|
|
// number of MBs in the current frame when the frame is
|
|
|
|
// scaled.
|
2013-04-03 00:08:50 +02:00
|
|
|
|
2014-02-06 18:23:17 +01:00
|
|
|
int use_svc;
|
|
|
|
|
2014-03-13 18:26:52 +01:00
|
|
|
SVC svc;
|
2014-02-06 18:23:17 +01:00
|
|
|
|
2014-05-02 00:14:39 +02:00
|
|
|
// Store frame variance info in SOURCE_VAR_BASED_PARTITION search type.
|
|
|
|
diff *source_diff_var;
|
|
|
|
// The threshold used in SOURCE_VAR_BASED_PARTITION search type.
|
|
|
|
unsigned int source_var_thresh;
|
|
|
|
int frames_till_next_var_check;
|
2014-04-02 02:32:20 +02:00
|
|
|
|
2014-04-10 05:56:06 +02:00
|
|
|
int frame_flags;
|
|
|
|
|
2014-04-26 03:22:27 +02:00
|
|
|
search_site_config ss_cfg;
|
|
|
|
|
2014-05-02 01:12:23 +02:00
|
|
|
int mbmode_cost[INTRA_MODES];
|
2014-08-29 20:27:24 +02:00
|
|
|
unsigned int inter_mode_cost[INTER_MODE_CONTEXTS][INTER_MODES];
|
2014-05-02 01:12:23 +02:00
|
|
|
int intra_uv_mode_cost[FRAME_TYPES][INTRA_MODES];
|
|
|
|
int y_mode_costs[INTRA_MODES][INTRA_MODES][INTRA_MODES];
|
|
|
|
int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS];
|
2014-05-15 21:01:34 +02:00
|
|
|
int partition_cost[PARTITION_CONTEXTS][PARTITION_TYPES];
|
|
|
|
|
2014-06-23 13:17:07 +02:00
|
|
|
int multi_arf_allowed;
|
2014-06-09 17:25:31 +02:00
|
|
|
int multi_arf_enabled;
|
2014-06-30 11:35:00 +02:00
|
|
|
int multi_arf_last_grp_enabled;
|
2014-06-05 23:00:08 +02:00
|
|
|
|
2014-07-24 22:30:00 +02:00
|
|
|
#if CONFIG_VP9_TEMPORAL_DENOISING
|
2014-06-05 23:00:08 +02:00
|
|
|
VP9_DENOISER denoiser;
|
|
|
|
#endif
|
2014-12-03 00:47:41 +01:00
|
|
|
|
|
|
|
// Multi-threading
|
|
|
|
int num_workers;
|
|
|
|
VP9Worker *workers;
|
2012-10-31 01:53:32 +01:00
|
|
|
} VP9_COMP;
|
2010-05-18 17:58:33 +02:00
|
|
|
|
2014-12-19 16:50:54 +01:00
|
|
|
void vp9_initialize_enc(void);
|
2014-03-06 08:33:22 +01:00
|
|
|
|
2014-04-18 20:01:36 +02:00
|
|
|
struct VP9_COMP *vp9_create_compressor(VP9EncoderConfig *oxcf);
|
2014-03-06 08:33:22 +01:00
|
|
|
void vp9_remove_compressor(VP9_COMP *cpi);
|
|
|
|
|
2014-04-18 20:01:36 +02:00
|
|
|
void vp9_change_config(VP9_COMP *cpi, const VP9EncoderConfig *oxcf);
|
2014-03-06 08:33:22 +01:00
|
|
|
|
|
|
|
// receive a frames worth of data. caller can assume that a copy of this
|
|
|
|
// frame is made and not just a copy of the pointer..
|
|
|
|
int vp9_receive_raw_frame(VP9_COMP *cpi, unsigned int frame_flags,
|
|
|
|
YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
|
|
|
|
int64_t end_time_stamp);
|
|
|
|
|
|
|
|
int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
|
|
|
|
size_t *size, uint8_t *dest,
|
|
|
|
int64_t *time_stamp, int64_t *time_end, int flush);
|
|
|
|
|
|
|
|
int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
|
|
|
|
vp9_ppflags_t *flags);
|
|
|
|
|
|
|
|
int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags);
|
|
|
|
|
2014-03-18 19:49:23 +01:00
|
|
|
void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags);
|
2014-03-06 08:33:22 +01:00
|
|
|
|
|
|
|
int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
|
|
|
|
YV12_BUFFER_CONFIG *sd);
|
|
|
|
|
|
|
|
int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
|
|
|
|
YV12_BUFFER_CONFIG *sd);
|
|
|
|
|
|
|
|
int vp9_update_entropy(VP9_COMP *cpi, int update);
|
|
|
|
|
2014-05-14 14:27:16 +02:00
|
|
|
int vp9_set_active_map(VP9_COMP *cpi, unsigned char *map, int rows, int cols);
|
2014-03-06 08:33:22 +01:00
|
|
|
|
|
|
|
int vp9_set_internal_size(VP9_COMP *cpi,
|
|
|
|
VPX_SCALING horiz_mode, VPX_SCALING vert_mode);
|
|
|
|
|
|
|
|
int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
|
|
|
|
unsigned int height);
|
|
|
|
|
|
|
|
void vp9_set_svc(VP9_COMP *cpi, int use_svc);
|
|
|
|
|
|
|
|
int vp9_get_quantizer(struct VP9_COMP *cpi);
|
|
|
|
|
2014-11-10 18:51:38 +01:00
|
|
|
static INLINE int frame_is_kf_gf_arf(const VP9_COMP *cpi) {
|
|
|
|
return frame_is_intra_only(&cpi->common) ||
|
|
|
|
cpi->refresh_alt_ref_frame ||
|
|
|
|
(cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref);
|
|
|
|
}
|
|
|
|
|
2014-03-24 17:26:20 +01:00
|
|
|
static INLINE int get_ref_frame_idx(const VP9_COMP *cpi,
|
|
|
|
MV_REFERENCE_FRAME ref_frame) {
|
2013-05-21 00:59:39 +02:00
|
|
|
if (ref_frame == LAST_FRAME) {
|
|
|
|
return cpi->lst_fb_idx;
|
|
|
|
} else if (ref_frame == GOLDEN_FRAME) {
|
|
|
|
return cpi->gld_fb_idx;
|
|
|
|
} else {
|
|
|
|
return cpi->alt_fb_idx;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-24 17:26:20 +01:00
|
|
|
static INLINE YV12_BUFFER_CONFIG *get_ref_frame_buffer(
|
|
|
|
VP9_COMP *cpi, MV_REFERENCE_FRAME ref_frame) {
|
|
|
|
VP9_COMMON * const cm = &cpi->common;
|
|
|
|
return &cm->frame_bufs[cm->ref_frame_map[get_ref_frame_idx(cpi, ref_frame)]]
|
|
|
|
.buf;
|
2014-01-06 23:50:54 +01:00
|
|
|
}
|
|
|
|
|
2014-03-24 17:26:20 +01:00
|
|
|
static INLINE int get_token_alloc(int mb_rows, int mb_cols) {
|
2014-07-17 20:29:59 +02:00
|
|
|
// TODO(JBB): double check we can't exceed this token count if we have a
|
|
|
|
// 32x32 transform crossing a boundary at a multiple of 16.
|
2014-03-24 17:26:20 +01:00
|
|
|
// mb_rows, cols are in units of 16 pixels. We assume 3 planes all at full
|
|
|
|
// resolution. We assume up to 1 token per pixel, and then allow
|
|
|
|
// a head room of 4.
|
|
|
|
return mb_rows * mb_cols * (16 * 16 * 3 + 4);
|
|
|
|
}
|
|
|
|
|
2014-10-16 21:29:48 +02:00
|
|
|
// Get the allocated token size for a tile. It does the same calculation as in
|
|
|
|
// the frame token allocation.
|
|
|
|
static INLINE int allocated_tokens(TileInfo tile) {
|
|
|
|
int tile_mb_rows = (tile.mi_row_end - tile.mi_row_start + 1) >> 1;
|
|
|
|
int tile_mb_cols = (tile.mi_col_end - tile.mi_col_start + 1) >> 1;
|
|
|
|
|
|
|
|
return get_token_alloc(tile_mb_rows, tile_mb_cols);
|
|
|
|
}
|
|
|
|
|
2014-03-18 01:53:02 +01:00
|
|
|
int vp9_get_y_sse(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b);
|
2014-09-20 01:51:59 +02:00
|
|
|
#if CONFIG_VP9_HIGHBITDEPTH
|
|
|
|
int vp9_highbd_get_y_sse(const YV12_BUFFER_CONFIG *a,
|
|
|
|
const YV12_BUFFER_CONFIG *b,
|
|
|
|
vpx_bit_depth_t bit_depth);
|
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
2012-11-02 19:22:57 +01:00
|
|
|
|
2013-09-25 00:13:09 +02:00
|
|
|
void vp9_alloc_compressor_data(VP9_COMP *cpi);
|
2012-11-02 19:22:57 +01:00
|
|
|
|
2014-03-19 19:06:20 +01:00
|
|
|
void vp9_scale_references(VP9_COMP *cpi);
|
|
|
|
|
|
|
|
void vp9_update_reference_frames(VP9_COMP *cpi);
|
|
|
|
|
2014-06-24 23:01:17 +02:00
|
|
|
void vp9_set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv);
|
|
|
|
|
2014-04-18 19:59:15 +02:00
|
|
|
YV12_BUFFER_CONFIG *vp9_scale_if_required(VP9_COMMON *cm,
|
|
|
|
YV12_BUFFER_CONFIG *unscaled,
|
|
|
|
YV12_BUFFER_CONFIG *scaled);
|
|
|
|
|
2014-06-24 23:01:17 +02:00
|
|
|
void vp9_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags);
|
|
|
|
|
2014-09-02 21:05:14 +02:00
|
|
|
static INLINE int is_two_pass_svc(const struct VP9_COMP *const cpi) {
|
2014-08-07 00:20:51 +02:00
|
|
|
return cpi->use_svc &&
|
2014-11-04 20:46:48 +01:00
|
|
|
((cpi->svc.number_spatial_layers > 1) ||
|
|
|
|
(cpi->svc.number_temporal_layers > 1 && cpi->oxcf.pass != 0));
|
2014-08-07 00:20:51 +02:00
|
|
|
}
|
|
|
|
|
2014-07-14 20:24:17 +02:00
|
|
|
static INLINE int is_altref_enabled(const VP9_COMP *const cpi) {
|
|
|
|
return cpi->oxcf.mode != REALTIME && cpi->oxcf.lag_in_frames > 0 &&
|
2014-10-20 13:05:17 +02:00
|
|
|
(cpi->oxcf.enable_auto_arf &&
|
2014-09-02 21:05:14 +02:00
|
|
|
(!is_two_pass_svc(cpi) ||
|
2014-10-20 13:05:17 +02:00
|
|
|
cpi->oxcf.ss_enable_auto_arf[cpi->svc.spatial_layer_id]));
|
2014-07-14 20:24:17 +02:00
|
|
|
}
|
|
|
|
|
2014-03-24 17:26:20 +01:00
|
|
|
static INLINE void set_ref_ptrs(VP9_COMMON *cm, MACROBLOCKD *xd,
|
|
|
|
MV_REFERENCE_FRAME ref0,
|
|
|
|
MV_REFERENCE_FRAME ref1) {
|
2014-01-30 07:02:24 +01:00
|
|
|
xd->block_refs[0] = &cm->frame_refs[ref0 >= LAST_FRAME ? ref0 - LAST_FRAME
|
|
|
|
: 0];
|
|
|
|
xd->block_refs[1] = &cm->frame_refs[ref1 >= LAST_FRAME ? ref1 - LAST_FRAME
|
|
|
|
: 0];
|
2014-01-28 01:00:20 +01:00
|
|
|
}
|
|
|
|
|
2014-07-26 01:43:27 +02:00
|
|
|
static INLINE int get_chessboard_index(const int frame_index) {
|
|
|
|
return frame_index & 0x1;
|
2014-06-06 03:17:54 +02:00
|
|
|
}
|
|
|
|
|
2014-10-07 11:48:08 +02:00
|
|
|
static INLINE int *cond_cost_list(const struct VP9_COMP *cpi, int *cost_list) {
|
|
|
|
return cpi->sf.mv.subpel_search_method != SUBPEL_TREE ? cost_list : NULL;
|
2014-08-27 23:06:30 +02:00
|
|
|
}
|
|
|
|
|
2014-01-18 21:16:11 +01:00
|
|
|
#ifdef __cplusplus
|
|
|
|
} // extern "C"
|
|
|
|
#endif
|
|
|
|
|
2014-04-19 03:27:47 +02:00
|
|
|
#endif // VP9_ENCODER_VP9_ENCODER_H_
|