vp9_onyx_int.h 29.5 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

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

36
37
38
39
#ifdef __cplusplus
extern "C" {
#endif

Paul Wilkins's avatar
Paul Wilkins committed
40
// #define MODE_TEST_HIT_STATS
41

42
43
44
45
#if CONFIG_MULTIPLE_ARF
// Set MIN_GF_INTERVAL to 1 for the full decomposition.
#define MIN_GF_INTERVAL             2
#else
John Koleszar's avatar
John Koleszar committed
46
#define MIN_GF_INTERVAL             4
47
#endif
48
#define DEFAULT_GF_INTERVAL         10
49
#define DEFAULT_KF_BOOST            2000
50
#define DEFAULT_GF_BOOST            2000
John Koleszar's avatar
John Koleszar committed
51
52
53

#define KEY_FRAME_CONTEXT 5

54
55
#define MAX_MODES 30
#define MAX_REFS  6
56

John Koleszar's avatar
John Koleszar committed
57
58
59
#define MIN_THRESHMULT  32
#define MAX_THRESHMULT  512

Paul Wilkins's avatar
Paul Wilkins committed
60
61
62
#define GF_ZEROMV_ZBIN_BOOST 0
#define LF_ZEROMV_ZBIN_BOOST 0
#define MV_ZBIN_BOOST        0
Paul Wilkins's avatar
Paul Wilkins committed
63
64
#define SPLIT_MV_ZBIN_BOOST  0
#define INTRA_ZBIN_BOOST     0
John Koleszar's avatar
John Koleszar committed
65

John Koleszar's avatar
John Koleszar committed
66
typedef struct {
67
68
69
  int nmvjointcost[MV_JOINTS];
  int nmvcosts[2][MV_VALS];
  int nmvcosts_hp[2][MV_VALS];
John Koleszar's avatar
John Koleszar committed
70

71
  vp9_prob segment_pred_probs[PREDICTION_PROBS];
John Koleszar's avatar
John Koleszar committed
72

John Koleszar's avatar
John Koleszar committed
73
  unsigned char *last_frame_seg_map_copy;
74

John Koleszar's avatar
John Koleszar committed
75
76
  // 0 = Intra, Last, GF, ARF
  signed char last_ref_lf_deltas[MAX_REF_LF_DELTAS];
77
  // 0 = ZERO_MV, MV
John Koleszar's avatar
John Koleszar committed
78
  signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS];
John Koleszar's avatar
John Koleszar committed
79

80
  FRAME_CONTEXT fc;
John Koleszar's avatar
John Koleszar committed
81
82
} CODING_CONTEXT;

83
84
// 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
85
86
typedef enum {
  THR_NEARESTMV,
Paul Wilkins's avatar
Paul Wilkins committed
87
88
  THR_NEARESTA,
  THR_NEARESTG,
John Koleszar's avatar
John Koleszar committed
89

90
91
92
  THR_DC,

  THR_NEWMV,
Paul Wilkins's avatar
Paul Wilkins committed
93
  THR_NEWA,
94
95
96
  THR_NEWG,

  THR_NEARMV,
John Koleszar's avatar
John Koleszar committed
97
  THR_NEARA,
98
99
  THR_COMP_NEARESTLA,
  THR_COMP_NEARESTGA,
John Koleszar's avatar
John Koleszar committed
100
101

  THR_TM,
102

Paul Wilkins's avatar
Paul Wilkins committed
103
104
105
106
107
  THR_COMP_NEARLA,
  THR_COMP_NEWLA,
  THR_NEARG,
  THR_COMP_NEARGA,
  THR_COMP_NEWGA,
108

Paul Wilkins's avatar
Paul Wilkins committed
109
110
111
  THR_ZEROMV,
  THR_ZEROG,
  THR_ZEROA,
John Koleszar's avatar
John Koleszar committed
112
113
  THR_COMP_ZEROLA,
  THR_COMP_ZEROGA,
114

Paul Wilkins's avatar
Paul Wilkins committed
115
116
117
  THR_H_PRED,
  THR_V_PRED,
  THR_D135_PRED,
Dmitry Kovalev's avatar
Dmitry Kovalev committed
118
  THR_D207_PRED,
Paul Wilkins's avatar
Paul Wilkins committed
119
120
121
122
  THR_D153_PRED,
  THR_D63_PRED,
  THR_D117_PRED,
  THR_D45_PRED,
Ronald S. Bultje's avatar
Ronald S. Bultje committed
123
} THR_MODES;
John Koleszar's avatar
John Koleszar committed
124

125
126
127
128
129
130
131
132
133
typedef enum {
  THR_LAST,
  THR_GOLD,
  THR_ALTR,
  THR_COMP_LA,
  THR_COMP_GA,
  THR_INTRA,
} THR_MODES_SUB8X8;

