vp9_encoder.h 18.2 KB
Newer Older
John Koleszar's avatar
John Koleszar committed
1
/*
2
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
John Koleszar's avatar
John Koleszar committed
3
 *
4
 *  Use of this source code is governed by a BSD-style license
5 6
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
7
 *  in the file PATENTS.  All contributing project authors may
8
 *  be found in the AUTHORS file in the root of the source tree.
John Koleszar's avatar
John Koleszar committed
9 10
 */

Dmitry Kovalev's avatar
Dmitry Kovalev committed
11 12
#ifndef VP9_ENCODER_VP9_ENCODER_H_
#define VP9_ENCODER_VP9_ENCODER_H_
John Koleszar's avatar
John Koleszar committed
13 14

#include <stdio.h>
15

16
#include "./vpx_config.h"
17 18
#include "vpx_ports/mem.h"
#include "vpx/internal/vpx_codec_internal.h"
19
#include "vpx/vp8cx.h"
20

21
#include "vp9/common/vp9_ppflags.h"
22 23
#include "vp9/common/vp9_entropy.h"
#include "vp9/common/vp9_entropymode.h"
24
#include "vp9/common/vp9_onyxc_int.h"
25

Marco Paniconi's avatar
Marco Paniconi committed
26
#include "vp9/encoder/vp9_aq_cyclicrefresh.h"
27
#include "vp9/encoder/vp9_encodemb.h"
28
#include "vp9/encoder/vp9_firstpass.h"
29
#include "vp9/encoder/vp9_lookahead.h"
30
#include "vp9/encoder/vp9_mbgraph.h"
31 32 33
#include "vp9/encoder/vp9_mcomp.h"
#include "vp9/encoder/vp9_quantize.h"
#include "vp9/encoder/vp9_ratectrl.h"
34
#include "vp9/encoder/vp9_speed_features.h"
35
#include "vp9/encoder/vp9_svc_layercontext.h"
36 37
#include "vp9/encoder/vp9_tokenize.h"
#include "vp9/encoder/vp9_variance.h"
John Koleszar's avatar
John Koleszar committed
38

39 40 41 42
#ifdef __cplusplus
extern "C" {
#endif

43
#define DEFAULT_GF_INTERVAL         10
John Koleszar's avatar
John Koleszar committed
44

45 46
#define MAX_MODES 30
#define MAX_REFS  6
47

John Koleszar's avatar
John Koleszar committed
48
typedef struct {
49 50 51
  int nmvjointcost[MV_JOINTS];
  int nmvcosts[2][MV_VALS];
  int nmvcosts_hp[2][MV_VALS];
John Koleszar's avatar
John Koleszar committed
52

53
  vp9_prob segment_pred_probs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
54

John Koleszar's avatar
John Koleszar committed
55
  unsigned char *last_frame_seg_map_copy;
56

John Koleszar's avatar
John Koleszar committed
57 58
  // 0 = Intra, Last, GF, ARF
  signed char last_ref_lf_deltas[MAX_REF_LF_DELTAS];
59
  // 0 = ZERO_MV, MV
John Koleszar's avatar
John Koleszar committed
60
  signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS];
John Koleszar's avatar
John Koleszar committed
61

62
  FRAME_CONTEXT fc;
John Koleszar's avatar
John Koleszar committed
63 64
} CODING_CONTEXT;

