vp9_encoder.h 16.3 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_context_tree.h"
28
#include "vp9/encoder/vp9_encodemb.h"
29
#include "vp9/encoder/vp9_firstpass.h"
30
#include "vp9/encoder/vp9_lookahead.h"
31
#include "vp9/encoder/vp9_mbgraph.h"
32 33 34
#include "vp9/encoder/vp9_mcomp.h"
#include "vp9/encoder/vp9_quantize.h"
#include "vp9/encoder/vp9_ratectrl.h"
35
#include "vp9/encoder/vp9_rd.h"
36
#include "vp9/encoder/vp9_speed_features.h"
37
#include "vp9/encoder/vp9_svc_layercontext.h"
38 39
#include "vp9/encoder/vp9_tokenize.h"
#include "vp9/encoder/vp9_variance.h"
Tim Kopp's avatar
Tim Kopp committed
40 41 42
#if CONFIG_DENOISING
#include "vp9/encoder/vp9_denoiser.h"
#endif
John Koleszar's avatar
John Koleszar committed
43

44 45 46 47
#ifdef __cplusplus
extern "C" {
#endif

48
#define DEFAULT_GF_INTERVAL         10
John Koleszar's avatar
John Koleszar committed
49

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

55
  vp9_prob segment_pred_probs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
56

John Koleszar's avatar
John Koleszar committed
57
  unsigned char *last_frame_seg_map_copy;
58

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

64
  FRAME_CONTEXT fc;
John Koleszar's avatar
John Koleszar committed
65 66
} CODING_CONTEXT;

67

68 69 70 71 72 73 74 75 76
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;

77 78 79 80 81 82 83 84
typedef enum {
  NORMAL      = 0,
  FOURFIVE    = 1,
  THREEFIVE   = 2,
  ONETWO      = 3
} VPX_SCALING;

typedef enum {
85 86 87
  // 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
88
  ONE_PASS_GOOD = 1,
89 90 91 92 93

  // 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
94
  ONE_PASS_BEST = 2,
95 96 97

  // 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
98
  TWO_PASS_FIRST = 3,
99 100 101 102

  // 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
103
  TWO_PASS_SECOND_GOOD = 4,
104 105 106 107 108

  // 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
109
  TWO_PASS_SECOND_BEST = 5,
110 111 112 113

  // 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
114
  REALTIME = 6,
115 116 117
} MODE;

typedef enum {
118 119 120
  FRAMEFLAGS_KEY    = 1 << 0,
  FRAMEFLAGS_GOLDEN = 1 << 1,
  FRAMEFLAGS_ALTREF = 1 << 2,
121 122 123 124 125 126
} FRAMETYPE_FLAGS;

typedef enum {
  NO_AQ = 0,
  VARIANCE_AQ = 1,
  COMPLEXITY_AQ = 2,
127
  CYCLIC_REFRESH_AQ = 3,
128 129
  AQ_MODE_COUNT  // This should always be the last member of the enum
} AQ_MODE;
130

Dmitry Kovalev's avatar
Dmitry Kovalev committed
131

132
typedef struct VP9EncoderConfig {
133 134
  BITSTREAM_PROFILE profile;
  BIT_DEPTH bit_depth;
135 136 137 138 139 140 141
  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:
142
  int speed;
143 144
  unsigned int rc_max_intra_bitrate_pct;

145
  MODE mode;
146 147 148 149 150 151 152 153 154 155

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

156 157
  // vbr, cbr, constrained quality or constant quality
  enum vpx_rc_mode rc_mode;
158 159 160 161 162 163

  // buffer targeting aggressiveness
  int under_shoot_pct;
  int over_shoot_pct;

  // buffering parameters
164 165 166
  int64_t starting_buffer_level_ms;
  int64_t optimal_buffer_level_ms;
  int64_t maximum_buffer_size_ms;
167 168 169 170 171 172 173 174 175

  // Frame drop threshold.
  int drop_frames_water_mark;

  // controlling quality
  int fixed_q;
  int worst_allowed_q;
  int best_allowed_q;
  int cq_level;
176
  AQ_MODE aq_mode;  // Adaptive Quantization mode
177

178 179 180 181 182
  // Internal frame size scaling.
  int allow_spatial_resampling;
  int scaled_frame_width;
  int scaled_frame_height;

183 184 185
  // Enable feature to reduce the frame quantization every x frames.
  int frame_periodic_boost;

186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
  // 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 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;
221
  int arnr_type;
222 223 224 225 226 227 228 229

  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;
230
} VP9EncoderConfig;
231