John Koleszar's avatar
John Koleszar committed
134
135
136
typedef enum {
  DIAMOND = 0,
  NSTEP = 1,
137
138
  HEX = 2,
  BIGDIA = 3,
139
140
  SQUARE = 4,
  FAST_HEX = 5
John Koleszar's avatar
John Koleszar committed
141
142
} SEARCH_METHODS;

Deb Mukherjee's avatar
Deb Mukherjee committed
143
144
145
146
147
148
149
typedef enum {
  USE_FULL_RD = 0,
  USE_LARGESTINTRA,
  USE_LARGESTINTRA_MODELINTER,
  USE_LARGESTALL
} TX_SIZE_SEARCH_METHOD;

150
151
152
153
154
155
typedef enum {
  NOT_IN_USE = 0,
  RELAXED_NEIGHBORING_MIN_MAX = 1,
  STRICT_NEIGHBORING_MIN_MAX = 2
} AUTO_MIN_MAX_MODE;

156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
typedef enum {
  // Values should be powers of 2 so that they can be selected as bits of
  // an integer flags field

  // terminate search early based on distortion so far compared to
  // qp step, distortion in the neighborhood of the frame, etc.
  FLAG_EARLY_TERMINATE = 1,

  // skips comp inter modes if the best so far is an intra mode
  FLAG_SKIP_COMP_BESTINTRA = 2,

  // skips comp inter modes if the best single intermode so far does
  // not have the same reference as one of the two references being
  // tested
  FLAG_SKIP_COMP_REFMISMATCH = 4,

  // skips oblique intra modes if the best so far is an inter mode
  FLAG_SKIP_INTRA_BESTINTER = 8,

  // skips oblique intra modes  at angles 27, 63, 117, 153 if the best
  // intra so far is not one of the neighboring directions
  FLAG_SKIP_INTRA_DIRMISMATCH = 16,
178
179
180
181

  // skips intra modes other than DC_PRED if the source variance
  // is small
  FLAG_SKIP_INTRA_LOWVAR = 32,
182
183
} MODE_SEARCH_SKIP_LOGIC;

184
typedef enum {
185
  SUBPEL_TREE = 0,
186
187
188
  // Other methods to come
} SUBPEL_SEARCH_METHODS;

189
190
191
#define ALL_INTRA_MODES 0x3FF
#define INTRA_DC_ONLY 0x01
#define INTRA_DC_TM ((1 << TM_PRED) | (1 << DC_PRED))
192
#define INTRA_DC_H_V ((1 << DC_PRED) | (1 << V_PRED) | (1 << H_PRED))
193
194
#define INTRA_DC_TM_H_V (INTRA_DC_TM | (1 << V_PRED) | (1 << H_PRED))

Paul Wilkins's avatar
Paul Wilkins committed
195
196
197
198
199
200
typedef enum {
  LAST_FRAME_PARTITION_OFF = 0,
  LAST_FRAME_PARTITION_LOW_MOTION = 1,
  LAST_FRAME_PARTITION_ALL = 2
} LAST_FRAME_PARTITION_METHOD;

201
202
203
204
205
206
207
208
209
210
211
typedef enum {
  // No recode.
  DISALLOW_RECODE = 0,
  // Allow recode for KF and exceeding maximum frame bandwidth.
  ALLOW_RECODE_KFMAXBW = 1,
  // Allow recode only for KF/ARF/GF frames.
  ALLOW_RECODE_KFARFGF = 2,
  // Allow recode for all frames based on bitrate constraints.
  ALLOW_RECODE = 3,
} RECODE_LOOP_TYPE;

212
213
214
215
216
217
218
219
220
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;

221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
typedef enum {
  // Search partitions using RD/NONRD criterion
  SEARCH_PARTITION = 0,

  // Always use a fixed size partition
  FIXED_PARTITION = 1,

  // Use a fixed size partition in every 64X64 SB, where the size is
  // determined based on source variance
  VAR_BASED_FIXED_PARTITION = 2,

  // Use an arbitrary partitioning scheme based on source variance within
  // a 64X64 SB
  VAR_BASED_PARTITION
} PARTITION_SEARCH_TYPE;