65 66
// This enumerator type needs to be kept aligned with the mode order in
// const MODE_DEFINITION vp9_mode_order[MAX_MODES] used in the rd code.
John Koleszar's avatar
John Koleszar committed
67 68
typedef enum {
  THR_NEARESTMV,
Paul Wilkins's avatar
Paul Wilkins committed
69 70
  THR_NEARESTA,
  THR_NEARESTG,
John Koleszar's avatar
John Koleszar committed
71

72 73 74
  THR_DC,

  THR_NEWMV,
Paul Wilkins's avatar
Paul Wilkins committed
75
  THR_NEWA,
76 77 78
  THR_NEWG,

  THR_NEARMV,
John Koleszar's avatar
John Koleszar committed
79
  THR_NEARA,
80 81
  THR_COMP_NEARESTLA,
  THR_COMP_NEARESTGA,
John Koleszar's avatar
John Koleszar committed
82 83

  THR_TM,
84

Paul Wilkins's avatar
Paul Wilkins committed
85 86 87 88 89
  THR_COMP_NEARLA,
  THR_COMP_NEWLA,
  THR_NEARG,
  THR_COMP_NEARGA,
  THR_COMP_NEWGA,
90

Paul Wilkins's avatar
Paul Wilkins committed
91 92 93
  THR_ZEROMV,
  THR_ZEROG,
  THR_ZEROA,
John Koleszar's avatar
John Koleszar committed
94 95
  THR_COMP_ZEROLA,
  THR_COMP_ZEROGA,
96

Paul Wilkins's avatar
Paul Wilkins committed
97 98 99
  THR_H_PRED,
  THR_V_PRED,
  THR_D135_PRED,
Dmitry Kovalev's avatar
Dmitry Kovalev committed
100
  THR_D207_PRED,
Paul Wilkins's avatar
Paul Wilkins committed
101 102 103 104
  THR_D153_PRED,
  THR_D63_PRED,
  THR_D117_PRED,
  THR_D45_PRED,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
105
} THR_MODES;
John Koleszar's avatar
John Koleszar committed
106

107 108 109 110 111 112 113 114 115
typedef enum {
  THR_LAST,
  THR_GOLD,
  THR_ALTR,
  THR_COMP_LA,
  THR_COMP_GA,
  THR_INTRA,
} THR_MODES_SUB8X8;

116 117 118 119 120 121 122 123 124
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;

125 126 127 128 129 130 131 132
typedef enum {
  NORMAL      = 0,
  FOURFIVE    = 1,
  THREEFIVE   = 2,
  ONETWO      = 3
} VPX_SCALING;

typedef enum {
133 134 135 136 137
  RC_MODE_VBR = 0,
  RC_MODE_CBR = 1,
  RC_MODE_CONSTRAINED_QUALITY = 2,
  RC_MODE_CONSTANT_QUALITY    = 3,
} RC_MODE;
138 139

typedef enum {
140 141 142
  // Good Quality Fast Encoding. The encoder balances quality with the
  // amount of time it takes to encode the output. (speed setting
  // controls how fast)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
143
  ONE_PASS_GOOD = 1,
144 145 146 147 148

  // One Pass - Best Quality. 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)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
149
  ONE_PASS_BEST = 2,
150 151 152

  // Two Pass - First Pass. The encoder generates a file of statistics
  // for use in the second encoding pass. (speed setting controls how fast)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
153
  TWO_PASS_FIRST = 3,
154 155 156 157

  // Two Pass - Second Pass. The encoder uses the statistics that were
  // generated in the first encoding pass to create the compressed
  // output. (speed setting controls how fast)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
158
  TWO_PASS_SECOND_GOOD = 4,
159 160 161 162 163

  // Two Pass - Second Pass Best.  The encoder uses the statistics that
  // were generated in the first encoding pass to create the compressed
  // output using the highest possible quality, and taking a
  // longer amount of time to encode. (speed setting ignored)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
164
  TWO_PASS_SECOND_BEST = 5,
165 166 167 168

  // 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)
Dmitry Kovalev's avatar
Dmitry Kovalev committed
169
  REALTIME = 6,
170 171 172
} MODE;

typedef enum {
173 174 175
  FRAMEFLAGS_KEY    = 1 << 0,
  FRAMEFLAGS_GOLDEN = 1 << 1,
  FRAMEFLAGS_ALTREF = 1 << 2,
176 177 178 179 180 181
} FRAMETYPE_FLAGS;

typedef enum {
  NO_AQ = 0,
  VARIANCE_AQ = 1,
  COMPLEXITY_AQ = 2,
182
  CYCLIC_REFRESH_AQ = 3,
183 184
  AQ_MODE_COUNT  // This should always be the last member of the enum
} AQ_MODE;
185

Dmitry Kovalev's avatar
Dmitry Kovalev committed
186