232 233 234 235
static INLINE int is_altref_enabled(const VP9EncoderConfig *cfg) {
  return cfg->mode != REALTIME && cfg->play_alternate && cfg->lag_in_frames > 0;
}

236 237 238 239
static INLINE int is_lossless_requested(const VP9EncoderConfig *cfg) {
  return cfg->best_allowed_q == 0 && cfg->worst_allowed_q == 0;
}

240 241 242
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
243

244
typedef struct VP9_COMP {
245
  QUANTS quants;
John Koleszar's avatar
John Koleszar committed
246
  MACROBLOCK mb;
247
  VP9_COMMON common;
248
  VP9EncoderConfig oxcf;
John Koleszar's avatar
John Koleszar committed
249 250 251
  struct lookahead_ctx    *lookahead;
  struct lookahead_entry  *source;
  struct lookahead_entry  *alt_ref_source;
252
  struct lookahead_entry  *last_source;
John Koleszar's avatar
John Koleszar committed
253

John Koleszar's avatar
John Koleszar committed
254
  YV12_BUFFER_CONFIG *Source;
255
  YV12_BUFFER_CONFIG *Last_Source;  // NULL for first frame and alt_ref frames
John Koleszar's avatar
John Koleszar committed
256 257
  YV12_BUFFER_CONFIG *un_scaled_source;
  YV12_BUFFER_CONFIG scaled_source;
258 259
  YV12_BUFFER_CONFIG *unscaled_last_source;
  YV12_BUFFER_CONFIG scaled_last_source;
John Koleszar's avatar
John Koleszar committed
260

261 262
  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
263
  int gold_is_alt;  // don't do both alt and gold search ( just do gold).
John Koleszar's avatar
John Koleszar committed
264

265 266
  int skippable_frame;

267
  int scaled_ref_idx[3];
268 269 270
  int lst_fb_idx;
  int gld_fb_idx;
  int alt_fb_idx;
271

272 273 274
  int refresh_last_frame;
  int refresh_golden_frame;
  int refresh_alt_ref_frame;
Deb Mukherjee's avatar
Deb Mukherjee committed
275 276 277 278 279 280 281 282 283

  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
284
  YV12_BUFFER_CONFIG last_frame_uf;
John Koleszar's avatar
John Koleszar committed
285

John Koleszar's avatar
John Koleszar committed
286
  TOKENEXTRA *tok;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
287
  unsigned int tok_count[4][1 << 6];
John Koleszar's avatar
John Koleszar committed
288

John Koleszar's avatar
John Koleszar committed
289 290
  // Ambient reconstruction err target for force key frames
  int ambient_err;
291

Dmitry Kovalev's avatar
Dmitry Kovalev committed
292
  RD_OPT rd;
John Koleszar's avatar
John Koleszar committed
293

John Koleszar's avatar
John Koleszar committed
294
  CODING_CONTEXT coding_context;
John Koleszar's avatar
John Koleszar committed
295

296 297
  int zbin_mode_boost;
  int zbin_mode_boost_enabled;
John Koleszar's avatar
John Koleszar committed
298
  int active_arnr_frames;           // <= cpi->oxcf.arnr_max_frames
299
  int active_arnr_strength;         // <= cpi->oxcf.arnr_max_strength
John Koleszar's avatar
John Koleszar committed
300

John Koleszar's avatar
John Koleszar committed
301 302 303
  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
304

305
  RATE_CONTROL rc;
John Koleszar's avatar
John Koleszar committed
306

307
  vp9_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
308

John Koleszar's avatar
John Koleszar committed
309
  struct vpx_codec_pkt_list  *output_pkt_list;
310

John Koleszar's avatar
John Koleszar committed
311 312 313 314 315
  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
316

John Koleszar's avatar
John Koleszar committed
317
  int ref_frame_flags;
John Koleszar's avatar
John Koleszar committed
318

John Koleszar's avatar
John Koleszar committed
319
  SPEED_FEATURES sf;
John Koleszar's avatar
John Koleszar committed
320

Paul Wilkins's avatar
Paul Wilkins committed
321
  unsigned int max_mv_magnitude;
322
  int mv_step_param;
Paul Wilkins's avatar
Paul Wilkins committed
323

324 325 326
  // Default value is 1. From first pass stats, encode_breakout may be disabled.
  ENCODE_BREAKOUT_TYPE allow_encode_breakout;

327 328
  // Get threshold from external input. A suggested threshold is 800 for HD
  // clips, and 300 for < HD clips.
329 330
  int encode_breakout;

John Koleszar's avatar
John Koleszar committed
331
  unsigned char *segmentation_map;
Paul Wilkins's avatar
Paul Wilkins committed
332

John Koleszar's avatar
John Koleszar committed
333
  // segment threashold for encode breakout
Paul Wilkins's avatar
Paul Wilkins committed
334
  int  segment_encode_breakout[MAX_SEGMENTS];
John Koleszar's avatar
John Koleszar committed
335

336 337
  unsigned char *complexity_map;

338
  CYCLIC_REFRESH *cyclic_refresh;
339

John Koleszar's avatar
John Koleszar committed
340
  fractional_mv_step_fp *find_fractional_mv_step;
341 342 343
  vp9_full_search_fn_t full_search_sad;
  vp9_refining_search_fn_t refining_search_sad;
  vp9_diamond_search_fn_t diamond_search_sad;
344
  vp9_variance_fn_ptr_t fn_ptr[BLOCK_SIZES];
Yaowu Xu's avatar
Yaowu Xu committed
345 346 347
  uint64_t time_receive_data;
  uint64_t time_compress_data;
  uint64_t time_pick_lpf;
348
  uint64_t time_encode_sb_row;
John Koleszar's avatar
John Koleszar committed
349

350 351 352 353
#if CONFIG_FP_MB_STATS
  int use_fp_mb_stats;
#endif

Paul Wilkins's avatar
Paul Wilkins committed
354
  TWO_PASS twopass;
John Koleszar's avatar
John Koleszar committed
355

John Koleszar's avatar
John Koleszar committed
356 357
  YV12_BUFFER_CONFIG alt_ref_buffer;
  YV12_BUFFER_CONFIG *frames[MAX_LAG_BUFFERS];
John Koleszar's avatar
John Koleszar committed
358

359
#if CONFIG_INTERNAL_STATS
360 361
  unsigned int mode_chosen_counts[MAX_MODES];

John Koleszar's avatar
John Koleszar committed
362 363 364 365 366
  int    count;
  double total_y;
  double total_u;
  double total_v;
  double total;
367 368 369
  uint64_t total_sq_error;
  uint64_t total_samples;

John Koleszar's avatar
John Koleszar committed
370 371 372 373
  double totalp_y;
  double totalp_u;
  double totalp_v;
  double totalp;
374 375 376
  uint64_t totalp_sq_error;
  uint64_t totalp_samples;

John Koleszar's avatar
John Koleszar committed
377 378 379
  int    bytes;
  double summed_quality;
  double summed_weights;
380 381
  double summedp_quality;
  double summedp_weights;
John Koleszar's avatar
John Koleszar committed
382 383 384 385 386 387 388 389 390
  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
391
#endif
John Koleszar's avatar
John Koleszar committed
392
  int b_calculate_psnr;
393

John Koleszar's avatar
John Koleszar committed
394
  int droppable;
Adrian Grange's avatar
Adrian Grange committed
395

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
398
  unsigned int tx_stepdown_count[TX_SIZES];
Deb Mukherjee's avatar
Deb Mukherjee committed
399

400 401
  int initial_width;
  int initial_height;
402

403 404
  int use_svc;

405
  SVC svc;
406

407 408 409 410 411
  // 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;
412

413 414
  int frame_flags;

415 416
  search_site_config ss_cfg;

417 418 419 420 421 422
  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];

