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
40extern "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
50typedef 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.
69typedef 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
109typedef 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
118typedef 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
127typedef enum {
128  NORMAL      = 0,
129  FOURFIVE    = 1,
130  THREEFIVE   = 2,
131  ONETWO      = 3
132} VPX_SCALING;
133
134typedef 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
141typedef 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
174typedef enum {
175  FRAMEFLAGS_KEY    = 1 << 0,
176  FRAMEFLAGS_GOLDEN = 1 << 1,
177  FRAMEFLAGS_ALTREF = 1 << 2,
178} FRAMETYPE_FLAGS;
179
180typedef 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
188typedef 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
284typedef 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
520void vp9_initialize_enc();
521
522struct VP9_COMP *vp9_create_compressor(VP9_CONFIG *oxcf);
523void vp9_remove_compressor(VP9_COMP *cpi);
524
525void 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..
529int 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
533int 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
537int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest,
538                              vp9_ppflags_t *flags);
539
540int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags);
541
542void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags);
543
544int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
545                           YV12_BUFFER_CONFIG *sd);
546
547int vp9_get_reference_enc(VP9_COMP *cpi, int index,
548                          YV12_BUFFER_CONFIG **fb);
549
550int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag,
551                          YV12_BUFFER_CONFIG *sd);
552
553int vp9_update_entropy(VP9_COMP *cpi, int update);
554
555int 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
561int vp9_set_active_map(VP9_COMP *cpi, unsigned char *map,
562                       unsigned int rows, unsigned int cols);
563
564int vp9_set_internal_size(VP9_COMP *cpi,
565                          VPX_SCALING horiz_mode, VPX_SCALING vert_mode);
566
567int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width,
568                         unsigned int height);
569
570void vp9_set_svc(VP9_COMP *cpi, int use_svc);
571
572int vp9_get_quantizer(struct VP9_COMP *cpi);
573
574static 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
585static 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
594static 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
599static 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
609int vp9_get_y_sse(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b);
610
611void vp9_alloc_compressor_data(VP9_COMP *cpi);
612
613void vp9_scale_references(VP9_COMP *cpi);
614
615void vp9_update_reference_frames(VP9_COMP *cpi);
616
617extern const int q_trans[];
618
619int64_t vp9_rescale(int64_t val, int64_t num, int denom);
620
621static INLINE void set_ref_ptrs(VP9_COMMON *cm, MACROBLOCKD *xd,
622                                MV_REFERENCE_FRAME ref0,
623                                MV_REFERENCE_FRAME ref1) {
624  xd->block_refs[0] = &cm->frame_refs[ref0 >= LAST_FRAME ? ref0 - LAST_FRAME
625                                                         : 0];
626  xd->block_refs[1] = &cm->frame_refs[ref1 >= LAST_FRAME ? ref1 - LAST_FRAME
627                                                         : 0];
628}
629
630#ifdef __cplusplus
631}  // extern "C"
632#endif
633
634#endif  // VP9_ENCODER_VP9_ONYX_INT_H_
635