vp9/encoder/vp9_encoder.h

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  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.
   9  */
  10
  11 #ifndef VP9_ENCODER_VP9_ENCODER_H_
  12 #define VP9_ENCODER_VP9_ENCODER_H_
  13
  14 #include <stdio.h>
  15
  16 #include "./vpx_config.h"
  17 #include "vpx_ports/mem.h"
  18 #include "vpx/internal/vpx_codec_internal.h"
  19 #include "vpx/vp8cx.h"
  20
  21 #include "vp9/common/vp9_ppflags.h"
  22 #include "vp9/common/vp9_entropy.h"
  23 #include "vp9/common/vp9_entropymode.h"
  24 #include "vp9/common/vp9_onyxc_int.h"
  25
  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 #include "vp9/encoder/vp9_mcomp.h"
  32 #include "vp9/encoder/vp9_quantize.h"
  33 #include "vp9/encoder/vp9_ratectrl.h"
  34 #include "vp9/encoder/vp9_speed_features.h"
  35 #include "vp9/encoder/vp9_svc_layercontext.h"
  36 #include "vp9/encoder/vp9_tokenize.h"
  37 #include "vp9/encoder/vp9_variance.h"
  38
  39 #ifdef __cplusplus
  40 extern "C" {
  41 #endif
  42
  43 // #define MODE_TEST_HIT_STATS
  44
  45 #define DEFAULT_GF_INTERVAL         10
  46
  47 #define MAX_MODES 30
  48 #define MAX_REFS  6
  49
  50 typedef struct {
  51   int nmvjointcost[MV_JOINTS];
  52   int nmvcosts[2][MV_VALS];
  53   int nmvcosts_hp[2][MV_VALS];
  54
  55   vp9_prob segment_pred_probs[PREDICTION_PROBS];
  56
  57   unsigned char *last_frame_seg_map_copy;
  58
  59   // 0 = Intra, Last, GF, ARF
  60   signed char last_ref_lf_deltas[MAX_REF_LF_DELTAS];
  61   // 0 = ZERO_MV, MV
  62   signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS];
  63
  64   FRAME_CONTEXT fc;
  65 } CODING_CONTEXT;
  66
  67 // This enumerator type needs to be kept aligned with the mode order in
  68 // const MODE_DEFINITION vp9_mode_order[MAX_MODES] used in the rd code.
  69 typedef enum {
  70   THR_NEARESTMV,
  71   THR_NEARESTA,
  72   THR_NEARESTG,
  73
  74   THR_DC,
  75
  76   THR_NEWMV,
  77   THR_NEWA,
  78   THR_NEWG,
  79
  80   THR_NEARMV,
  81   THR_NEARA,
  82   THR_COMP_NEARESTLA,
  83   THR_COMP_NEARESTGA,
  84
  85   THR_TM,
  86
  87   THR_COMP_NEARLA,
  88   THR_COMP_NEWLA,
  89   THR_NEARG,
  90   THR_COMP_NEARGA,
  91   THR_COMP_NEWGA,
  92
  93   THR_ZEROMV,
  94   THR_ZEROG,
  95   THR_ZEROA,
  96   THR_COMP_ZEROLA,
  97   THR_COMP_ZEROGA,
  98
  99   THR_H_PRED,
 100   THR_V_PRED,
 101   THR_D135_PRED,
 102   THR_D207_PRED,
 103   THR_D153_PRED,
 104   THR_D63_PRED,
 105   THR_D117_PRED,
 106   THR_D45_PRED,
 107 } THR_MODES;
 108
 109 typedef enum {
 110   THR_LAST,
 111   THR_GOLD,
 112   THR_ALTR,
 113   THR_COMP_LA,
 114   THR_COMP_GA,
 115   THR_INTRA,
 116 } THR_MODES_SUB8X8;
 117
 118 typedef enum {
 119   // encode_breakout is disabled.
 120   ENCODE_BREAKOUT_DISABLED = 0,
 121   // encode_breakout is enabled.
 122   ENCODE_BREAKOUT_ENABLED = 1,
 123   // encode_breakout is enabled with small max_thresh limit.
 124   ENCODE_BREAKOUT_LIMITED = 2
 125 } ENCODE_BREAKOUT_TYPE;
 126
 127 typedef enum {
 128   NORMAL      = 0,
 129   FOURFIVE    = 1,
 130   THREEFIVE   = 2,
 131   ONETWO      = 3
 132 } VPX_SCALING;
 133
 134 typedef enum {
 135   RC_MODE_VBR = 0,
 136   RC_MODE_CBR = 1,
 137   RC_MODE_CONSTRAINED_QUALITY = 2,
 138   RC_MODE_CONSTANT_QUALITY    = 3,
 139 } RC_MODE;
 140
 141 typedef enum {
 142   // Good Quality Fast Encoding. The encoder balances quality with the
 143   // amount of time it takes to encode the output. (speed setting
 144   // controls how fast)
 145   ONE_PASS_GOOD = 1,
 146
 147   // One Pass - Best Quality. The encoder places priority on the
 148   // quality of the output over encoding speed. The output is compressed
 149   // at the highest possible quality. This option takes the longest
 150   // amount of time to encode. (speed setting ignored)
 151   ONE_PASS_BEST = 2,
 152
 153   // Two Pass - First Pass. The encoder generates a file of statistics
 154   // for use in the second encoding pass. (speed setting controls how fast)
 155   TWO_PASS_FIRST = 3,
 156
 157   // Two Pass - Second Pass. The encoder uses the statistics that were
 158   // generated in the first encoding pass to create the compressed
 159   // output. (speed setting controls how fast)
 160   TWO_PASS_SECOND_GOOD = 4,
 161
 162   // Two Pass - Second Pass Best.  The encoder uses the statistics that
 163   // were generated in the first encoding pass to create the compressed
 164   // output using the highest possible quality, and taking a
 165   // longer amount of time to encode. (speed setting ignored)
 166   TWO_PASS_SECOND_BEST = 5,
 167
 168   // Realtime/Live Encoding. This mode is optimized for realtime
 169   // encoding (for example, capturing a television signal or feed from
 170   // a live camera). (speed setting controls how fast)
 171   REALTIME = 6,
 172 } MODE;
 173
 174 typedef enum {
 175   FRAMEFLAGS_KEY    = 1 << 0,
 176   FRAMEFLAGS_GOLDEN = 1 << 1,
 177   FRAMEFLAGS_ALTREF = 1 << 2,
 178 } FRAMETYPE_FLAGS;
 179
 180 typedef enum {
 181   NO_AQ = 0,
 182   VARIANCE_AQ = 1,
 183   COMPLEXITY_AQ = 2,
 184   CYCLIC_REFRESH_AQ = 3,
 185   AQ_MODE_COUNT  // This should always be the last member of the enum
 186 } AQ_MODE;
 187
 188
 189 typedef struct VP9EncoderConfig {
 190   BITSTREAM_PROFILE profile;
 191   BIT_DEPTH bit_depth;
 192   int width;  // width of data passed to the compressor
 193   int height;  // height of data passed to the compressor
 194   double framerate;  // set to passed in framerate
 195   int64_t target_bandwidth;  // bandwidth to be used in kilobits per second
 196
 197   int noise_sensitivity;  // pre processing blur: recommendation 0
 198   int sharpness;  // sharpening output: recommendation 0:
 199   int speed;
 200   unsigned int rc_max_intra_bitrate_pct;
 201
 202   MODE mode;
 203
 204   // Key Framing Operations
 205   int auto_key;  // autodetect cut scenes and set the keyframes
 206   int key_freq;  // maximum distance to key frame.
 207
 208   int lag_in_frames;  // how many frames lag before we start encoding
 209
 210   // ----------------------------------------------------------------
 211   // DATARATE CONTROL OPTIONS
 212
 213   RC_MODE rc_mode;  // vbr, cbr, constrained quality or constant quality
 214
 215   // buffer targeting aggressiveness
 216   int under_shoot_pct;
 217   int over_shoot_pct;
 218
 219   // buffering parameters
 220   int64_t starting_buffer_level;  // in seconds
 221   int64_t optimal_buffer_level;
 222   int64_t maximum_buffer_size;
 223
 224   // Frame drop threshold.
 225   int drop_frames_water_mark;
 226
 227   // controlling quality
 228   int fixed_q;
 229   int worst_allowed_q;
 230   int best_allowed_q;
 231   int cq_level;
 232   int lossless;
 233   AQ_MODE aq_mode;  // Adaptive Quantization mode
 234
 235   // Internal frame size scaling.
 236   int allow_spatial_resampling;
 237   int scaled_frame_width;
 238   int scaled_frame_height;
 239
 240   // Enable feature to reduce the frame quantization every x frames.
 241   int frame_periodic_boost;
 242
 243   // two pass datarate control
 244   int two_pass_vbrbias;        // two pass datarate control tweaks
 245   int two_pass_vbrmin_section;
 246   int two_pass_vbrmax_section;
 247   // END DATARATE CONTROL OPTIONS
 248   // ----------------------------------------------------------------
 249
 250   // Spatial and temporal scalability.
 251   int ss_number_layers;  // Number of spatial layers.
 252   int ts_number_layers;  // Number of temporal layers.
 253   // Bitrate allocation for spatial layers.
 254   int ss_target_bitrate[VPX_SS_MAX_LAYERS];
 255   // Bitrate allocation (CBR mode) and framerate factor, for temporal layers.
 256   int ts_target_bitrate[VPX_TS_MAX_LAYERS];
 257   int ts_rate_decimator[VPX_TS_MAX_LAYERS];
 258
 259   // these parameters aren't to be used in final build don't use!!!
 260   int play_alternate;
 261   int alt_freq;
 262
 263   int encode_breakout;  // early breakout : for video conf recommend 800
 264
 265   /* Bitfield defining the error resiliency features to enable.
 266    * Can provide decodable frames after losses in previous
 267    * frames and decodable partitions after losses in the same frame.
 268    */
 269   unsigned int error_resilient_mode;
 270
 271   /* Bitfield defining the parallel decoding mode where the
 272    * decoding in successive frames may be conducted in parallel
 273    * just by decoding the frame headers.
 274    */
 275   unsigned int frame_parallel_decoding_mode;
 276
 277   int arnr_max_frames;
 278   int arnr_strength;
 279   int arnr_type;
 280
 281   int tile_columns;
 282   int tile_rows;
 283
 284   struct vpx_fixed_buf         two_pass_stats_in;
 285   struct vpx_codec_pkt_list  *output_pkt_list;
 286
 287   vp8e_tuning tuning;
 288 } VP9EncoderConfig;
 289
 290 static INLINE int is_best_mode(MODE mode) {
 291   return mode == ONE_PASS_BEST || mode == TWO_PASS_SECOND_BEST;
 292 }
 293
 294 typedef struct RD_OPT {
 295   // Thresh_mult is used to set a threshold for the rd score. A higher value
 296   // means that we will accept the best mode so far more often. This number
 297   // is used in combination with the current block size, and thresh_freq_fact
 298   // to pick a threshold.
 299   int thresh_mult[MAX_MODES];
 300   int thresh_mult_sub8x8[MAX_REFS];
 301
 302   int threshes[MAX_SEGMENTS][BLOCK_SIZES][MAX_MODES];
 303   int thresh_freq_fact[BLOCK_SIZES][MAX_MODES];
 304
 305   int64_t comp_pred_diff[REFERENCE_MODES];
 306   int64_t prediction_type_threshes[MAX_REF_FRAMES][REFERENCE_MODES];
 307   int64_t tx_select_diff[TX_MODES];
 308   // FIXME(rbultje) can this overflow?
 309   int tx_select_threshes[MAX_REF_FRAMES][TX_MODES];
 310
 311   int64_t filter_diff[SWITCHABLE_FILTER_CONTEXTS];
 312   int64_t filter_threshes[MAX_REF_FRAMES][SWITCHABLE_FILTER_CONTEXTS];
 313   int64_t filter_cache[SWITCHABLE_FILTER_CONTEXTS];
 314   int64_t mask_filter;
 315
 316   int RDMULT;
 317   int RDDIV;
 318 } RD_OPT;
 319
 320 typedef struct VP9_COMP {
 321   QUANTS quants;
 322   MACROBLOCK mb;
 323   VP9_COMMON common;
 324   VP9EncoderConfig oxcf;
 325   struct lookahead_ctx    *lookahead;
 326   struct lookahead_entry  *source;
 327 #if CONFIG_MULTIPLE_ARF
 328   struct lookahead_entry  *alt_ref_source[REF_FRAMES];
 329 #else
 330   struct lookahead_entry  *alt_ref_source;
 331 #endif
 332   struct lookahead_entry  *last_source;
 333
 334   YV12_BUFFER_CONFIG *Source;
 335   YV12_BUFFER_CONFIG *Last_Source;  // NULL for first frame and alt_ref frames
 336   YV12_BUFFER_CONFIG *un_scaled_source;
 337   YV12_BUFFER_CONFIG scaled_source;
 338   YV12_BUFFER_CONFIG *unscaled_last_source;
 339   YV12_BUFFER_CONFIG scaled_last_source;
 340
 341   int gold_is_last;  // gold same as last frame ( short circuit gold searches)
 342   int alt_is_last;  // Alt same as last ( short circuit altref search)
 343   int gold_is_alt;  // don't do both alt and gold search ( just do gold).
 344
 345   int scaled_ref_idx[3];
 346   int lst_fb_idx;
 347   int gld_fb_idx;
 348   int alt_fb_idx;
 349
 350 #if CONFIG_MULTIPLE_ARF
 351   int alt_ref_fb_idx[REF_FRAMES - 3];
 352 #endif
 353   int refresh_last_frame;
 354   int refresh_golden_frame;
 355   int refresh_alt_ref_frame;
 356
 357   int ext_refresh_frame_flags_pending;
 358   int ext_refresh_last_frame;
 359   int ext_refresh_golden_frame;
 360   int ext_refresh_alt_ref_frame;
 361
 362   int ext_refresh_frame_context_pending;
 363   int ext_refresh_frame_context;
 364
 365   YV12_BUFFER_CONFIG last_frame_uf;
 366
 367   TOKENEXTRA *tok;
 368   unsigned int tok_count[4][1 << 6];
 369
 370 #if CONFIG_MULTIPLE_ARF
 371   // Position within a frame coding order (including any additional ARF frames).
 372   unsigned int sequence_number;
 373   // Next frame in naturally occurring order that has not yet been coded.
 374   int next_frame_in_order;
 375 #endif
 376
 377   // Ambient reconstruction err target for force key frames
 378   int ambient_err;
 379
 380   RD_OPT rd;
 381
 382   CODING_CONTEXT coding_context;
 383
 384   int zbin_mode_boost;
 385   int zbin_mode_boost_enabled;
 386   int active_arnr_frames;           // <= cpi->oxcf.arnr_max_frames
 387   int active_arnr_strength;         // <= cpi->oxcf.arnr_max_strength
 388
 389   int64_t last_time_stamp_seen;
 390   int64_t last_end_time_stamp_seen;
 391   int64_t first_time_stamp_ever;
 392
 393   RATE_CONTROL rc;
 394
 395   vp9_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
 396   vp9_coeff_probs_model frame_coef_probs[TX_SIZES][PLANE_TYPES];
 397
 398   struct vpx_codec_pkt_list  *output_pkt_list;
 399
 400   MBGRAPH_FRAME_STATS mbgraph_stats[MAX_LAG_BUFFERS];
 401   int mbgraph_n_frames;             // number of frames filled in the above
 402   int static_mb_pct;                // % forced skip mbs by segmentation
 403
 404   int pass;
 405
 406   int ref_frame_flags;
 407
 408   SPEED_FEATURES sf;
 409
 410   unsigned int max_mv_magnitude;
 411   int mv_step_param;
 412
 413   // Default value is 1. From first pass stats, encode_breakout may be disabled.
 414   ENCODE_BREAKOUT_TYPE allow_encode_breakout;
 415
 416   // Get threshold from external input. In real time mode, it can be
 417   // overwritten according to encoding speed.
 418   int encode_breakout;
 419
 420   unsigned char *segmentation_map;
 421
 422   // segment threashold for encode breakout
 423   int  segment_encode_breakout[MAX_SEGMENTS];
 424
 425   unsigned char *complexity_map;
 426
 427   unsigned char *active_map;
 428   unsigned int active_map_enabled;
 429
 430   CYCLIC_REFRESH *cyclic_refresh;
 431
 432   fractional_mv_step_fp *find_fractional_mv_step;
 433   fractional_mv_step_comp_fp *find_fractional_mv_step_comp;
 434   vp9_full_search_fn_t full_search_sad;
 435   vp9_refining_search_fn_t refining_search_sad;
 436   vp9_diamond_search_fn_t diamond_search_sad;
 437   vp9_variance_fn_ptr_t fn_ptr[BLOCK_SIZES];
 438   uint64_t time_receive_data;
 439   uint64_t time_compress_data;
 440   uint64_t time_pick_lpf;
 441   uint64_t time_encode_sb_row;
 442
 443   struct twopass_rc twopass;
 444
 445   YV12_BUFFER_CONFIG alt_ref_buffer;
 446   YV12_BUFFER_CONFIG *frames[MAX_LAG_BUFFERS];
 447
 448 #if CONFIG_INTERNAL_STATS
 449   unsigned int mode_chosen_counts[MAX_MODES];
 450
 451   int    count;
 452   double total_y;
 453   double total_u;
 454   double total_v;
 455   double total;
 456   uint64_t total_sq_error;
 457   uint64_t total_samples;
 458
 459   double totalp_y;
 460   double totalp_u;
 461   double totalp_v;
 462   double totalp;
 463   uint64_t totalp_sq_error;
 464   uint64_t totalp_samples;
 465
 466   int    bytes;
 467   double summed_quality;
 468   double summed_weights;
 469   double summedp_quality;
 470   double summedp_weights;
 471   unsigned int tot_recode_hits;
 472
 473
 474   double total_ssimg_y;
 475   double total_ssimg_u;
 476   double total_ssimg_v;
 477   double total_ssimg_all;
 478
 479   int b_calculate_ssimg;
 480 #endif
 481   int b_calculate_psnr;
 482
 483   int droppable;
 484
 485   int dummy_packing;    /* flag to indicate if packing is dummy */
 486
 487   unsigned int tx_stepdown_count[TX_SIZES];
 488
 489   int initial_width;
 490   int initial_height;
 491
 492   int use_svc;
 493
 494   SVC svc;
 495
 496   int use_large_partition_rate;
 497
 498   int frame_flags;
 499
 500   search_site_config ss_cfg;
 501
 502   int mbmode_cost[INTRA_MODES];
 503   unsigned inter_mode_cost[INTER_MODE_CONTEXTS][INTER_MODES];
 504   int intra_uv_mode_cost[FRAME_TYPES][INTRA_MODES];
 505   int y_mode_costs[INTRA_MODES][INTRA_MODES][INTRA_MODES];
 506   int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS];
 507
 508 #if CONFIG_MULTIPLE_ARF
 509   // ARF tracking variables.
 510   int multi_arf_enabled;
 511   unsigned int frame_coding_order_period;
 512   unsigned int new_frame_coding_order_period;
 513   int frame_coding_order[MAX_LAG_BUFFERS * 2];
 514   int arf_buffer_idx[MAX_LAG_BUFFERS * 3 / 2];
 515   int arf_weight[MAX_LAG_BUFFERS];
 516   int arf_buffered;
 517   int this_frame_weight;
 518   int max_arf_level;
 519 #endif
 520
 521 #ifdef MODE_TEST_HIT_STATS
 522   // Debug / test stats
 523   int64_t mode_test_hits[BLOCK_SIZES];
 524 #endif
 525 } VP9_COMP;
 526
 527 void vp9_initialize_enc();
 528
 529 struct VP9_COMP *vp9_create_compressor(VP9EncoderConfig *oxcf);
 530 void vp9_remove_compressor(VP9_COMP *cpi);
 531
 532 void vp9_change_config(VP9_COMP *cpi, const VP9EncoderConfig *oxcf);
 533
 534   // receive a frames worth of data. caller can assume that a copy of this
 535   // frame is made and not just a copy of the pointer..
 536 int vp9_receive_raw_frame(VP9_COMP *cpi, unsigned int frame_flags,
 537                           YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
 538                           int64_t end_time_stamp);
 539
 540 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
 541                             size_t *size, uint8_t *dest,
 542                             int64_t *time_stamp, int64_t *time_end, int flush);
 543
 544 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
 545                               vp9_ppflags_t *flags);
 546
 547 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags);
 548
 549 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags);
 550
 551 int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
 552                            YV12_BUFFER_CONFIG *sd);
 553
 554 int vp9_get_reference_enc(VP9_COMP *cpi, int index,
 555                           YV12_BUFFER_CONFIG **fb);
 556
 557 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
 558                           YV12_BUFFER_CONFIG *sd);
 559
 560 int vp9_update_entropy(VP9_COMP *cpi, int update);
 561
 562 int vp9_set_roimap(VP9_COMP *cpi, unsigned char *map,
 563                    unsigned int rows, unsigned int cols,
 564                    int delta_q[MAX_SEGMENTS],
 565                    int delta_lf[MAX_SEGMENTS],
 566                    unsigned int threshold[MAX_SEGMENTS]);
 567
 568 int vp9_set_active_map(VP9_COMP *cpi, unsigned char *map,
 569                        unsigned int rows, unsigned int cols);
 570
 571 int vp9_set_internal_size(VP9_COMP *cpi,
 572                           VPX_SCALING horiz_mode, VPX_SCALING vert_mode);
 573
 574 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
 575                          unsigned int height);
 576
 577 void vp9_set_svc(VP9_COMP *cpi, int use_svc);
 578
 579 int vp9_get_quantizer(struct VP9_COMP *cpi);
 580
 581 static INLINE int get_ref_frame_idx(const VP9_COMP *cpi,
 582                                     MV_REFERENCE_FRAME ref_frame) {
 583   if (ref_frame == LAST_FRAME) {
 584     return cpi->lst_fb_idx;
 585   } else if (ref_frame == GOLDEN_FRAME) {
 586     return cpi->gld_fb_idx;
 587   } else {
 588     return cpi->alt_fb_idx;
 589   }
 590 }
 591
 592 static INLINE YV12_BUFFER_CONFIG *get_ref_frame_buffer(
 593     VP9_COMP *cpi, MV_REFERENCE_FRAME ref_frame) {
 594   VP9_COMMON * const cm = &cpi->common;
 595   return &cm->frame_bufs[cm->ref_frame_map[get_ref_frame_idx(cpi, ref_frame)]]
 596       .buf;
 597 }
 598
 599 // Intra only frames, golden frames (except alt ref overlays) and
 600 // alt ref frames tend to be coded at a higher than ambient quality
 601 static INLINE int frame_is_boosted(const VP9_COMP *cpi) {
 602   return frame_is_intra_only(&cpi->common) || cpi->refresh_alt_ref_frame ||
 603          (cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref) ||
 604          vp9_is_upper_layer_key_frame(cpi);
 605 }
 606
 607 static INLINE int get_token_alloc(int mb_rows, int mb_cols) {
 608   // TODO(JBB): make this work for alpha channel and double check we can't
 609   // exceed this token count if we have a 32x32 transform crossing a boundary
 610   // at a multiple of 16.
 611   // mb_rows, cols are in units of 16 pixels. We assume 3 planes all at full
 612   // resolution. We assume up to 1 token per pixel, and then allow
 613   // a head room of 4.
 614   return mb_rows * mb_cols * (16 * 16 * 3 + 4);
 615 }
 616
 617 int vp9_get_y_sse(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b);
 618
 619 void vp9_alloc_compressor_data(VP9_COMP *cpi);
 620
 621 void vp9_scale_references(VP9_COMP *cpi);
 622
 623 void vp9_update_reference_frames(VP9_COMP *cpi);
 624
 625 int64_t vp9_rescale(int64_t val, int64_t num, int denom);
 626
 627 YV12_BUFFER_CONFIG *vp9_scale_if_required(VP9_COMMON *cm,
 628                                           YV12_BUFFER_CONFIG *unscaled,
 629                                           YV12_BUFFER_CONFIG *scaled);
 630
 631 static INLINE void set_ref_ptrs(VP9_COMMON *cm, MACROBLOCKD *xd,
 632                                 MV_REFERENCE_FRAME ref0,
 633                                 MV_REFERENCE_FRAME ref1) {
 634   xd->block_refs[0] = &cm->frame_refs[ref0 >= LAST_FRAME ? ref0 - LAST_FRAME
 635                                                          : 0];
 636   xd->block_refs[1] = &cm->frame_refs[ref1 >= LAST_FRAME ? ref1 - LAST_FRAME
 637                                                          : 0];
 638 }
 639
 640 #ifdef __cplusplus
 641 }  // extern "C"
 642 #endif
 643
 644 #endif  // VP9_ENCODER_VP9_ENCODER_H_