423 424 425 426 427
  PICK_MODE_CONTEXT *leaf_tree;
  PC_TREE *pc_tree;
  PC_TREE *pc_root;
  int partition_cost[PARTITION_CONTEXTS][PARTITION_TYPES];

428
  int multi_arf_allowed;
429
  int multi_arf_enabled;
430
  int multi_arf_last_grp_enabled;
Tim Kopp's avatar
Tim Kopp committed
431 432 433 434

#if CONFIG_DENOISING
  VP9_DENOISER denoiser;
#endif
435
} VP9_COMP;
John Koleszar's avatar
John Koleszar committed
436

437 438
void vp9_initialize_enc();

439
struct VP9_COMP *vp9_create_compressor(VP9EncoderConfig *oxcf);
440 441
void vp9_remove_compressor(VP9_COMP *cpi);

442
void vp9_change_config(VP9_COMP *cpi, const VP9EncoderConfig *oxcf);
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458

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

459
void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags);
460 461 462 463 464 465 466 467 468 469 470 471

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

472
int vp9_set_active_map(VP9_COMP *cpi, unsigned char *map, int rows, int cols);
473 474 475 476 477 478 479 480 481 482 483

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

484 485
static INLINE int get_ref_frame_idx(const VP9_COMP *cpi,
                                    MV_REFERENCE_FRAME ref_frame) {
486 487 488 489 490 491 492 493 494
  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;
  }
}