John Koleszar's avatar
John Koleszar committed
237
typedef struct {
238
239
  // Frame level coding parameter update
  int frame_parameter_update;
Jim Bankoski's avatar
Jim Bankoski committed
240
241

  // Motion search method (Diamond, NSTEP, Hex, Big Diamond, Square, etc).
John Koleszar's avatar
John Koleszar committed
242
  SEARCH_METHODS search_method;
Jim Bankoski's avatar
Jim Bankoski committed
243

244
  RECODE_LOOP_TYPE recode_loop;
Jim Bankoski's avatar
Jim Bankoski committed
245
246
247
248
249

  // Subpel_search_method can only be subpel_tree which does a subpixel
  // logarithmic search that keeps stepping at 1/2 pixel units until
  // you stop getting a gain, and then goes on to 1/4 and repeats
  // the same process. Along the way it skips many diagonals.
250
  SUBPEL_SEARCH_METHODS subpel_search_method;
Jim Bankoski's avatar
Jim Bankoski committed
251
252

  // Maximum number of steps in logarithmic subpel search before giving up.
253
  int subpel_iters_per_step;
Jim Bankoski's avatar
Jim Bankoski committed
254

Yaowu Xu's avatar
Yaowu Xu committed
255
256
257
  // Control when to stop subpel search
  int subpel_force_stop;

Jim Bankoski's avatar
Jim Bankoski committed
258
259
260
261
  // 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.
John Koleszar's avatar
John Koleszar committed
262
  int thresh_mult[MAX_MODES];
263
  int thresh_mult_sub8x8[MAX_REFS];
Jim Bankoski's avatar
Jim Bankoski committed
264
265
266

  // This parameter controls the number of steps we'll do in a diamond
  // search.
John Koleszar's avatar
John Koleszar committed
267
  int max_step_search_steps;
Jim Bankoski's avatar
Jim Bankoski committed
268
269
270

  // This parameter controls which step in the n-step process we start at.
  // It's changed adaptively based on circumstances.
271
  int reduce_first_step_size;
Jim Bankoski's avatar
Jim Bankoski committed
272
273
274

  // If this is set to 1, we limit the motion search range to 2 times the
  // largest motion vector found in the last frame.
Paul Wilkins's avatar
Paul Wilkins committed
275
  int auto_mv_step_size;
Jim Bankoski's avatar
Jim Bankoski committed
276
277

  // Trellis (dynamic programming) optimization of quantized values (+1, 0).
John Koleszar's avatar
John Koleszar committed
278
  int optimize_coefficients;
Jim Bankoski's avatar
Jim Bankoski committed
279
280
281
282
283
284

  // Always set to 0. If on it enables 0 cost background transmission
  // (except for the initial transmission of the segmentation). The feature is
  // disabled because the addition of very large block sizes make the
  // backgrounds very to cheap to encode, and the segmentation we have
  // adds overhead.
285
  int static_segmentation;
Jim Bankoski's avatar
Jim Bankoski committed
286
287
288
289
290

  // If 1 we iterate finding a best reference for 2 ref frames together - via
  // a log search that iterates 4 times (check around mv for last for best
  // error of combined predictor then check around mv for alt). If 0 we
  // we just use the best motion vector found for each frame by itself.
291
  int comp_inter_joint_search_thresh;
Jim Bankoski's avatar
Jim Bankoski committed
292
293
294

  // This variable is used to cap the maximum number of times we skip testing a
  // mode to be evaluated. A high value means we will be faster.
295
  int adaptive_rd_thresh;
Jim Bankoski's avatar
Jim Bankoski committed
296
297
298
299

  // Enables skipping the reconstruction step (idct, recon) in the
  // intermediate steps assuming the last frame didn't have too many intra
  // blocks and the q is less than a threshold.
300
  int skip_encode_sb;
301
  int skip_encode_frame;
Jim Bankoski's avatar
Jim Bankoski committed
302
303
304
305
306
307
308
309

  // This variable allows us to reuse the last frames partition choices
  // (64x64 v 32x32 etc) for this frame. It can be set to only use the last
  // frame as a starting point in low motion scenes or always use it. If set
  // we use last partitioning_redo frequency to determine how often to redo
  // the partitioning from scratch. Adjust_partitioning_from_last_frame
  // enables us to adjust up or down one partitioning from the last frames
  // partitioning.
Paul Wilkins's avatar
Paul Wilkins committed
310
  LAST_FRAME_PARTITION_METHOD use_lastframe_partitioning;
Jim Bankoski's avatar
Jim Bankoski committed
311
312
313
314

  // Determine which method we use to determine transform size. We can choose
  // between options like full rd, largest for prediction size, largest
  // for intra and model coefs for the rest.
Deb Mukherjee's avatar
Deb Mukherjee committed
315
  TX_SIZE_SEARCH_METHOD tx_size_search_method;
Jim Bankoski's avatar
Jim Bankoski committed
316
317
318

  // Low precision 32x32 fdct keeps everything in 16 bits and thus is less
  // precise but significantly faster than the non lp version.
319
  int use_lp32x32fdct;
Jim Bankoski's avatar
Jim Bankoski committed
320
321
322
323
324
325

  // TODO(JBB): remove this as its no longer used.

  // After looking at the first set of modes (set by index here), skip
  // checking modes for reference frames that don't match the reference frame
  // of the best so far.
326
  int mode_skip_start;
Jim Bankoski's avatar
Jim Bankoski committed
327
328

  // TODO(JBB): Remove this.
Paul Wilkins's avatar
Paul Wilkins committed
329
  int reference_masking;
Jim Bankoski's avatar
Jim Bankoski committed
330

331
332
333
  PARTITION_SEARCH_TYPE partition_search_type;

  // Used if partition_search_type = FIXED_SIZE_PARTITION
334
  BLOCK_SIZE always_this_block_size;
Jim Bankoski's avatar
Jim Bankoski committed
335

336
337
338
339
340
341
342
  // Skip rectangular partition test when partition type none gives better
  // rd than partition type split.
  int less_rectangular_check;

  // Disable testing non square partitions. (eg 16x32)
  int use_square_partition_only;

Jim Bankoski's avatar
Jim Bankoski committed
343
  // Sets min and max partition sizes for this 64x64 region based on the
344
345
  // same 64x64 in last encoded frame, and the left and above neighbor.
  AUTO_MIN_MAX_MODE auto_min_max_partition_size;
Jim Bankoski's avatar
Jim Bankoski committed
346
347
348

  // Min and max partition size we enable (block_size) as per auto
  // min max, but also used by adjust partitioning, and pick_partitioning.
349
350
  BLOCK_SIZE min_partition_size;
  BLOCK_SIZE max_partition_size;
Jim Bankoski's avatar
Jim Bankoski committed
351
352
353

  // Whether or not we allow partitions one smaller or one greater than the last
  // frame's partitioning. Only used if use_lastframe_partitioning is set.
354
  int adjust_partitioning_from_last_frame;
Jim Bankoski's avatar
Jim Bankoski committed
355
356
357

  // How frequently we re do the partitioning from scratch. Only used if
  // use_lastframe_partitioning is set.
358
  int last_partitioning_redo_frequency;
Jim Bankoski's avatar
Jim Bankoski committed
359
360
361
362

  // Disables sub 8x8 blocksizes in different scenarios: Choices are to disable
  // it always, to allow it for only Last frame and Intra, disable it for all
  // inter modes or to enable it always.
363
  int disable_split_mask;
Jim Bankoski's avatar
Jim Bankoski committed
364

Jingning Han's avatar
Jingning Han committed
365
  // TODO(jingning): combine the related motion search speed features
Jim Bankoski's avatar
Jim Bankoski committed
366
367
  // This allows us to use motion search at other sizes as a starting
  // point for this motion search and limits the search range around it.
Jingning Han's avatar
Jingning Han committed
368
  int adaptive_motion_search;
Jim Bankoski's avatar
Jim Bankoski committed
369
370
371
372
373

  // Allows sub 8x8 modes to use the prediction filter that was determined
  // best for 8x8 mode. If set to 0 we always re check all the filters for
  // sizes less than 8x8, 1 means we check all filter modes if no 8x8 filter
  // was selected, and 2 means we use 8 tap if no 8x8 filter mode was selected.
374
  int adaptive_pred_interp_filter;
375
376
377
378
379

  // Implements various heuristics to skip searching modes
  // The heuristics selected are based on  flags
  // defined in the MODE_SEARCH_SKIP_HEURISTICS enum
  unsigned int mode_search_skip_flags;
Jim Bankoski's avatar
Jim Bankoski committed
380

381
382
  // A source variance threshold below which the split mode is disabled
  unsigned int disable_split_var_thresh;
Jim Bankoski's avatar
Jim Bankoski committed
383

384
385
386
  // A source variance threshold below which filter search is disabled
  // Choose a very large value (UINT_MAX) to use 8-tap always
  unsigned int disable_filter_search_var_thresh;
Jim Bankoski's avatar
Jim Bankoski committed
387
388
389

  // These bit masks allow you to enable or disable intra modes for each
  // transform size separately.
390
391
  int intra_y_mode_mask[TX_SIZES];
  int intra_uv_mode_mask[TX_SIZES];
Jim Bankoski's avatar
Jim Bankoski committed
392
393
394
395

  // This variable enables an early break out of mode testing if the model for
  // rd built from the prediction signal indicates a value that's much
  // higher than the best rd we've seen so far.
396
  int use_rd_breakout;
Jim Bankoski's avatar
Jim Bankoski committed
397
398
399
400

  // This enables us to use an estimate for intra rd based on dc mode rather
  // than choosing an actual uv mode in the stage of encoding before the actual
  // final encode.
401
  int use_uv_intra_rd_estimate;
Jim Bankoski's avatar
Jim Bankoski committed
402

403
404
405
406
  // This feature controls how the loop filter level is determined:
  // 0: Try the full image with different values.
  // 1: Try a small portion of the image with different values.
  // 2: Estimate the level based on quantizer and frame type
407
  int use_fast_lpf_pick;
Jim Bankoski's avatar
Jim Bankoski committed
408
409
410

  // This feature limits the number of coefficients updates we actually do
  // by only looking at counts from 1/2 the bands.
411
  int use_fast_coef_updates;  // 0: 2-loop, 1: 1-loop, 2: 1-loop reduced
412

413
  // This flag controls the use of non-RD mode decision.
414
  int use_nonrd_pick_mode;
415
416
417
418

  // This variable sets the encode_breakout threshold. Currently, it is only
  // enabled in real time mode.
  int encode_breakout_thresh;
419
420
421
422

  // A binary mask indicating if NEARESTMV, NEARMV, ZEROMV, NEWMV
  // modes are disabled in order from LSB to MSB for each BLOCK_SIZE.
  int disable_inter_mode_mask[BLOCK_SIZES];
423
424
425
426

  // This feature controls whether we do the expensive context update and
  // calculation in the rd coefficient costing loop.
  int use_fast_coef_costing;
427
428
429
430
431

  // This variable controls the maximum block size where intra blocks can be
  // used in inter frames.
  // TODO(aconverse): Fold this into one of the other many mode skips
  BLOCK_SIZE max_intra_bsize;
John Koleszar's avatar
John Koleszar committed
432
433
} SPEED_FEATURES;

