granicus.if.org Git - libvpx/blob - vp9/encoder/vp9_onyx_int.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_ONYX_INT_H_
  12 #define VP9_ENCODER_VP9_ONYX_INT_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   USAGE_LOCAL_FILE_PLAYBACK = 0,
 136   USAGE_STREAM_FROM_SERVER  = 1,
 137   USAGE_CONSTRAINED_QUALITY = 2,
 138   USAGE_CONSTANT_QUALITY    = 3,
 139 } END_USAGE;
 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   MODE_GOODQUALITY = 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   MODE_BESTQUALITY = 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   MODE_FIRSTPASS = 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   MODE_SECONDPASS = 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   MODE_SECONDPASS_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   MODE_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 typedef struct VP9_CONFIG {
 189   BITSTREAM_PROFILE profile;
 190   BIT_DEPTH bit_depth;
 191   int width;  // width of data passed to the compressor
 192   int height;  // height of data passed to the compressor
 193   double framerate;  // set to passed in framerate
 194   int64_t target_bandwidth;  // bandwidth to be used in kilobits per second
 195
 196   int noise_sensitivity;  // pre processing blur: recommendation 0
 197   int sharpness;  // sharpening output: recommendation 0:
 198   int cpu_used;
 199   unsigned int rc_max_intra_bitrate_pct;
 200
 201   MODE mode;
 202
 203   // Key Framing Operations
 204   int auto_key;  // autodetect cut scenes and set the keyframes
 205   int key_freq;  // maximum distance to key frame.
 206
 207   int lag_in_frames;  // how many frames lag before we start encoding
 208
 209   // ----------------------------------------------------------------
 210   // DATARATE CONTROL OPTIONS
 211
 212   END_USAGE end_usage;  // vbr or cbr
 213
 214   // buffer targeting aggressiveness
 215   int under_shoot_pct;
 216   int over_shoot_pct;
 217
 218   // buffering parameters
 219   int64_t starting_buffer_level;  // in seconds
 220   int64_t optimal_buffer_level;
 221   int64_t maximum_buffer_size;
 222
 223   // Frame drop threshold.
 224   int drop_frames_water_mark;
 225
 226   // controlling quality
 227   int fixed_q;
 228   int worst_allowed_q;
 229   int best_allowed_q;
 230   int cq_level;
 231   int lossless;
 232   AQ_MODE aq_mode;  // Adaptive Quantization mode
 233
 234   // Enable feature to reduce the frame quantization every x frames.
 235   int frame_periodic_boost;
 236
 237   // two pass datarate control
 238   int two_pass_vbrbias;        // two pass datarate control tweaks
 239   int two_pass_vbrmin_section;
 240   int two_pass_vbrmax_section;
 241   // END DATARATE CONTROL OPTIONS
 242   // ----------------------------------------------------------------
 243
 244   // Spatial and temporal scalability.
 245   int ss_number_layers;  // Number of spatial layers.
 246   int ts_number_layers;  // Number of temporal layers.
 247   // Bitrate allocation for spatial layers.
 248   int ss_target_bitrate[VPX_SS_MAX_LAYERS];
 249   // Bitrate allocation (CBR mode) and framerate factor, for temporal layers.
 250   int ts_target_bitrate[VPX_TS_MAX_LAYERS];
 251   int ts_rate_decimator[VPX_TS_MAX_LAYERS];
 252
 253   // these parameters aren't to be used in final build don't use!!!
 254   int play_alternate;
 255   int alt_freq;
 256
 257   int encode_breakout;  // early breakout : for video conf recommend 800
 258
 259   /* Bitfield defining the error resiliency features to enable.
 260    * Can provide decodable frames after losses in previous
 261    * frames and decodable partitions after losses in the same frame.
 262    */
 263   unsigned int error_resilient_mode;
 264
 265   /* Bitfield defining the parallel decoding mode where the
 266    * decoding in successive frames may be conducted in parallel
 267    * just by decoding the frame headers.
 268    */
 269   unsigned int frame_parallel_decoding_mode;
 270
 271   int arnr_max_frames;
 272   int arnr_strength;
 273   int arnr_type;
 274
 275   int tile_columns;
 276   int tile_rows;
 277
 278   struct vpx_fixed_buf         two_pass_stats_in;
 279   struct vpx_codec_pkt_list  *output_pkt_list;
 280
 281   vp8e_tuning tuning;
 282 } VP9_CONFIG;
 283
 284 typedef struct VP9_COMP {
 285   QUANTS quants;
 286   MACROBLOCK mb;
 287   VP9_COMMON common;
 288   VP9_CONFIG oxcf;
 289   struct lookahead_ctx    *lookahead;
 290   struct lookahead_entry  *source;
 291 #if CONFIG_MULTIPLE_ARF
 292   struct lookahead_entry  *alt_ref_source[REF_FRAMES];
 293 #else
 294   struct lookahead_entry  *alt_ref_source;
 295 #endif
 296   struct lookahead_entry  *last_source;
 297
 298   YV12_BUFFER_CONFIG *Source;
 299   YV12_BUFFER_CONFIG *Last_Source;  // NULL for first frame and alt_ref frames
 300   YV12_BUFFER_CONFIG *un_scaled_source;
 301   YV12_BUFFER_CONFIG scaled_source;
 302   YV12_BUFFER_CONFIG *unscaled_last_source;
 303   YV12_BUFFER_CONFIG scaled_last_source;
 304
 305   int key_frame_frequency;
 306
 307   int gold_is_last;  // gold same as last frame ( short circuit gold searches)
 308   int alt_is_last;  // Alt same as last ( short circuit altref search)
 309   int gold_is_alt;  // don't do both alt and gold search ( just do gold).
 310
 311   int scaled_ref_idx[3];
 312   int lst_fb_idx;
 313   int gld_fb_idx;
 314   int alt_fb_idx;
 315
 316 #if CONFIG_MULTIPLE_ARF
 317   int alt_ref_fb_idx[REF_FRAMES - 3];
 318 #endif
 319   int refresh_last_frame;
 320   int refresh_golden_frame;
 321   int refresh_alt_ref_frame;
 322
 323   int ext_refresh_frame_flags_pending;
 324   int ext_refresh_last_frame;
 325   int ext_refresh_golden_frame;
 326   int ext_refresh_alt_ref_frame;
 327
 328   int ext_refresh_frame_context_pending;
 329   int ext_refresh_frame_context;
 330
 331   YV12_BUFFER_CONFIG last_frame_uf;
 332
 333   TOKENEXTRA *tok;
 334   unsigned int tok_count[4][1 << 6];
 335
 336 #if CONFIG_MULTIPLE_ARF
 337   // Position within a frame coding order (including any additional ARF frames).
 338   unsigned int sequence_number;
 339   // Next frame in naturally occurring order that has not yet been coded.
 340   int next_frame_in_order;
 341 #endif
 342
 343   // Ambient reconstruction err target for force key frames
 344   int ambient_err;
 345
 346   // Thresh_mult is used to set a threshold for the rd score. A higher value
 347   // means that we will accept the best mode so far more often. This number
 348   // is used in combination with the current block size, and thresh_freq_fact
 349   // to pick a threshold.
 350   int rd_thresh_mult[MAX_MODES];
 351   int rd_thresh_mult_sub8x8[MAX_REFS];
 352
 353   int rd_threshes[MAX_SEGMENTS][BLOCK_SIZES][MAX_MODES];
 354   int rd_thresh_freq_fact[BLOCK_SIZES][MAX_MODES];
 355   int rd_thresh_sub8x8[MAX_SEGMENTS][BLOCK_SIZES][MAX_REFS];
 356   int rd_thresh_freq_sub8x8[BLOCK_SIZES][MAX_REFS];
 357
 358   int64_t rd_comp_pred_diff[REFERENCE_MODES];
 359   int64_t rd_prediction_type_threshes[MAX_REF_FRAMES][REFERENCE_MODES];
 360   int64_t rd_tx_select_diff[TX_MODES];
 361   // FIXME(rbultje) can this overflow?
 362   int rd_tx_select_threshes[MAX_REF_FRAMES][TX_MODES];
 363
 364   int64_t rd_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
 365   int64_t rd_filter_threshes[MAX_REF_FRAMES][SWITCHABLE_FILTER_CONTEXTS];
 366   int64_t rd_filter_cache[SWITCHABLE_FILTER_CONTEXTS];
 367   int64_t mask_filter_rd;
 368
 369   int RDMULT;
 370   int RDDIV;
 371
 372   CODING_CONTEXT coding_context;
 373
 374   int zbin_mode_boost;
 375   int zbin_mode_boost_enabled;
 376   int active_arnr_frames;           // <= cpi->oxcf.arnr_max_frames
 377   int active_arnr_strength;         // <= cpi->oxcf.arnr_max_strength
 378
 379   double output_framerate;
 380   int64_t last_time_stamp_seen;
 381   int64_t last_end_time_stamp_seen;
 382   int64_t first_time_stamp_ever;
 383
 384   RATE_CONTROL rc;
 385
 386   int cq_target_quality;
 387
 388   vp9_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
 389   vp9_coeff_probs_model frame_coef_probs[TX_SIZES][PLANE_TYPES];
 390
 391   struct vpx_codec_pkt_list  *output_pkt_list;
 392
 393   MBGRAPH_FRAME_STATS mbgraph_stats[MAX_LAG_BUFFERS];
 394   int mbgraph_n_frames;             // number of frames filled in the above
 395   int static_mb_pct;                // % forced skip mbs by segmentation
 396
 397   // for real time encoding
 398   int speed;
 399
 400   int cpu_used;
 401   int pass;
 402
 403   int ref_frame_flags;
 404
 405   SPEED_FEATURES sf;
 406
 407   unsigned int max_mv_magnitude;
 408   int mv_step_param;
 409
 410   // Default value is 1. From first pass stats, encode_breakout may be disabled.
 411   ENCODE_BREAKOUT_TYPE allow_encode_breakout;
 412
 413   // Get threshold from external input. In real time mode, it can be
 414   // overwritten according to encoding speed.
 415   int encode_breakout;
 416
 417   unsigned char *segmentation_map;
 418
 419   // segment threashold for encode breakout
 420   int  segment_encode_breakout[MAX_SEGMENTS];
 421
 422   unsigned char *complexity_map;
 423
 424   unsigned char *active_map;
 425   unsigned int active_map_enabled;
 426
 427   CYCLIC_REFRESH *cyclic_refresh;
 428
 429   fractional_mv_step_fp *find_fractional_mv_step;
 430   fractional_mv_step_comp_fp *find_fractional_mv_step_comp;
 431   vp9_full_search_fn_t full_search_sad;
 432   vp9_refining_search_fn_t refining_search_sad;
 433   vp9_diamond_search_fn_t diamond_search_sad;
 434   vp9_variance_fn_ptr_t fn_ptr[BLOCK_SIZES];
 435   uint64_t time_receive_data;
 436   uint64_t time_compress_data;
 437   uint64_t time_pick_lpf;
 438   uint64_t time_encode_sb_row;
 439
 440   struct twopass_rc twopass;
 441
 442   YV12_BUFFER_CONFIG alt_ref_buffer;
 443   YV12_BUFFER_CONFIG *frames[MAX_LAG_BUFFERS];
 444   int fixed_divide[512];
 445
 446 #if CONFIG_INTERNAL_STATS
 447   unsigned int mode_chosen_counts[MAX_MODES];
 448
 449   int    count;
 450   double total_y;
 451   double total_u;
 452   double total_v;
 453   double total;
 454   uint64_t total_sq_error;
 455   uint64_t total_samples;
 456
 457   double totalp_y;
 458   double totalp_u;
 459   double totalp_v;
 460   double totalp;
 461   uint64_t totalp_sq_error;
 462   uint64_t totalp_samples;
 463
 464   int    bytes;
 465   double summed_quality;
 466   double summed_weights;
 467   double summedp_quality;
 468   double summedp_weights;
 469   unsigned int tot_recode_hits;
 470
 471
 472   double total_ssimg_y;
 473   double total_ssimg_u;
 474   double total_ssimg_v;
 475   double total_ssimg_all;
 476
 477   int b_calculate_ssimg;
 478 #endif
 479   int b_calculate_psnr;
 480
 481   // Per MB activity measurement
 482   unsigned int activity_avg;
 483   unsigned int *mb_activity_map;
 484   int *mb_norm_activity_map;
 485
 486   int droppable;
 487
 488   int dummy_packing;    /* flag to indicate if packing is dummy */
 489
 490   unsigned int tx_stepdown_count[TX_SIZES];
 491
 492   int initial_width;
 493   int initial_height;
 494
 495   int use_svc;
 496
 497   SVC svc;
 498
 499   int use_large_partition_rate;
 500
 501 #if CONFIG_MULTIPLE_ARF
 502   // ARF tracking variables.
 503   int multi_arf_enabled;
 504   unsigned int frame_coding_order_period;
 505   unsigned int new_frame_coding_order_period;
 506   int frame_coding_order[MAX_LAG_BUFFERS * 2];
 507   int arf_buffer_idx[MAX_LAG_BUFFERS * 3 / 2];
 508   int arf_weight[MAX_LAG_BUFFERS];
 509   int arf_buffered;
 510   int this_frame_weight;
 511   int max_arf_level;
 512 #endif
 513
 514 #ifdef MODE_TEST_HIT_STATS
 515   // Debug / test stats
 516   int64_t mode_test_hits[BLOCK_SIZES];
 517 #endif
 518 } VP9_COMP;
 519
 520 void vp9_initialize_enc();
 521
 522 struct VP9_COMP *vp9_create_compressor(VP9_CONFIG *oxcf);
 523 void vp9_remove_compressor(VP9_COMP *cpi);
 524
 525 void vp9_change_config(VP9_COMP *cpi, const VP9_CONFIG *oxcf);
 526
 527   // receive a frames worth of data. caller can assume that a copy of this
 528   // frame is made and not just a copy of the pointer..
 529 int vp9_receive_raw_frame(VP9_COMP *cpi, unsigned int frame_flags,
 530                           YV12_BUFFER_CONFIG *sd, int64_t time_stamp,
 531                           int64_t end_time_stamp);
 532
 533 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags,
 534                             size_t *size, uint8_t *dest,
 535                             int64_t *time_stamp, int64_t *time_end, int flush);
 536
 537 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
 538                               vp9_ppflags_t *flags);
 539
 540 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags);
 541
 542 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags);
 543
 544 int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
 545                            YV12_BUFFER_CONFIG *sd);
 546
 547 int vp9_get_reference_enc(VP9_COMP *cpi, int index,
 548                           YV12_BUFFER_CONFIG **fb);
 549
 550 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
 551                           YV12_BUFFER_CONFIG *sd);
 552
 553 int vp9_update_entropy(VP9_COMP *cpi, int update);
 554
 555 int vp9_set_roimap(VP9_COMP *cpi, unsigned char *map,
 556                    unsigned int rows, unsigned int cols,
 557                    int delta_q[MAX_SEGMENTS],
 558                    int delta_lf[MAX_SEGMENTS],
 559                    unsigned int threshold[MAX_SEGMENTS]);
 560
 561 int vp9_set_active_map(VP9_COMP *cpi, unsigned char *map,
 562                        unsigned int rows, unsigned int cols);
 563
 564 int vp9_set_internal_size(VP9_COMP *cpi,
 565                           VPX_SCALING horiz_mode, VPX_SCALING vert_mode);
 566
 567 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
 568                          unsigned int height);
 569
 570 void vp9_set_svc(VP9_COMP *cpi, int use_svc);
 571
 572 int vp9_get_quantizer(struct VP9_COMP *cpi);
 573
 574 static INLINE int get_ref_frame_idx(const VP9_COMP *cpi,
 575                                     MV_REFERENCE_FRAME ref_frame) {
 576   if (ref_frame == LAST_FRAME) {
 577     return cpi->lst_fb_idx;
 578   } else if (ref_frame == GOLDEN_FRAME) {
 579     return cpi->gld_fb_idx;
 580   } else {
 581     return cpi->alt_fb_idx;
 582   }
 583 }
 584
 585 static INLINE YV12_BUFFER_CONFIG *get_ref_frame_buffer(
 586     VP9_COMP *cpi, MV_REFERENCE_FRAME ref_frame) {
 587   VP9_COMMON * const cm = &cpi->common;
 588   return &cm->frame_bufs[cm->ref_frame_map[get_ref_frame_idx(cpi, ref_frame)]]
 589       .buf;
 590 }
 591
 592 // Intra only frames, golden frames (except alt ref overlays) and
 593 // alt ref frames tend to be coded at a higher than ambient quality
 594 static INLINE int vp9_frame_is_boosted(const VP9_COMP *cpi) {
 595   return frame_is_intra_only(&cpi->common) || cpi->refresh_alt_ref_frame ||
 596          (cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref);
 597 }
 598
 599 static INLINE int get_token_alloc(int mb_rows, int mb_cols) {
 600   // TODO(JBB): make this work for alpha channel and double check we can't
 601   // exceed this token count if we have a 32x32 transform crossing a boundary
 602   // at a multiple of 16.
 603   // mb_rows, cols are in units of 16 pixels. We assume 3 planes all at full
 604   // resolution. We assume up to 1 token per pixel, and then allow
 605   // a head room of 4.
 606   return mb_rows * mb_cols * (16 * 16 * 3 + 4);
 607 }
 608
 609 int vp9_get_y_sse(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b);
 610
 611 void vp9_alloc_compressor_data(VP9_COMP *cpi);
 612
 613 void vp9_scale_references(VP9_COMP *cpi);
 614
 615 void vp9_update_reference_frames(VP9_COMP *cpi);
 616
 617 int64_t vp9_rescale(int64_t val, int64_t num, int denom);
 618
 619 static INLINE void set_ref_ptrs(VP9_COMMON *cm, MACROBLOCKD *xd,
 620                                 MV_REFERENCE_FRAME ref0,
 621                                 MV_REFERENCE_FRAME ref1) {
 622   xd->block_refs[0] = &cm->frame_refs[ref0 >= LAST_FRAME ? ref0 - LAST_FRAME
 623                                                          : 0];
 624   xd->block_refs[1] = &cm->frame_refs[ref1 >= LAST_FRAME ? ref1 - LAST_FRAME
 625                                                          : 0];
 626 }
 627
 628 #ifdef __cplusplus
 629 }  // extern "C"
 630 #endif
 631
 632 #endif  // VP9_ENCODER_VP9_ONYX_INT_H_