495 496 497 498 499
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;
500 501
}

502 503
// Intra only frames, golden frames (except alt ref overlays) and
// alt ref frames tend to be coded at a higher than ambient quality
504
static INLINE int frame_is_boosted(const VP9_COMP *cpi) {
505
  return frame_is_intra_only(&cpi->common) || cpi->refresh_alt_ref_frame ||
506 507
         (cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref) ||
         vp9_is_upper_layer_key_frame(cpi);
508 509
}

510 511 512 513 514 515 516 517 518 519
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);
}

520
int vp9_get_y_sse(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b);
521

522
void vp9_alloc_compressor_data(VP9_COMP *cpi);
523

524 525 526 527
void vp9_scale_references(VP9_COMP *cpi);

void vp9_update_reference_frames(VP9_COMP *cpi);

528 529
int64_t vp9_rescale(int64_t val, int64_t num, int denom);

530 531
void vp9_set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv);

532 533 534 535
YV12_BUFFER_CONFIG *vp9_scale_if_required(VP9_COMMON *cm,
                                          YV12_BUFFER_CONFIG *unscaled,
                                          YV12_BUFFER_CONFIG *scaled);

536 537
void vp9_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags);

538 539 540
static INLINE void set_ref_ptrs(VP9_COMMON *cm, MACROBLOCKD *xd,
                                MV_REFERENCE_FRAME ref0,
                                MV_REFERENCE_FRAME ref1) {
541 542 543 544
  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];
545 546
}

547 548 549 550
static INLINE int get_chessboard_index(const VP9_COMMON *cm) {
  return cm->current_video_frame % 2;
}

551 552 553 554
#ifdef __cplusplus
}  // extern "C"
#endif

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