434
435
436
437
438
439
440
typedef struct {
  RATE_CONTROL rc;
  int target_bandwidth;
  int64_t starting_buffer_level;
  int64_t optimal_buffer_level;
  int64_t maximum_buffer_size;
  double framerate;
441
  int avg_frame_size;
442
443
} LAYER_CONTEXT;

444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
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
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
#define MAX_SEGMENTS 8

typedef enum {
  NORMAL      = 0,
  FOURFIVE    = 1,
  THREEFIVE   = 2,
  ONETWO      = 3
} VPX_SCALING;

typedef enum {
  VP9_LAST_FLAG = 1,
  VP9_GOLD_FLAG = 2,
  VP9_ALT_FLAG = 4
} VP9_REFFRAME;

typedef enum {
  USAGE_LOCAL_FILE_PLAYBACK   = 0x0,
  USAGE_STREAM_FROM_SERVER    = 0x1,
  USAGE_CONSTRAINED_QUALITY   = 0x2,
  USAGE_CONSTANT_QUALITY      = 0x3,
} END_USAGE;


typedef enum {
  MODE_GOODQUALITY    = 0x1,
  MODE_BESTQUALITY    = 0x2,
  MODE_FIRSTPASS      = 0x3,
  MODE_SECONDPASS     = 0x4,
  MODE_SECONDPASS_BEST = 0x5,
  MODE_REALTIME       = 0x6,
} MODE;