187
typedef struct VP9EncoderConfig {
188 189
  BITSTREAM_PROFILE profile;
  BIT_DEPTH bit_depth;
190 191 192 193 194 195 196
  int width;  // width of data passed to the compressor
  int height;  // height of data passed to the compressor
  double framerate;  // set to passed in framerate
  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:
197
  int speed;
198 199
  unsigned int rc_max_intra_bitrate_pct;

200
  MODE mode;
201 202 203 204 205 206 207 208 209 210

  // 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

211
  RC_MODE rc_mode;  // vbr, cbr, constrained quality or constant quality
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230

  // buffer targeting aggressiveness
  int under_shoot_pct;
  int over_shoot_pct;

  // buffering parameters
  int64_t starting_buffer_level;  // in seconds
  int64_t optimal_buffer_level;
  int64_t maximum_buffer_size;

  // Frame drop threshold.
  int drop_frames_water_mark;

  // controlling quality
  int fixed_q;
  int worst_allowed_q;
  int best_allowed_q;
  int cq_level;
  int lossless;
231
  AQ_MODE aq_mode;  // Adaptive Quantization mode
232

233 234 235 236 237
  // Internal frame size scaling.
  int allow_spatial_resampling;
  int scaled_frame_width;
  int scaled_frame_height;

238 239 240
  // Enable feature to reduce the frame quantization every x frames.
  int frame_periodic_boost;

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
  // 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];
  // 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];

  // these parameters aren't to be used in final build don't use!!!
  int play_alternate;
  int alt_freq;

  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;
277
  int arnr_type;
278 279 280 281 282 283 284 285

  int tile_columns;
  int tile_rows;

  struct vpx_fixed_buf         two_pass_stats_in;
  struct vpx_codec_pkt_list  *output_pkt_list;

  vp8e_tuning tuning;
286
} VP9EncoderConfig;
287

288 289 290
static INLINE int is_best_mode(MODE mode) {
  return mode == ONE_PASS_BEST || mode == TWO_PASS_SECOND_BEST;
}
Dmitry Kovalev's avatar
Dmitry Kovalev committed
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317

typedef struct RD_OPT {
  // Thresh_mult is used to set a threshold for the rd score. A higher value
  // means that we will accept the best mode so far more often. This number
  // is used in combination with the current block size, and thresh_freq_fact
  // to pick a threshold.
  int thresh_mult[MAX_MODES];
  int thresh_mult_sub8x8[MAX_REFS];

  int threshes[MAX_SEGMENTS][BLOCK_SIZES][MAX_MODES];
  int thresh_freq_fact[BLOCK_SIZES][MAX_MODES];

  int64_t comp_pred_diff[REFERENCE_MODES];
  int64_t prediction_type_threshes[MAX_REF_FRAMES][REFERENCE_MODES];
  int64_t tx_select_diff[TX_MODES];
  // FIXME(rbultje) can this overflow?
  int tx_select_threshes[MAX_REF_FRAMES][TX_MODES];

  int64_t filter_diff[SWITCHABLE_FILTER_CONTEXTS];
  int64_t filter_threshes[MAX_REF_FRAMES][SWITCHABLE_FILTER_CONTEXTS];
  int64_t filter_cache[SWITCHABLE_FILTER_CONTEXTS];
  int64_t mask_filter;

  int RDMULT;
  int RDDIV;
} RD_OPT;

