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"
|
2015-08-06 21:53:59 +02:00
|
|
|
#if CONFIG_INTERNAL_STATS
|
|
|
|
#include "vpx_dsp/ssim.h"
|
|
|
|
#endif
|
|
|
|
#include "vpx_dsp/variance.h"
|
2016-05-05 21:04:42 +02:00
|
|
|
#include "vpx_ports/system_state.h"
|
2015-07-02 19:01:09 +02:00
|
|
|
#include "vpx_util/vpx_thread.h"
|
2014-01-28 21:57:49 +01:00
|
|
|
|
2015-02-18 18:40:34 +01:00
|
|
|
#include "vp9/common/vp9_alloccommon.h"
|
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"
|
2015-02-06 19:03:31 +01:00
|
|
|
#include "vp9/common/vp9_thread_common.h"
|
2012-11-27 22:59:17 +01:00
|
|
|
#include "vp9/common/vp9_onyxc_int.h"
|
2014-01-28 21:57:49 +01:00
|
|
|
|
2016-07-19 00:44:40 +02:00
|
|
|
#include "vp9/encoder/vp9_alt_ref_aq.h"
|
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"
|
2016-12-27 14:15:43 +01:00
|
|
|
#include "vp9/encoder/vp9_ethread.h"
|
2014-02-06 03:28:28 +01:00
|
|
|
#include "vp9/encoder/vp9_firstpass.h"
|
2016-12-27 14:15:43 +01:00
|
|
|
#include "vp9/encoder/vp9_job_queue.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"
|
2015-11-01 23:40:05 +01:00
|
|
|
#include "vp9/encoder/vp9_noise_estimate.h"
|
2014-01-28 21:57:49 +01:00
|
|
|
#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"
|
2015-01-06 23:14:26 +01:00
|
|
|
|
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
|
|
|
|
|
2016-05-05 21:04:42 +02:00
|
|
|
// vp9 uses 10,000,000 ticks/second as time stamp
|
|
|
|
#define TICKS_PER_SEC 10000000
|
|
|
|
|
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
|
|
|
|
2015-07-20 22:49:15 +02:00
|
|
|
vpx_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;
|
|
|
|
|
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 {
|
2016-07-27 05:43:23 +02:00
|
|
|
NORMAL = 0,
|
|
|
|
FOURFIVE = 1,
|
|
|
|
THREEFIVE = 2,
|
|
|
|
ONETWO = 3
|
2014-03-06 08:33:22 +01:00
|
|
|
} 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 {
|
2016-07-27 05:43:23 +02:00
|
|
|
FRAMEFLAGS_KEY = 1 << 0,
|
2014-03-15 01:38:15 +01:00
|
|
|
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,
|
2015-12-17 00:34:07 +01:00
|
|
|
EQUATOR360_AQ = 4,
|
2016-07-18 21:17:58 +02:00
|
|
|
// AQ based on lookahead temporal
|
|
|
|
// variance (only valid for altref frames)
|
|
|
|
LOOKAHEAD_AQ = 5,
|
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.
|
2016-07-27 05:43:23 +02: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.
|
2016-07-27 05:43:23 +02:00
|
|
|
double init_framerate; // set to passed in framerate
|
|
|
|
int64_t target_bandwidth; // bandwidth to be used in bits per second
|
2014-03-06 08:33:22 +01:00
|
|
|
|
|
|
|
int noise_sensitivity; // pre processing blur: recommendation 0
|
2016-07-27 05:43:23 +02:00
|
|
|
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
|
|
|
|
2016-07-18 21:17:58 +02:00
|
|
|
// Special handling of Adaptive Quantization for AltRef frames
|
|
|
|
int alt_ref_aq;
|
|
|
|
|
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
|
2016-07-27 05:43:23 +02:00
|
|
|
int two_pass_vbrbias; // two pass datarate control tweaks
|
2014-03-06 08:33:22 +01:00
|
|
|
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.
|
2015-05-22 01:15:37 +02:00
|
|
|
int layer_target_bitrate[VPX_MAX_LAYERS];
|
2014-03-06 08:33:22 +01:00
|
|
|
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_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;
|
|
|
|
|
2015-04-02 01:39:06 +02:00
|
|
|
int min_gf_interval;
|
|
|
|
int max_gf_interval;
|
|
|
|
|
2014-03-06 08:33:22 +01:00
|
|
|
int tile_columns;
|
|
|
|
int tile_rows;
|
|
|
|
|
2014-12-03 00:47:41 +01:00
|
|
|
int max_threads;
|
|
|
|
|
2016-12-02 19:11:33 +01:00
|
|
|
unsigned int target_level;
|
2016-05-06 00:37:37 +02:00
|
|
|
|
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
|
2015-01-13 19:07:20 +01:00
|
|
|
vpx_color_space_t color_space;
|
2015-10-17 01:25:08 +02:00
|
|
|
vpx_color_range_t color_range;
|
2015-09-26 03:51:55 +02:00
|
|
|
int render_width;
|
|
|
|
int render_height;
|
2015-05-22 01:15:37 +02:00
|
|
|
VP9E_TEMPORAL_LAYERING_MODE temporal_layering_mode;
|
2016-12-27 14:15:43 +01:00
|
|
|
|
|
|
|
int new_mt;
|
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];
|
2016-10-25 18:00:58 +02:00
|
|
|
int m_search_count;
|
|
|
|
int ex_search_count;
|
2016-12-27 14:15:43 +01:00
|
|
|
FIRSTPASS_DATA fp_data;
|
|
|
|
VP9RowMTSync row_mt_sync;
|
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;
|
|
|
|
|
2016-12-27 14:15:43 +01:00
|
|
|
typedef struct RowMTInfo {
|
|
|
|
JobQueueHandle job_queue_hdl;
|
|
|
|
#if CONFIG_MULTITHREAD
|
|
|
|
pthread_mutex_t job_mutex;
|
|
|
|
#endif
|
|
|
|
} RowMTInfo;
|
|
|
|
|
2017-02-02 09:49:29 +01:00
|
|
|
typedef struct {
|
|
|
|
TOKENEXTRA *start;
|
|
|
|
TOKENEXTRA *stop;
|
|
|
|
unsigned int count;
|
|
|
|
} TOKENLIST;
|
|
|
|
|
2016-12-27 14:15:43 +01:00
|
|
|
typedef struct MultiThreadHandle {
|
|
|
|
int allocated_tile_rows;
|
|
|
|
int allocated_tile_cols;
|
|
|
|
int allocated_vert_unit_rows;
|
|
|
|
|
|
|
|
// Frame level params
|
|
|
|
int num_tile_vert_sbs[MAX_NUM_TILE_ROWS];
|
|
|
|
|
|
|
|
// Job Queue structure and handles
|
|
|
|
JobQueue *job_queue;
|
|
|
|
|
|
|
|
int jobs_per_tile_col;
|
|
|
|
|
|
|
|
RowMTInfo row_mt_info[MAX_NUM_TILE_COLS];
|
|
|
|
int thread_id_to_tile_id[MAX_NUM_THREADS]; // Mapping of threads to tiles
|
|
|
|
} MultiThreadHandle;
|
|
|
|
|
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 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
|
|
|
|
2015-01-06 23:14:26 +01:00
|
|
|
struct EncWorkerData;
|
|
|
|
|
2015-03-11 00:08:17 +01:00
|
|
|
typedef struct ActiveMap {
|
|
|
|
int enabled;
|
|
|
|
int update;
|
|
|
|
unsigned char *map;
|
|
|
|
} ActiveMap;
|
|
|
|
|
2016-07-27 05:43:23 +02:00
|
|
|
typedef enum { Y, U, V, ALL } STAT_TYPE;
|
2015-04-22 15:45:56 +02:00
|
|
|
|
|
|
|
typedef struct IMAGE_STAT {
|
2016-07-27 05:43:23 +02:00
|
|
|
double stat[ALL + 1];
|
2015-04-22 15:45:56 +02:00
|
|
|
double worst;
|
|
|
|
} ImageStat;
|
|
|
|
|
2016-02-03 16:37:32 +01:00
|
|
|
// Kf noise filtering currently disabled by default in build.
|
|
|
|
// #define ENABLE_KF_DENOISE 1
|
|
|
|
|
2016-05-05 21:04:42 +02:00
|
|
|
#define CPB_WINDOW_SIZE 4
|
|
|
|
#define FRAME_WINDOW_SIZE 128
|
|
|
|
#define SAMPLE_RATE_GRACE_P 0.015
|
|
|
|
#define VP9_LEVELS 14
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
LEVEL_UNKNOWN = 0,
|
|
|
|
LEVEL_1 = 10,
|
|
|
|
LEVEL_1_1 = 11,
|
|
|
|
LEVEL_2 = 20,
|
|
|
|
LEVEL_2_1 = 21,
|
|
|
|
LEVEL_3 = 30,
|
|
|
|
LEVEL_3_1 = 31,
|
|
|
|
LEVEL_4 = 40,
|
|
|
|
LEVEL_4_1 = 41,
|
|
|
|
LEVEL_5 = 50,
|
|
|
|
LEVEL_5_1 = 51,
|
|
|
|
LEVEL_5_2 = 52,
|
|
|
|
LEVEL_6 = 60,
|
|
|
|
LEVEL_6_1 = 61,
|
|
|
|
LEVEL_6_2 = 62,
|
|
|
|
LEVEL_MAX = 255
|
|
|
|
} VP9_LEVEL;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
VP9_LEVEL level;
|
|
|
|
uint64_t max_luma_sample_rate;
|
|
|
|
uint32_t max_luma_picture_size;
|
|
|
|
double average_bitrate; // in kilobits per second
|
2016-07-27 05:43:23 +02:00
|
|
|
double max_cpb_size; // in kilobits
|
2016-05-05 21:04:42 +02:00
|
|
|
double compression_ratio;
|
|
|
|
uint8_t max_col_tiles;
|
|
|
|
uint32_t min_altref_distance;
|
|
|
|
uint8_t max_ref_frame_buffers;
|
|
|
|
} Vp9LevelSpec;
|
|
|
|
|
2016-12-02 19:11:33 +01:00
|
|
|
extern const Vp9LevelSpec vp9_level_defs[VP9_LEVELS];
|
|
|
|
|
2016-05-05 21:04:42 +02:00
|
|
|
typedef struct {
|
|
|
|
int64_t ts; // timestamp
|
|
|
|
uint32_t luma_samples;
|
|
|
|
uint32_t size; // in bytes
|
|
|
|
} FrameRecord;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
FrameRecord buf[FRAME_WINDOW_SIZE];
|
|
|
|
uint8_t start;
|
|
|
|
uint8_t len;
|
|
|
|
} FrameWindowBuffer;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
uint8_t seen_first_altref;
|
|
|
|
uint32_t frames_since_last_altref;
|
|
|
|
uint64_t total_compressed_size;
|
|
|
|
uint64_t total_uncompressed_size;
|
|
|
|
double time_encoded; // in seconds
|
|
|
|
FrameWindowBuffer frame_window_buffer;
|
|
|
|
int ref_refresh_map;
|
|
|
|
} Vp9LevelStats;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
Vp9LevelStats level_stats;
|
|
|
|
Vp9LevelSpec level_spec;
|
|
|
|
} Vp9LevelInfo;
|
|
|
|
|
2016-12-02 19:11:33 +01:00
|
|
|
typedef enum {
|
|
|
|
BITRATE_TOO_LARGE = 0,
|
|
|
|
LUMA_PIC_SIZE_TOO_LARGE = 1,
|
|
|
|
LUMA_SAMPLE_RATE_TOO_LARGE = 2,
|
|
|
|
CPB_TOO_LARGE = 3,
|
|
|
|
COMPRESSION_RATIO_TOO_SMALL = 4,
|
|
|
|
TOO_MANY_COLUMN_TILE = 5,
|
|
|
|
ALTREF_DIST_TOO_SMALL = 6,
|
|
|
|
TOO_MANY_REF_BUFFER = 7,
|
|
|
|
TARGET_LEVEL_FAIL_IDS = 8
|
|
|
|
} TARGET_LEVEL_FAIL_ID;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
int8_t level_index;
|
|
|
|
uint8_t rc_config_updated;
|
|
|
|
uint8_t fail_flag;
|
|
|
|
int max_frame_size; // in bits
|
|
|
|
double max_cpb_size; // in bits
|
|
|
|
} LevelConstraint;
|
|
|
|
|
2017-02-01 12:04:49 +01:00
|
|
|
typedef struct ARNRFilterData {
|
|
|
|
YV12_BUFFER_CONFIG *frames[MAX_LAG_BUFFERS];
|
|
|
|
int strength;
|
|
|
|
int frame_count;
|
|
|
|
int alt_ref_index;
|
|
|
|
struct scale_factors sf;
|
|
|
|
} ARNRFilterData;
|
|
|
|
|
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;
|
2015-06-29 18:27:11 +02:00
|
|
|
MB_MODE_INFO_EXT *mbmi_ext_base;
|
2015-02-20 19:58:12 +01:00
|
|
|
DECLARE_ALIGNED(16, int16_t, y_dequant[QINDEX_RANGE][8]);
|
|
|
|
DECLARE_ALIGNED(16, int16_t, uv_dequant[QINDEX_RANGE][8]);
|
2012-10-31 01:53:32 +01:00
|
|
|
VP9_COMMON common;
|
2014-04-18 20:01:36 +02:00
|
|
|
VP9EncoderConfig oxcf;
|
2016-07-27 05:43:23 +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;
|
2016-02-03 16:37:32 +01:00
|
|
|
#ifdef ENABLE_KF_DENOISE
|
|
|
|
YV12_BUFFER_CONFIG raw_unscaled_source;
|
|
|
|
YV12_BUFFER_CONFIG raw_scaled_source;
|
|
|
|
#endif
|
|
|
|
YV12_BUFFER_CONFIG *raw_source_frame;
|
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;
|
2015-06-11 20:30:18 +02:00
|
|
|
int allocated_tiles; // Keep track of memory allocated for tiles.
|
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
|
|
|
|
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];
|
2016-06-22 21:15:23 +02:00
|
|
|
uint32_t tok_count[4][1 << 6];
|
2017-02-02 09:49:29 +01:00
|
|
|
TOKENLIST *tplist[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
|
2014-12-19 17:58:05 +01:00
|
|
|
int64_t 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
|
|
|
|
2016-07-27 05:43:23 +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];
|
2016-07-27 05:43:23 +02:00
|
|
|
int mbgraph_n_frames; // number of frames filled in the above
|
|
|
|
int static_mb_pct; // % forced skip mbs by segmentation
|
2012-07-14 00:21:29 +02:00
|
|
|
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
|
|
|
|
2016-06-22 21:15:23 +02:00
|
|
|
uint32_t 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;
|
|
|
|
|
2016-06-22 21:15:23 +02:00
|
|
|
uint8_t *segmentation_map;
|
2011-09-13 12:26:39 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
// segment threashold for encode breakout
|
2016-06-22 21:20:06 +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;
|
2015-03-11 00:08:17 +01:00
|
|
|
ActiveMap active_map;
|
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
|
|
|
|
2016-07-16 00:38:52 +02:00
|
|
|
// Force recalculation of segment_ids for each mode info
|
|
|
|
uint8_t force_update_segmentation;
|
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
YV12_BUFFER_CONFIG alt_ref_buffer;
|
2014-08-26 08:27:08 +02:00
|
|
|
|
2016-07-19 00:44:40 +02:00
|
|
|
// class responsible for adaptive
|
|
|
|
// quantization of altref frames
|
|
|
|
struct ALT_REF_AQ *alt_ref_aq;
|
|
|
|
|
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];
|
|
|
|
|
2016-06-22 21:20:06 +02:00
|
|
|
int count;
|
2014-01-11 01:09:56 +01:00
|
|
|
uint64_t total_sq_error;
|
|
|
|
uint64_t total_samples;
|
2015-04-22 15:45:56 +02:00
|
|
|
ImageStat psnr;
|
2014-01-11 01:09:56 +01:00
|
|
|
|
|
|
|
uint64_t totalp_sq_error;
|
|
|
|
uint64_t totalp_samples;
|
2015-04-22 15:45:56 +02:00
|
|
|
ImageStat psnrp;
|
2014-01-11 01:09:56 +01:00
|
|
|
|
2015-04-17 20:13:18 +02:00
|
|
|
double total_blockiness;
|
2015-04-22 15:45:56 +02:00
|
|
|
double worst_blockiness;
|
2015-04-17 20:13:18 +02:00
|
|
|
|
2016-07-27 05:43:23 +02:00
|
|
|
int bytes;
|
2012-07-14 00:21:29 +02:00
|
|
|
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;
|
2015-04-22 15:45:56 +02:00
|
|
|
double worst_ssim;
|
2012-07-14 00:21:29 +02:00
|
|
|
|
2015-04-22 15:45:56 +02:00
|
|
|
ImageStat ssimg;
|
|
|
|
ImageStat fastssim;
|
|
|
|
ImageStat psnrhvs;
|
2015-04-17 19:27:56 +02:00
|
|
|
|
2012-07-14 00:21:29 +02:00
|
|
|
int b_calculate_ssimg;
|
2015-04-17 20:13:18 +02:00
|
|
|
int b_calculate_blockiness;
|
2015-04-22 15:45:56 +02:00
|
|
|
|
2015-04-21 19:05:37 +02:00
|
|
|
int b_calculate_consistency;
|
2015-04-22 15:45:56 +02:00
|
|
|
|
2015-04-21 19:05:37 +02:00
|
|
|
double total_inconsistency;
|
2015-04-22 15:45:56 +02:00
|
|
|
double worst_consistency;
|
2015-04-21 19:05:37 +02:00
|
|
|
Ssimv *ssim_vars;
|
|
|
|
Metrics metrics;
|
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];
|
2015-11-06 22:56:51 +01:00
|
|
|
int intra_uv_mode_cost[FRAME_TYPES][INTRA_MODES][INTRA_MODES];
|
2014-05-02 01:12:23 +02:00
|
|
|
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
|
|
|
|
2014-11-15 00:29:18 +01:00
|
|
|
int resize_pending;
|
2015-06-08 19:03:51 +02:00
|
|
|
int resize_state;
|
2016-02-11 01:59:09 +01:00
|
|
|
int external_resize;
|
2015-06-08 19:03:51 +02:00
|
|
|
int resize_scale_num;
|
|
|
|
int resize_scale_den;
|
|
|
|
int resize_avg_qp;
|
|
|
|
int resize_buffer_underflow;
|
|
|
|
int resize_count;
|
2014-11-15 00:29:18 +01:00
|
|
|
|
2016-02-01 20:52:49 +01:00
|
|
|
int use_skin_detection;
|
|
|
|
|
2016-05-06 00:37:37 +02:00
|
|
|
int target_level;
|
|
|
|
|
2015-11-01 23:40:05 +01:00
|
|
|
NOISE_ESTIMATE noise_estimate;
|
|
|
|
|
2016-04-21 23:00:26 +02:00
|
|
|
// Count on how many consecutive times a block uses small/zeromv for encoding.
|
|
|
|
uint8_t *consec_zero_mv;
|
|
|
|
|
2015-02-09 19:21:17 +01:00
|
|
|
// VAR_BASED_PARTITION thresholds
|
2015-04-02 22:57:22 +02:00
|
|
|
// 0 - threshold_64x64; 1 - threshold_32x32;
|
|
|
|
// 2 - threshold_16x16; 3 - vbp_threshold_8x8;
|
|
|
|
int64_t vbp_thresholds[4];
|
2015-04-16 02:48:20 +02:00
|
|
|
int64_t vbp_threshold_minmax;
|
|
|
|
int64_t vbp_threshold_sad;
|
2016-12-19 19:39:04 +01:00
|
|
|
// Threshold used for partition copy
|
|
|
|
int64_t vbp_threshold_copy;
|
2015-02-09 19:21:17 +01:00
|
|
|
BLOCK_SIZE vbp_bsize_min;
|
|
|
|
|
2014-12-03 00:47:41 +01:00
|
|
|
// Multi-threading
|
|
|
|
int num_workers;
|
2015-07-02 01:32:48 +02:00
|
|
|
VPxWorker *workers;
|
2015-01-06 23:14:26 +01:00
|
|
|
struct EncWorkerData *tile_thr_data;
|
|
|
|
VP9LfSync lf_row_sync;
|
2016-10-19 20:07:41 +02:00
|
|
|
struct VP9BitstreamWorkerData *vp9_bitstream_worker_data;
|
2016-05-05 21:04:42 +02:00
|
|
|
|
|
|
|
int keep_level_stats;
|
|
|
|
Vp9LevelInfo level_info;
|
2016-12-27 14:15:43 +01:00
|
|
|
MultiThreadHandle multi_thread_ctxt;
|
|
|
|
void (*row_mt_sync_read_ptr)(VP9RowMTSync *const, int, int);
|
|
|
|
void (*row_mt_sync_write_ptr)(VP9RowMTSync *const, int, int, const int);
|
2017-02-01 12:04:49 +01:00
|
|
|
ARNRFilterData arnr_filter_data;
|
2016-12-27 14:15:43 +01:00
|
|
|
int new_mt;
|
2016-12-19 19:39:04 +01:00
|
|
|
|
|
|
|
// Previous Partition Info
|
|
|
|
BLOCK_SIZE *prev_partition;
|
|
|
|
int8_t *prev_segment_id;
|
2017-01-13 20:28:27 +01:00
|
|
|
// Used to save the status of whether a block has a low variance in
|
|
|
|
// choose_partitioning. 0 for 64x64, 1~2 for 64x32, 3~4 for 32x64, 5~8 for
|
|
|
|
// 32x32, 9~24 for 16x16.
|
|
|
|
// This is for the last frame and is copied to the current frame
|
|
|
|
// when partition copy happens.
|
|
|
|
uint8_t *prev_variance_low;
|
2017-01-13 23:20:59 +01:00
|
|
|
uint8_t *copied_frame_cnt;
|
|
|
|
uint8_t max_copied_frame;
|
2016-12-02 19:11:33 +01:00
|
|
|
|
2017-01-17 19:39:26 +01:00
|
|
|
uint8_t *avg_source_sad_sb;
|
|
|
|
|
2016-12-02 19:11:33 +01:00
|
|
|
LevelConstraint level_constraint;
|
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
|
|
|
|
2015-01-27 21:26:28 +01:00
|
|
|
struct VP9_COMP *vp9_create_compressor(VP9EncoderConfig *oxcf,
|
|
|
|
BufferPool *const pool);
|
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
|
|
|
|
2016-07-27 05:43:23 +02: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..
|
2016-08-05 08:24:18 +02:00
|
|
|
int vp9_receive_raw_frame(VP9_COMP *cpi, vpx_enc_frame_flags_t frame_flags,
|
2014-03-06 08:33:22 +01:00
|
|
|
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,
|
2016-07-27 05:43:23 +02:00
|
|
|
size_t *size, uint8_t *dest, int64_t *time_stamp,
|
|
|
|
int64_t *time_end, int flush);
|
2014-03-06 08:33:22 +01:00
|
|
|
|
|
|
|
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
|
|
|
|
2015-03-20 22:55:43 +01:00
|
|
|
int vp9_get_active_map(VP9_COMP *cpi, unsigned char *map, int rows, int cols);
|
|
|
|
|
2016-07-27 05:43:23 +02:00
|
|
|
int vp9_set_internal_size(VP9_COMP *cpi, VPX_SCALING horiz_mode,
|
|
|
|
VPX_SCALING vert_mode);
|
2014-03-06 08:33:22 +01:00
|
|
|
|
|
|
|
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) {
|
2016-07-27 05:43:23 +02:00
|
|
|
return frame_is_intra_only(&cpi->common) || cpi->refresh_alt_ref_frame ||
|
2014-11-10 18:51:38 +01:00
|
|
|
(cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref);
|
|
|
|
}
|
|
|
|
|
2015-02-18 18:40:34 +01:00
|
|
|
static INLINE int get_ref_frame_map_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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-18 18:40:34 +01:00
|
|
|
static INLINE int get_ref_frame_buf_idx(const VP9_COMP *const cpi,
|
|
|
|
int ref_frame) {
|
|
|
|
const VP9_COMMON *const cm = &cpi->common;
|
|
|
|
const int map_idx = get_ref_frame_map_idx(cpi, ref_frame);
|
|
|
|
return (map_idx != INVALID_IDX) ? cm->ref_frame_map[map_idx] : INVALID_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) {
|
2015-01-27 21:26:28 +01:00
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
2015-02-18 18:40:34 +01:00
|
|
|
const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame);
|
2016-07-27 05:43:23 +02:00
|
|
|
return buf_idx != INVALID_IDX ? &cm->buffer_pool->frame_bufs[buf_idx].buf
|
|
|
|
: NULL;
|
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);
|
|
|
|
}
|
|
|
|
|
2017-02-02 09:49:29 +01:00
|
|
|
static INLINE void get_start_tok(VP9_COMP *cpi, int tile_row, int tile_col,
|
|
|
|
int mi_row, TOKENEXTRA **tok) {
|
|
|
|
VP9_COMMON *const cm = &cpi->common;
|
|
|
|
const int tile_cols = 1 << cm->log2_tile_cols;
|
|
|
|
TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col];
|
|
|
|
const TileInfo *const tile_info = &this_tile->tile_info;
|
|
|
|
|
|
|
|
int tile_mb_cols = (tile_info->mi_col_end - tile_info->mi_col_start + 1) >> 1;
|
|
|
|
const int mb_row = (mi_row - tile_info->mi_row_start) >> 1;
|
|
|
|
|
|
|
|
*tok =
|
|
|
|
cpi->tile_tok[tile_row][tile_col] + get_token_alloc(mb_row, tile_mb_cols);
|
|
|
|
}
|
|
|
|
|
2014-12-19 17:58:05 +01:00
|
|
|
int64_t 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
|
2014-12-19 17:58:05 +01:00
|
|
|
int64_t vp9_highbd_get_y_sse(const YV12_BUFFER_CONFIG *a,
|
|
|
|
const YV12_BUFFER_CONFIG *b);
|
2014-09-20 01:51:59 +02:00
|
|
|
#endif // CONFIG_VP9_HIGHBITDEPTH
|
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);
|
|
|
|
|
2016-02-25 17:38:08 +01:00
|
|
|
YV12_BUFFER_CONFIG *vp9_svc_twostage_scale(VP9_COMMON *cm,
|
|
|
|
YV12_BUFFER_CONFIG *unscaled,
|
|
|
|
YV12_BUFFER_CONFIG *scaled,
|
|
|
|
YV12_BUFFER_CONFIG *scaled_temp);
|
|
|
|
|
2014-04-18 19:59:15 +02:00
|
|
|
YV12_BUFFER_CONFIG *vp9_scale_if_required(VP9_COMMON *cm,
|
|
|
|
YV12_BUFFER_CONFIG *unscaled,
|
2015-09-14 19:13:33 +02:00
|
|
|
YV12_BUFFER_CONFIG *scaled,
|
|
|
|
int use_normative_scaler);
|
2014-04-18 19:59:15 +02:00
|
|
|
|
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) {
|
2015-05-22 01:15:37 +02:00
|
|
|
return cpi->use_svc && cpi->oxcf.pass != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static INLINE int is_one_pass_cbr_svc(const struct VP9_COMP *const cpi) {
|
|
|
|
return (cpi->use_svc && cpi->oxcf.pass == 0);
|
2014-08-07 00:20:51 +02:00
|
|
|
}
|
|
|
|
|
2016-12-21 23:33:21 +01:00
|
|
|
#if CONFIG_VP9_TEMPORAL_DENOISING
|
|
|
|
static INLINE int denoise_svc(const struct VP9_COMP *const cpi) {
|
|
|
|
return (!cpi->use_svc ||
|
|
|
|
(cpi->use_svc &&
|
|
|
|
cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2014-07-14 20:24:17 +02:00
|
|
|
static INLINE int is_altref_enabled(const VP9_COMP *const cpi) {
|
2016-08-03 02:37:32 +02:00
|
|
|
return !(cpi->oxcf.mode == REALTIME && cpi->oxcf.rc_mode == VPX_CBR) &&
|
|
|
|
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) {
|
2016-07-27 05:43:23 +02: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
|
|
|
}
|
|
|
|
|
2016-12-27 14:15:43 +01:00
|
|
|
static INLINE int get_num_vert_units(TileInfo tile, int shift) {
|
|
|
|
int num_vert_units =
|
|
|
|
(tile.mi_row_end - tile.mi_row_start + (1 << shift) - 1) >> shift;
|
|
|
|
return num_vert_units;
|
|
|
|
}
|
|
|
|
|
|
|
|
static INLINE int get_num_cols(TileInfo tile, int shift) {
|
|
|
|
int num_cols =
|
|
|
|
(tile.mi_col_end - tile.mi_col_start + (1 << shift) - 1) >> shift;
|
|
|
|
return num_cols;
|
|
|
|
}
|
|
|
|
|
2016-12-02 19:11:33 +01:00
|
|
|
static INLINE int get_level_index(VP9_LEVEL level) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < VP9_LEVELS; ++i) {
|
|
|
|
if (level == vp9_level_defs[i].level) return i;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2016-05-05 21:04:42 +02:00
|
|
|
VP9_LEVEL vp9_get_level(const Vp9LevelSpec *const level_spec);
|
|
|
|
|
2014-11-15 00:29:18 +01:00
|
|
|
void vp9_new_framerate(VP9_COMP *cpi, double framerate);
|
|
|
|
|
2015-05-22 01:15:37 +02:00
|
|
|
#define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl))
|
|
|
|
|
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_
|