typedef enum {
  FRAMEFLAGS_KEY    = 1,
  FRAMEFLAGS_GOLDEN = 2,
  FRAMEFLAGS_ALTREF = 4,
} FRAMETYPE_FLAGS;

typedef enum {
  NO_AQ = 0,
  VARIANCE_AQ = 1,
  COMPLEXITY_AQ = 2,
  AQ_MODES_COUNT  // This should always be the last member of the enum
} AQ_MODES;

typedef struct {
  int version;  // 4 versions of bitstream defined:
                //   0 - best quality/slowest decode,
                //   3 - lowest quality/fastest decode
  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;

  // mode ->
  // (0)=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 )
  // (1)=Good Quality Fast Encoding. The encoder balances quality with the
  //     amount of time it takes to encode the output. ( speed setting
  //     controls how fast )
  // (2)=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 )
  // (3)=Two Pass - First Pass. The encoder generates a file of statistics
  //     for use in the second encoding pass. ( speed setting controls how
  //     fast )
  // (4)=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 )
  // (5)=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 )
  int mode;

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

  int end_usage;  // vbr or cbr

  // 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;
  int aq_mode;  // Adaptive Quantization mode

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

604
typedef struct VP9_COMP {
605
606
607
608
  DECLARE_ALIGNED(16, int16_t, y_quant[QINDEX_RANGE][8]);
  DECLARE_ALIGNED(16, int16_t, y_quant_shift[QINDEX_RANGE][8]);
  DECLARE_ALIGNED(16, int16_t, y_zbin[QINDEX_RANGE][8]);
  DECLARE_ALIGNED(16, int16_t, y_round[QINDEX_RANGE][8]);
John Koleszar's avatar
John Koleszar committed
609

610
611
612
613
  DECLARE_ALIGNED(16, int16_t, uv_quant[QINDEX_RANGE][8]);
  DECLARE_ALIGNED(16, int16_t, uv_quant_shift[QINDEX_RANGE][8]);
  DECLARE_ALIGNED(16, int16_t, uv_zbin[QINDEX_RANGE][8]);
  DECLARE_ALIGNED(16, int16_t, uv_round[QINDEX_RANGE][8]);
John Koleszar's avatar
John Koleszar committed
614

615
#if CONFIG_ALPHA
616
617
618
619
  DECLARE_ALIGNED(16, int16_t, a_quant[QINDEX_RANGE][8]);
  DECLARE_ALIGNED(16, int16_t, a_quant_shift[QINDEX_RANGE][8]);
  DECLARE_ALIGNED(16, int16_t, a_zbin[QINDEX_RANGE][8]);
  DECLARE_ALIGNED(16, int16_t, a_round[QINDEX_RANGE][8]);
620
#endif
John Koleszar's avatar
John Koleszar committed
621

John Koleszar's avatar
John Koleszar committed
622
  MACROBLOCK mb;
623
  VP9_COMMON common;
624
  VP9_CONFIG oxcf;
John Koleszar's avatar
John Koleszar committed
625
626
  struct lookahead_ctx    *lookahead;
  struct lookahead_entry  *source;
627
#if CONFIG_MULTIPLE_ARF
Dmitry Kovalev's avatar
Dmitry Kovalev committed
628
  struct lookahead_entry  *alt_ref_source[REF_FRAMES];
629
#else
John Koleszar's avatar
John Koleszar committed
630
  struct lookahead_entry  *alt_ref_source;
631
#endif
John Koleszar's avatar
John Koleszar committed
632

John Koleszar's avatar
John Koleszar committed
633
634
635
  YV12_BUFFER_CONFIG *Source;
  YV12_BUFFER_CONFIG *un_scaled_source;
  YV12_BUFFER_CONFIG scaled_source;
John Koleszar's avatar
John Koleszar committed
636

637
  int key_frame_frequency;
John Koleszar's avatar
John Koleszar committed
638

639
640
  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
641
  int gold_is_alt;  // don't do both alt and gold search ( just do gold).
John Koleszar's avatar
John Koleszar committed
642

643
  int scaled_ref_idx[3];
644
645
646
  int lst_fb_idx;
  int gld_fb_idx;
  int alt_fb_idx;
647

648
#if CONFIG_MULTIPLE_ARF
Dmitry Kovalev's avatar
Dmitry Kovalev committed
649
  int alt_ref_fb_idx[REF_FRAMES - 3];
650
#endif
651
652
653
  int refresh_last_frame;
  int refresh_golden_frame;
  int refresh_alt_ref_frame;
Deb Mukherjee's avatar
Deb Mukherjee committed
654
655
656
657
658
659
660
661
662

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

John Koleszar's avatar
John Koleszar committed
665
  TOKENEXTRA *tok;
Ronald S. Bultje's avatar
Ronald S. Bultje committed
666
  unsigned int tok_count[4][1 << 6];
John Koleszar's avatar
John Koleszar committed
667

668
669
670
671
672
673
#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
674

John Koleszar's avatar
John Koleszar committed
675
676
  // Ambient reconstruction err target for force key frames
  int ambient_err;
677

678
  int rd_threshes[MAX_SEGMENTS][BLOCK_SIZES][MAX_MODES];
679
  int rd_thresh_freq_fact[BLOCK_SIZES][MAX_MODES];
680
  int rd_thresh_sub8x8[MAX_SEGMENTS][BLOCK_SIZES][MAX_REFS];
681
  int rd_thresh_freq_sub8x8[BLOCK_SIZES][MAX_REFS];
682

683
684
  int64_t rd_comp_pred_diff[REFERENCE_MODES];
  int64_t rd_prediction_type_threshes[4][REFERENCE_MODES];
685
  int64_t rd_tx_select_diff[TX_MODES];
686
  // FIXME(rbultje) can this overflow?
687
  int rd_tx_select_threshes[4][TX_MODES];
John Koleszar's avatar
John Koleszar committed
688

689
690
691
  int64_t rd_filter_diff[SWITCHABLE_FILTER_CONTEXTS];
  int64_t rd_filter_threshes[4][SWITCHABLE_FILTER_CONTEXTS];
  int64_t rd_filter_cache[SWITCHABLE_FILTER_CONTEXTS];
692
  int64_t mask_filter_rd;
693

John Koleszar's avatar
John Koleszar committed
694
695
  int RDMULT;
  int RDDIV;
John Koleszar's avatar
John Koleszar committed
696

John Koleszar's avatar
John Koleszar committed
697
  CODING_CONTEXT coding_context;
John Koleszar's avatar
John Koleszar committed
698

699
700
  int zbin_mode_boost;
  int zbin_mode_boost_enabled;
John Koleszar's avatar
John Koleszar committed
701
  int active_arnr_frames;           // <= cpi->oxcf.arnr_max_frames
702
  int active_arnr_strength;         // <= cpi->oxcf.arnr_max_strength
John Koleszar's avatar
John Koleszar committed
703

James Zern's avatar
James Zern committed
704
  double output_framerate;
John Koleszar's avatar
John Koleszar committed
705
706
707
  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
708

709
  RATE_CONTROL rc;
John Koleszar's avatar
John Koleszar committed
710

John Koleszar's avatar
John Koleszar committed
711
  int cq_target_quality;
712

713
714
715
  vp9_coeff_count coef_counts[TX_SIZES][PLANE_TYPES];
  vp9_coeff_probs_model frame_coef_probs[TX_SIZES][PLANE_TYPES];
  vp9_coeff_stats frame_branch_ct[TX_SIZES][PLANE_TYPES];
716

John Koleszar's avatar
John Koleszar committed
717
  struct vpx_codec_pkt_list  *output_pkt_list;
718

John Koleszar's avatar
John Koleszar committed
719
720
721
722
723
724
  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 seg0_progress, seg0_idx, seg0_cnt;

  // for real time encoding
725
  int speed;
John Koleszar's avatar
John Koleszar committed
726
727
728

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
730
  vp9_prob last_skip_false_probs[3][SKIP_CONTEXTS];
John Koleszar's avatar
John Koleszar committed
731
  int last_skip_probs_q[3];
John Koleszar's avatar
John Koleszar committed
732

John Koleszar's avatar
John Koleszar committed
733
  int ref_frame_flags;
John Koleszar's avatar
John Koleszar committed
734

John Koleszar's avatar
John Koleszar committed
735
  SPEED_FEATURES sf;
John Koleszar's avatar
John Koleszar committed
736

Paul Wilkins's avatar
Paul Wilkins committed
737
  unsigned int max_mv_magnitude;
738
  int mv_step_param;
Paul Wilkins's avatar
Paul Wilkins committed
739

740
741
742
743
744
745
746
  // 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
747
  unsigned char *segmentation_map;
Paul Wilkins's avatar
Paul Wilkins committed
748

John Koleszar's avatar
John Koleszar committed
749
  // segment threashold for encode breakout
Paul Wilkins's avatar
Paul Wilkins committed
750
  int  segment_encode_breakout[MAX_SEGMENTS];
John Koleszar's avatar
John Koleszar committed
751

752
753
  unsigned char *complexity_map;

John Koleszar's avatar
John Koleszar committed
754
755
  unsigned char *active_map;
  unsigned int active_map_enabled;
John Koleszar's avatar
John Koleszar committed
756

John Koleszar's avatar
John Koleszar committed
757
  fractional_mv_step_fp *find_fractional_mv_step;
758
  fractional_mv_step_comp_fp *find_fractional_mv_step_comp;
759
760
761
  vp9_full_search_fn_t full_search_sad;
  vp9_refining_search_fn_t refining_search_sad;
  vp9_diamond_search_fn_t diamond_search_sad;
762
  vp9_variance_fn_ptr_t fn_ptr[BLOCK_SIZES];
Yaowu Xu's avatar
Yaowu Xu committed
763
764
765
  uint64_t time_receive_data;
  uint64_t time_compress_data;
  uint64_t time_pick_lpf;
766
  uint64_t time_encode_sb_row;
John Koleszar's avatar
John Koleszar committed
767

768
  struct twopass_rc twopass;
John Koleszar's avatar
John Koleszar committed
769

John Koleszar's avatar
John Koleszar committed
770
771
772
  YV12_BUFFER_CONFIG alt_ref_buffer;
  YV12_BUFFER_CONFIG *frames[MAX_LAG_BUFFERS];
  int fixed_divide[512];
John Koleszar's avatar
John Koleszar committed
773

774
#if CONFIG_INTERNAL_STATS
775
776
  unsigned int mode_chosen_counts[MAX_MODES];

John Koleszar's avatar
John Koleszar committed
777
778
779
780
781
  int    count;
  double total_y;
  double total_u;
  double total_v;
  double total;
782
783
784
  uint64_t total_sq_error;
  uint64_t total_samples;

John Koleszar's avatar
John Koleszar committed
785
786
787
788
  double totalp_y;
  double totalp_u;
  double totalp_v;
  double totalp;
789
790
791
  uint64_t totalp_sq_error;
  uint64_t totalp_samples;

John Koleszar's avatar
John Koleszar committed
792
793
794
  int    bytes;
  double summed_quality;
  double summed_weights;
795
796
  double summedp_quality;
  double summedp_weights;
John Koleszar's avatar
John Koleszar committed
797
798
799
800
801
802
803
804
805
  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
806
#endif
John Koleszar's avatar
John Koleszar committed
807
  int b_calculate_psnr;
808

John Koleszar's avatar
John Koleszar committed
809
810
811
812
813
  // Per MB activity measurement
  unsigned int activity_avg;
  unsigned int *mb_activity_map;
  int *mb_norm_activity_map;
  int output_partition;
814

Jim Bankoski's avatar
Jim Bankoski committed
815
  // Force next frame to intra when kf_auto says so.
John Koleszar's avatar
John Koleszar committed
816
  int force_next_frame_intra;
817

John Koleszar's avatar
John Koleszar committed
818
  int droppable;
Adrian Grange's avatar
Adrian Grange committed
819

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

Dmitry Kovalev's avatar
Dmitry Kovalev committed
822
  unsigned int tx_stepdown_count[TX_SIZES];
Deb Mukherjee's avatar
Deb Mukherjee committed
823

824
825
  int initial_width;
  int initial_height;
826

827
828
829
830
831
832
833
834
835
836
837
838
  int use_svc;

  struct svc {
    int spatial_layer_id;
    int temporal_layer_id;
    int number_spatial_layers;
    int number_temporal_layers;
    // Layer context used for rate control in CBR mode, only defined for
    // temporal layers for now.
    LAYER_CONTEXT layer_context[VPX_TS_MAX_LAYERS];
  } svc;

839
840
841
842
843
844
845
846
847
848
849
850
#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
851
852

#ifdef ENTROPY_STATS
853
  int64_t mv_ref_stats[INTER_MODE_CONTEXTS][INTER_MODES - 1][2];
Paul Wilkins's avatar
Paul Wilkins committed
854
#endif
855
856
857
858
859
860


#ifdef MODE_TEST_HIT_STATS
  // Debug / test stats
  int64_t mode_test_hits[BLOCK_SIZES];
#endif
861

Jim Bankoski's avatar
Jim Bankoski committed
862
  // Y,U,V,(A)
863
864
865
  ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
  ENTROPY_CONTEXT left_context[MAX_MB_PLANE][16];

866
867
  PARTITION_CONTEXT *above_seg_context;
  PARTITION_CONTEXT left_seg_context[8];
868
} VP9_COMP;
John Koleszar's avatar
John Koleszar committed
869

870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
void vp9_initialize_enc();

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

void vp9_change_config(VP9_COMP *cpi, VP9_CONFIG *oxcf);

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

int vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags);

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

