vp9_onyx_int.h 17.8 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
 */

11
12
#ifndef VP9_ENCODER_VP9_ONYX_INT_H_
#define VP9_ENCODER_VP9_ONYX_INT_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

Paul Wilkins's avatar
Paul Wilkins committed
43
// #define MODE_TEST_HIT_STATS
44

45
#define DEFAULT_GF_INTERVAL         10
John Koleszar's avatar
John Koleszar committed
46

47
48
#define MAX_MODES 30
#define MAX_REFS  6
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
// 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
69
70
typedef enum {
  THR_NEARESTMV,
Paul Wilkins's avatar
Paul Wilkins committed
71
72
  THR_NEARESTA,
  THR_NEARESTG,
John Koleszar's avatar
John Koleszar committed
73

74
75
76
  THR_DC,

  THR_NEWMV,
Paul Wilkins's avatar
Paul Wilkins committed
77
  THR_NEWA,
78
79
80
  THR_NEWG,

  THR_NEARMV,
John Koleszar's avatar
John Koleszar committed
81
  THR_NEARA,
82
83
  THR_COMP_NEARESTLA,
  THR_COMP_NEARESTGA,
John Koleszar's avatar
John Koleszar committed
84
85

  THR_TM,
86

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

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

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

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

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

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

typedef enum {
135
136
137
138
  USAGE_LOCAL_FILE_PLAYBACK = 0,
  USAGE_STREAM_FROM_SERVER  = 1,
  USAGE_CONSTRAINED_QUALITY = 2,
  USAGE_CONSTANT_QUALITY    = 3,
139
140
141
} END_USAGE;

typedef enum {
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
  // Good Quality Fast Encoding. The encoder balances quality with the
  // amount of time it takes to encode the output. (speed setting
  // controls how fast)
  MODE_GOODQUALITY = 1,

  // 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)
  MODE_BESTQUALITY = 2,

  // Two Pass - First Pass. The encoder generates a file of statistics
  // for use in the second encoding pass. (speed setting controls how fast)
  MODE_FIRSTPASS = 3,

  // 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)
  MODE_SECONDPASS = 4,

  // 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)
  MODE_SECONDPASS_BEST = 5,

  // 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)
  MODE_REALTIME = 6,
172
173
174
} MODE;

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

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

188
typedef struct VP9_CONFIG {
189
190
  BITSTREAM_PROFILE profile;
  BIT_DEPTH bit_depth;
191
192
193
194
195
196
197
198
199
200
  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:
  int cpu_used;
  unsigned int rc_max_intra_bitrate_pct;

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

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

212
  END_USAGE end_usage;  // vbr or cbr
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231

  // 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;
232
  AQ_MODE aq_mode;  // Adaptive Quantization mode
233

234
235
236
  // Enable feature to reduce the frame quantization every x frames.
  int frame_periodic_boost;

237
238
239
240
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
277
278
279
280
281
282
283
  // 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;
  int arnr_type;

  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;
} VP9_CONFIG;

284
typedef struct VP9_COMP {
285
  QUANTS quants;
John Koleszar's avatar
John Koleszar committed
286
  MACROBLOCK mb;
287
  VP9_COMMON common;
288
  VP9_CONFIG oxcf;
John Koleszar's avatar
John Koleszar committed
289
290
  struct lookahead_ctx    *lookahead;
  struct lookahead_entry  *source;
291
#if CONFIG_MULTIPLE_ARF
Dmitry Kovalev's avatar
Dmitry Kovalev committed
292
  struct lookahead_entry  *alt_ref_source[REF_FRAMES];
293
#else
John Koleszar's avatar
John Koleszar committed
294
  struct lookahead_entry  *alt_ref_source;
295
#endif
296
  struct lookahead_entry  *last_source;
John Koleszar's avatar
John Koleszar committed
297

John Koleszar's avatar
John Koleszar committed
298
  YV12_BUFFER_CONFIG *Source;
299
  YV12_BUFFER_CONFIG *Last_Source;  // NULL for first frame and alt_ref frames
John Koleszar's avatar
John Koleszar committed
300
301
  YV12_BUFFER_CONFIG *un_scaled_source;
  YV12_BUFFER_CONFIG scaled_source;
302
303
  YV12_BUFFER_CONFIG *unscaled_last_source;
  YV12_BUFFER_CONFIG scaled_last_source;
John Koleszar's avatar
John Koleszar committed
304

305
  int key_frame_frequency;
John Koleszar's avatar
John Koleszar committed
306

307
308
  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
309
  int gold_is_alt;  // don't do both alt and gold search ( just do gold).
John Koleszar's avatar
John Koleszar committed
310

311
  int scaled_ref_idx[3];
312
313
314
  int lst_fb_idx;
  int gld_fb_idx;
  int alt_fb_idx;
315

316
#if CONFIG_MULTIPLE_ARF
Dmitry Kovalev's avatar
Dmitry Kovalev committed
317
  int alt_ref_fb_idx[REF_FRAMES - 3];
318
#endif
319
320
321
  int refresh_last_frame;
  int refresh_golden_frame;
  int refresh_alt_ref_frame;
Deb Mukherjee's avatar
Deb Mukherjee committed
322
323
324
325
326
327
328
329
330

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

John Koleszar's avatar
John Koleszar committed
333
  TOKENEXTRA *tok;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
334
  unsigned int tok_count[4][1 << 6];
John Koleszar's avatar
John Koleszar committed
335

336
337
338
339
340
341
#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
342

John Koleszar's avatar
John Koleszar committed
343
344
  // Ambient reconstruction err target for force key frames
  int ambient_err;
345

346
347
348
349
350
351
352
  // 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 rd_thresh_mult[MAX_MODES];
  int rd_thresh_mult_sub8x8[MAX_REFS];

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];
John Koleszar's avatar
John Koleszar committed
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

John Koleszar's avatar
John Koleszar committed
369
370
  int RDMULT;
  int RDDIV;
John Koleszar's avatar
John Koleszar committed
371

John Koleszar's avatar
John Koleszar committed
372
  CODING_CONTEXT coding_context;
John Koleszar's avatar
John Koleszar committed
373

374
375
  int zbin_mode_boost;
  int zbin_mode_boost_enabled;
John Koleszar's avatar
John Koleszar committed
376
  int active_arnr_frames;           // <= cpi->oxcf.arnr_max_frames
377
  int active_arnr_strength;         // <= cpi->oxcf.arnr_max_strength
John Koleszar's avatar
John Koleszar committed
378

John Koleszar's avatar
John Koleszar committed
379
380
381
  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
382

383
  RATE_CONTROL rc;
John Koleszar's avatar
John Koleszar committed
384

John Koleszar's avatar
John Koleszar committed
385
  int cq_target_quality;
386

387
388
  vp9_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
  vp9_coeff_probs_model frame_coef_probs[TX_SIZES][PLANE_TYPES];
389

John Koleszar's avatar
John Koleszar committed
390
  struct vpx_codec_pkt_list  *output_pkt_list;
391

John Koleszar's avatar
John Koleszar committed
392
393
394
395
396
  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

  // for real time encoding
397
  int speed;
John Koleszar's avatar
John Koleszar committed
398
399
400

  int cpu_used;
  int pass;
John Koleszar's avatar
John Koleszar committed
401

John Koleszar's avatar
John Koleszar committed
402
  int ref_frame_flags;
John Koleszar's avatar
John Koleszar committed
403

John Koleszar's avatar
John Koleszar committed
404
  SPEED_FEATURES sf;
John Koleszar's avatar
John Koleszar committed
405

Paul Wilkins's avatar
Paul Wilkins committed
406
  unsigned int max_mv_magnitude;
407
  int mv_step_param;
Paul Wilkins's avatar
Paul Wilkins committed
408

409
410
411
412
413
414
415
  // 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
416
  unsigned char *segmentation_map;
Paul Wilkins's avatar
Paul Wilkins committed
417

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

421
422
  unsigned char *complexity_map;

John Koleszar's avatar
John Koleszar committed
423
424
  unsigned char *active_map;
  unsigned int active_map_enabled;
John Koleszar's avatar
John Koleszar committed
425

426
  CYCLIC_REFRESH *cyclic_refresh;
427

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

439
  struct twopass_rc twopass;
John Koleszar's avatar
John Koleszar committed
440

John Koleszar's avatar
John Koleszar committed
441
442
443
  YV12_BUFFER_CONFIG alt_ref_buffer;
  YV12_BUFFER_CONFIG *frames[MAX_LAG_BUFFERS];
  int fixed_divide[512];
John Koleszar's avatar
John Koleszar committed
444

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

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

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

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

John Koleszar's avatar
John Koleszar committed
480
481
482
483
  // Per MB activity measurement
  unsigned int activity_avg;
  unsigned int *mb_activity_map;
  int *mb_norm_activity_map;
484

John Koleszar's avatar
John Koleszar committed
485
  int droppable;
Adrian Grange's avatar
Adrian Grange committed
486

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
489
  unsigned int tx_stepdown_count[TX_SIZES];
Deb Mukherjee's avatar
Deb Mukherjee committed
490

491
492
  int initial_width;
  int initial_height;
493

494
495
  int use_svc;

496
  SVC svc;
497

498
499
  int use_large_partition_rate;

500
501
502
503
504
505
506
507
508
509
510
511
#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
Paul Wilkins's avatar
Paul Wilkins committed
512

513
514
515
516
#ifdef MODE_TEST_HIT_STATS
  // Debug / test stats
  int64_t mode_test_hits[BLOCK_SIZES];
#endif
517
} VP9_COMP;
John Koleszar's avatar
John Koleszar committed
518

519
520
521
522
523
void vp9_initialize_enc();

struct VP9_COMP *vp9_create_compressor(VP9_CONFIG *oxcf);
void vp9_remove_compressor(VP9_COMP *cpi);

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

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

541
void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags);
542
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

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

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

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

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

598
599
600
601
602
603
604
605
606
607
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);
}

608
int vp9_get_y_sse(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b);
609

610
void vp9_alloc_compressor_data(VP9_COMP *cpi);
611

612
613
614
615
void vp9_scale_references(VP9_COMP *cpi);

void vp9_update_reference_frames(VP9_COMP *cpi);

616
617
int64_t vp9_rescale(int64_t val, int64_t num, int denom);

618
619
620
static INLINE void set_ref_ptrs(VP9_COMMON *cm, MACROBLOCKD *xd,
                                MV_REFERENCE_FRAME ref0,
                                MV_REFERENCE_FRAME ref1) {
621
622
623
624
  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];
625
626
}

627
628
629
630
#ifdef __cplusplus
}  // extern "C"
#endif

631
#endif  // VP9_ENCODER_VP9_ONYX_INT_H_