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
get_ref_frame_idx(const VP9_COMP * cpi,MV_REFERENCE_FRAME ref_frame)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
get_ref_frame_buffer(VP9_COMP * cpi,MV_REFERENCE_FRAME ref_frame)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
vp9_frame_is_boosted(const VP9_COMP * cpi)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
get_token_alloc(int mb_rows,int mb_cols)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 extern const int q_trans[];
618
619 int64_t vp9_rescale(int64_t val, int64_t num, int denom);
620
set_ref_ptrs(VP9_COMMON * cm,MACROBLOCKD * xd,MV_REFERENCE_FRAME ref0,MV_REFERENCE_FRAME ref1)621 static 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