924
925
static int get_ref_frame_idx(const VP9_COMP *cpi,
                             MV_REFERENCE_FRAME ref_frame) {
926
927
928
929
930
931
932
933
934
  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;
  }
}

935
936
937
static YV12_BUFFER_CONFIG *get_ref_frame_buffer(VP9_COMP *cpi,
                                                MV_REFERENCE_FRAME ref_frame) {
  VP9_COMMON *const cm = &cpi->common;
938
939
  return &cm->frame_bufs[cm->ref_frame_map[get_ref_frame_idx(cpi,
                                                             ref_frame)]].buf;
940
941
}

942
void vp9_encode_frame(VP9_COMP *cpi);
John Koleszar's avatar
John Koleszar committed
943

944
void vp9_set_speed_features(VP9_COMP *cpi);
Yaowu Xu's avatar
Yaowu Xu committed
945

946
947
int vp9_calc_ss_err(const YV12_BUFFER_CONFIG *source,
                    const YV12_BUFFER_CONFIG *reference);
948

949
void vp9_alloc_compressor_data(VP9_COMP *cpi);
950

Deb Mukherjee's avatar
Deb Mukherjee committed
951
int vp9_compute_qdelta(const VP9_COMP *cpi, double qstart, double qtarget);
952

953
954
955
956
static int get_token_alloc(int mb_rows, int mb_cols) {
  return mb_rows * mb_cols * (48 * 16 + 4);
}

957
958
static void set_ref_ptrs(VP9_COMMON *cm, MACROBLOCKD *xd,
                         MV_REFERENCE_FRAME ref0, MV_REFERENCE_FRAME ref1) {
959
960
961
962
  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];
963
964
}

965
966
967
968
#ifdef __cplusplus
}  // extern "C"
#endif

969
#endif  // VP9_ENCODER_VP9_ONYX_INT_H_