318
typedef struct VP9_COMP {
319
  QUANTS quants;
John Koleszar's avatar
John Koleszar committed
320
  MACROBLOCK mb;
321
  VP9_COMMON common;
322
  VP9EncoderConfig oxcf;
John Koleszar's avatar
John Koleszar committed
323 324
  struct lookahead_ctx    *lookahead;
  struct lookahead_entry  *source;
325
#if CONFIG_MULTIPLE_ARF
Dmitry Kovalev's avatar
Dmitry Kovalev committed
326
  struct lookahead_entry  *alt_ref_source[REF_FRAMES];
327
#else
John Koleszar's avatar
John Koleszar committed
328
  struct lookahead_entry  *alt_ref_source;
329
#endif
330
  struct lookahead_entry  *last_source;
John Koleszar's avatar
John Koleszar committed
331

John Koleszar's avatar
John Koleszar committed
332
  YV12_BUFFER_CONFIG *Source;
333
  YV12_BUFFER_CONFIG *Last_Source;  // NULL for first frame and alt_ref frames
John Koleszar's avatar
John Koleszar committed
334 335
  YV12_BUFFER_CONFIG *un_scaled_source;
  YV12_BUFFER_CONFIG scaled_source;
336 337
  YV12_BUFFER_CONFIG *unscaled_last_source;
  YV12_BUFFER_CONFIG scaled_last_source;
John Koleszar's avatar
John Koleszar committed
338

339 340
  int gold_is_last;  // gold same as last frame ( short circuit gold searches)
  int alt_is_last;  // Alt same as last ( short circuit altref search)
John Koleszar's avatar
John Koleszar committed
341
  int gold_is_alt;  // don't do both alt and gold search ( just do gold).
John Koleszar's avatar
John Koleszar committed
342

343
  int scaled_ref_idx[3];
344 345 346
  int lst_fb_idx;
  int gld_fb_idx;
  int alt_fb_idx;
347

348
#if CONFIG_MULTIPLE_ARF
Dmitry Kovalev's avatar
Dmitry Kovalev committed
349
  int alt_ref_fb_idx[REF_FRAMES - 3];
350
#endif
351 352 353
  int refresh_last_frame;
  int refresh_golden_frame;
  int refresh_alt_ref_frame;
Deb Mukherjee's avatar
Deb Mukherjee committed
354 355 356 357 358 359 360 361 362

  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;

John Koleszar's avatar
John Koleszar committed
363
  YV12_BUFFER_CONFIG last_frame_uf;
John Koleszar's avatar
John Koleszar committed
364

John Koleszar's avatar
John Koleszar committed
365
  TOKENEXTRA *tok;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
366
  unsigned int tok_count[4][1 << 6];
John Koleszar's avatar
John Koleszar committed
367

368 369 370 371 372 373
#if CONFIG_MULTIPLE_ARF
  // Position within a frame coding order (including any additional ARF frames).
  unsigned int sequence_number;
  // Next frame in naturally occurring order that has not yet been coded.
  int next_frame_in_order;
#endif
John Koleszar's avatar
John Koleszar committed
374

John Koleszar's avatar
John Koleszar committed
375 376
  // Ambient reconstruction err target for force key frames
  int ambient_err;
377

Dmitry Kovalev's avatar
Dmitry Kovalev committed
378
  RD_OPT rd;
John Koleszar's avatar
John Koleszar committed
379

John Koleszar's avatar
John Koleszar committed
380
  CODING_CONTEXT coding_context;
John Koleszar's avatar
John Koleszar committed
381

382 383
  int zbin_mode_boost;
  int zbin_mode_boost_enabled;
John Koleszar's avatar
John Koleszar committed
384
  int active_arnr_frames;           // <= cpi->oxcf.arnr_max_frames
385
  int active_arnr_strength;         // <= cpi->oxcf.arnr_max_strength
John Koleszar's avatar
John Koleszar committed
386

John Koleszar's avatar
John Koleszar committed
387 388 389
  int64_t last_time_stamp_seen;
  int64_t last_end_time_stamp_seen;
  int64_t first_time_stamp_ever;
John Koleszar's avatar
John Koleszar committed
390

391
  RATE_CONTROL rc;
John Koleszar's avatar
John Koleszar committed
392

393 394
  vp9_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
  vp9_coeff_probs_model frame_coef_probs[TX_SIZES][PLANE_TYPES];
395

John Koleszar's avatar
John Koleszar committed
396
  struct vpx_codec_pkt_list  *output_pkt_list;
397

John Koleszar's avatar
John Koleszar committed
398 399 400 401 402
  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 pass;
John Koleszar's avatar
John Koleszar committed
403

John Koleszar's avatar
John Koleszar committed
404
  int ref_frame_flags;
John Koleszar's avatar
John Koleszar committed
405

John Koleszar's avatar
John Koleszar committed
406
  SPEED_FEATURES sf;
John Koleszar's avatar
John Koleszar committed
407

Paul Wilkins's avatar
Paul Wilkins committed
408
  unsigned int max_mv_magnitude;
409
  int mv_step_param;
Paul Wilkins's avatar
Paul Wilkins committed
410

411 412 413 414 415 416 417
  // Default value is 1. From first pass stats, encode_breakout may be disabled.
  ENCODE_BREAKOUT_TYPE allow_encode_breakout;

  // Get threshold from external input. In real time mode, it can be
  // overwritten according to encoding speed.
  int encode_breakout;

John Koleszar's avatar
John Koleszar committed
418
  unsigned char *segmentation_map;
Paul Wilkins's avatar
Paul Wilkins committed
419

John Koleszar's avatar
John Koleszar committed
420
  // segment threashold for encode breakout
Paul Wilkins's avatar
Paul Wilkins committed
421
  int  segment_encode_breakout[MAX_SEGMENTS];
John Koleszar's avatar
John Koleszar committed
422

423 424
  unsigned char *complexity_map;

John Koleszar's avatar
John Koleszar committed
425 426
  unsigned char *active_map;
  unsigned int active_map_enabled;
John Koleszar's avatar
John Koleszar committed
427

428
  CYCLIC_REFRESH *cyclic_refresh;
429

John Koleszar's avatar
John Koleszar committed
430
  fractional_mv_step_fp *find_fractional_mv_step;
431
  fractional_mv_step_comp_fp *find_fractional_mv_step_comp;
432 433 434
  vp9_full_search_fn_t full_search_sad;
  vp9_refining_search_fn_t refining_search_sad;
  vp9_diamond_search_fn_t diamond_search_sad;
435
  vp9_variance_fn_ptr_t fn_ptr[BLOCK_SIZES];
Yaowu Xu's avatar
Yaowu Xu committed
436 437 438
  uint64_t time_receive_data;
  uint64_t time_compress_data;
  uint64_t time_pick_lpf;
439
  uint64_t time_encode_sb_row;
John Koleszar's avatar
John Koleszar committed
440

441
  struct twopass_rc twopass;
John Koleszar's avatar
John Koleszar committed
442

John Koleszar's avatar
John Koleszar committed
443 444
  YV12_BUFFER_CONFIG alt_ref_buffer;
  YV12_BUFFER_CONFIG *frames[MAX_LAG_BUFFERS];
John Koleszar's avatar
John Koleszar committed
445

446
#if CONFIG_INTERNAL_STATS
447 448
  unsigned int mode_chosen_counts[MAX_MODES];

John Koleszar's avatar
John Koleszar committed
449 450 451 452 453
  int    count;
  double total_y;
  double total_u;
  double total_v;
  double total;
454 455 456
  uint64_t total_sq_error;
  uint64_t total_samples;

John Koleszar's avatar
John Koleszar committed
457 458 459 460
  double totalp_y;
  double totalp_u;
  double totalp_v;
  double totalp;
461 462 463
  uint64_t totalp_sq_error;
  uint64_t totalp_samples;

John Koleszar's avatar
John Koleszar committed
464 465 466
  int    bytes;
  double summed_quality;
  double summed_weights;
467 468
  double summedp_quality;
  double summedp_weights;
John Koleszar's avatar
John Koleszar committed
469 470 471 472 473 474 475 476 477
  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;
John Koleszar's avatar
John Koleszar committed
478
#endif
John Koleszar's avatar
John Koleszar committed
479
  int b_calculate_psnr;
480

John Koleszar's avatar
John Koleszar committed
481
  int droppable;
Adrian Grange's avatar
Adrian Grange committed
482

John Koleszar's avatar
John Koleszar committed
483
  int dummy_packing;    /* flag to indicate if packing is dummy */
484

Dmitry Kovalev's avatar
Dmitry Kovalev committed
485
  unsigned int tx_stepdown_count[TX_SIZES];
Deb Mukherjee's avatar
Deb Mukherjee committed
486

487 488
  int initial_width;
  int initial_height;
489

490 491
  int use_svc;

492
  SVC svc;
493

494 495
  int use_large_partition_rate;

496 497
  int frame_flags;

498 499
  search_site_config ss_cfg;

500 501 502 503 504 505
  int mbmode_cost[INTRA_MODES];
  unsigned inter_mode_cost[INTER_MODE_CONTEXTS][INTER_MODES];
  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];

506 507 508 509 510 511 512 513 514 515 516 517
#if CONFIG_MULTIPLE_ARF
  // ARF tracking variables.
  int multi_arf_enabled;
  unsigned int frame_coding_order_period;
  unsigned int new_frame_coding_order_period;
  int frame_coding_order[MAX_LAG_BUFFERS * 2];
  int arf_buffer_idx[MAX_LAG_BUFFERS * 3 / 2];
  int arf_weight[MAX_LAG_BUFFERS];
  int arf_buffered;
  int this_frame_weight;
  int max_arf_level;
#endif
518
} VP9_COMP;
John Koleszar's avatar
John Koleszar committed
519

520 521
void vp9_initialize_enc();

522
struct VP9_COMP *vp9_create_compressor(VP9EncoderConfig *oxcf);
523 524
void vp9_remove_compressor(VP9_COMP *cpi);

525
void vp9_change_config(VP9_COMP *cpi, const VP9EncoderConfig *oxcf);
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541

  // 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);

542
void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags);
543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573

int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
                           YV12_BUFFER_CONFIG *sd);

int vp9_get_reference_enc(VP9_COMP *cpi, int index,
                          YV12_BUFFER_CONFIG **fb);

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);

int vp9_set_roimap(VP9_COMP *cpi, unsigned char *map,
                   unsigned int rows, unsigned int cols,
                   int delta_q[MAX_SEGMENTS],
                   int delta_lf[MAX_SEGMENTS],
                   unsigned int threshold[MAX_SEGMENTS]);

int vp9_set_active_map(VP9_COMP *cpi, unsigned char *map,
                       unsigned int rows, unsigned int cols);

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);

574 575
static INLINE int get_ref_frame_idx(const VP9_COMP *cpi,
                                    MV_REFERENCE_FRAME ref_frame) {
576 577 578 579 580 581 582 583 584
  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;
  }
}

585 586 587 588 589
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;
590 591
}

592 593
// Intra only frames, golden frames (except alt ref overlays) and
// alt ref frames tend to be coded at a higher than ambient quality
594
static INLINE int frame_is_boosted(const VP9_COMP *cpi) {
595
  return frame_is_intra_only(&cpi->common) || cpi->refresh_alt_ref_frame ||
596 597
         (cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref) ||
         vp9_is_upper_layer_key_frame(cpi);
598 599
}

600 601 602 603 604 605 606 607 608 609
static INLINE int get_token_alloc(int mb_rows, int mb_cols) {
  // TODO(JBB): make this work for alpha channel and double check we can't
  // exceed this token count if we have a 32x32 transform crossing a boundary
  // at a multiple of 16.
  // 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);
}

610
int vp9_get_y_sse(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b);
611

612
void vp9_alloc_compressor_data(VP9_COMP *cpi);
613

614 615 616 617
void vp9_scale_references(VP9_COMP *cpi);

void vp9_update_reference_frames(VP9_COMP *cpi);

618 619
int64_t vp9_rescale(int64_t val, int64_t num, int denom);

620 621 622 623
YV12_BUFFER_CONFIG *vp9_scale_if_required(VP9_COMMON *cm,
                                          YV12_BUFFER_CONFIG *unscaled,
                                          YV12_BUFFER_CONFIG *scaled);

624 625 626
static INLINE void set_ref_ptrs(VP9_COMMON *cm, MACROBLOCKD *xd,
                                MV_REFERENCE_FRAME ref0,
                                MV_REFERENCE_FRAME ref1) {
627 628 629 630
  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];
631 632
}

633 634 635 636
#ifdef __cplusplus
}  // extern "C"
#endif

Dmitry Kovalev's avatar
Dmitry Kovalev committed
637
#endif  // VP9_ENCODER_VP9_ENCODER_H_