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_ENCODER_H_ 12 #define VP9_ENCODER_VP9_ENCODER_H_ 13 14 #include <stdio.h> 15 16 #include "./vpx_config.h" 17 #include "vpx/internal/vpx_codec_internal.h" 18 #include "vpx/vp8cx.h" 19 #if CONFIG_INTERNAL_STATS 20 #include "vpx_dsp/ssim.h" 21 #endif 22 #include "vpx_dsp/variance.h" 23 #include "vpx_ports/system_state.h" 24 #include "vpx_util/vpx_thread.h" 25 26 #include "vp9/common/vp9_alloccommon.h" 27 #include "vp9/common/vp9_ppflags.h" 28 #include "vp9/common/vp9_entropymode.h" 29 #include "vp9/common/vp9_thread_common.h" 30 #include "vp9/common/vp9_onyxc_int.h" 31 32 #include "vp9/encoder/vp9_alt_ref_aq.h" 33 #include "vp9/encoder/vp9_aq_cyclicrefresh.h" 34 #include "vp9/encoder/vp9_context_tree.h" 35 #include "vp9/encoder/vp9_encodemb.h" 36 #include "vp9/encoder/vp9_ethread.h" 37 #include "vp9/encoder/vp9_firstpass.h" 38 #include "vp9/encoder/vp9_job_queue.h" 39 #include "vp9/encoder/vp9_lookahead.h" 40 #include "vp9/encoder/vp9_mbgraph.h" 41 #include "vp9/encoder/vp9_mcomp.h" 42 #include "vp9/encoder/vp9_noise_estimate.h" 43 #include "vp9/encoder/vp9_quantize.h" 44 #include "vp9/encoder/vp9_ratectrl.h" 45 #include "vp9/encoder/vp9_rd.h" 46 #include "vp9/encoder/vp9_speed_features.h" 47 #include "vp9/encoder/vp9_svc_layercontext.h" 48 #include "vp9/encoder/vp9_tokenize.h" 49 50 #if CONFIG_VP9_TEMPORAL_DENOISING 51 #include "vp9/encoder/vp9_denoiser.h" 52 #endif 53 54 #ifdef __cplusplus 55 extern "C" { 56 #endif 57 58 // vp9 uses 10,000,000 ticks/second as time stamp 59 #define TICKS_PER_SEC 10000000 60 61 typedef struct { 62 int nmvjointcost[MV_JOINTS]; 63 int nmvcosts[2][MV_VALS]; 64 int nmvcosts_hp[2][MV_VALS]; 65 66 vpx_prob segment_pred_probs[PREDICTION_PROBS]; 67 68 unsigned char *last_frame_seg_map_copy; 69 70 // 0 = Intra, Last, GF, ARF 71 signed char last_ref_lf_deltas[MAX_REF_LF_DELTAS]; 72 // 0 = ZERO_MV, MV 73 signed char last_mode_lf_deltas[MAX_MODE_LF_DELTAS]; 74 75 FRAME_CONTEXT fc; 76 } CODING_CONTEXT; 77 78 typedef enum { 79 // encode_breakout is disabled. 80 ENCODE_BREAKOUT_DISABLED = 0, 81 // encode_breakout is enabled. 82 ENCODE_BREAKOUT_ENABLED = 1, 83 // encode_breakout is enabled with small max_thresh limit. 84 ENCODE_BREAKOUT_LIMITED = 2 85 } ENCODE_BREAKOUT_TYPE; 86 87 typedef enum { 88 NORMAL = 0, 89 FOURFIVE = 1, 90 THREEFIVE = 2, 91 ONETWO = 3 92 } VPX_SCALING; 93 94 typedef enum { 95 // Good Quality Fast Encoding. The encoder balances quality with the amount of 96 // time it takes to encode the output. Speed setting controls how fast. 97 GOOD, 98 99 // The encoder places priority on the quality of the output over encoding 100 // speed. The output is compressed at the highest possible quality. This 101 // option takes the longest amount of time to encode. Speed setting ignored. 102 BEST, 103 104 // Realtime/Live Encoding. This mode is optimized for realtime encoding (for 105 // example, capturing a television signal or feed from a live camera). Speed 106 // setting controls how fast. 107 REALTIME 108 } MODE; 109 110 typedef enum { 111 FRAMEFLAGS_KEY = 1 << 0, 112 FRAMEFLAGS_GOLDEN = 1 << 1, 113 FRAMEFLAGS_ALTREF = 1 << 2, 114 } FRAMETYPE_FLAGS; 115 116 typedef enum { 117 NO_AQ = 0, 118 VARIANCE_AQ = 1, 119 COMPLEXITY_AQ = 2, 120 CYCLIC_REFRESH_AQ = 3, 121 EQUATOR360_AQ = 4, 122 // AQ based on lookahead temporal 123 // variance (only valid for altref frames) 124 LOOKAHEAD_AQ = 5, 125 AQ_MODE_COUNT // This should always be the last member of the enum 126 } AQ_MODE; 127 128 typedef enum { 129 RESIZE_NONE = 0, // No frame resizing allowed (except for SVC). 130 RESIZE_FIXED = 1, // All frames are coded at the specified dimension. 131 RESIZE_DYNAMIC = 2 // Coded size of each frame is determined by the codec. 132 } RESIZE_TYPE; 133 134 typedef enum { 135 kInvalid = 0, 136 kLowSadLowSumdiff = 1, 137 kLowSadHighSumdiff = 2, 138 kHighSadLowSumdiff = 3, 139 kHighSadHighSumdiff = 4, 140 kLowVarHighSumdiff = 5, 141 } CONTENT_STATE_SB; 142 143 typedef struct VP9EncoderConfig { 144 BITSTREAM_PROFILE profile; 145 vpx_bit_depth_t bit_depth; // Codec bit-depth. 146 int width; // width of data passed to the compressor 147 int height; // height of data passed to the compressor 148 unsigned int input_bit_depth; // Input bit depth. 149 double init_framerate; // set to passed in framerate 150 int64_t target_bandwidth; // bandwidth to be used in bits per second 151 152 int noise_sensitivity; // pre processing blur: recommendation 0 153 int sharpness; // sharpening output: recommendation 0: 154 int speed; 155 // maximum allowed bitrate for any intra frame in % of bitrate target. 156 unsigned int rc_max_intra_bitrate_pct; 157 // maximum allowed bitrate for any inter frame in % of bitrate target. 158 unsigned int rc_max_inter_bitrate_pct; 159 // percent of rate boost for golden frame in CBR mode. 160 unsigned int gf_cbr_boost_pct; 161 162 MODE mode; 163 int pass; 164 165 // Key Framing Operations 166 int auto_key; // autodetect cut scenes and set the keyframes 167 int key_freq; // maximum distance to key frame. 168 169 int lag_in_frames; // how many frames lag before we start encoding 170 171 // ---------------------------------------------------------------- 172 // DATARATE CONTROL OPTIONS 173 174 // vbr, cbr, constrained quality or constant quality 175 enum vpx_rc_mode rc_mode; 176 177 // buffer targeting aggressiveness 178 int under_shoot_pct; 179 int over_shoot_pct; 180 181 // buffering parameters 182 int64_t starting_buffer_level_ms; 183 int64_t optimal_buffer_level_ms; 184 int64_t maximum_buffer_size_ms; 185 186 // Frame drop threshold. 187 int drop_frames_water_mark; 188 189 // controlling quality 190 int fixed_q; 191 int worst_allowed_q; 192 int best_allowed_q; 193 int cq_level; 194 AQ_MODE aq_mode; // Adaptive Quantization mode 195 196 // Special handling of Adaptive Quantization for AltRef frames 197 int alt_ref_aq; 198 199 // Internal frame size scaling. 200 RESIZE_TYPE resize_mode; 201 int scaled_frame_width; 202 int scaled_frame_height; 203 204 // Enable feature to reduce the frame quantization every x frames. 205 int frame_periodic_boost; 206 207 // two pass datarate control 208 int two_pass_vbrbias; // two pass datarate control tweaks 209 int two_pass_vbrmin_section; 210 int two_pass_vbrmax_section; 211 // END DATARATE CONTROL OPTIONS 212 // ---------------------------------------------------------------- 213 214 // Spatial and temporal scalability. 215 int ss_number_layers; // Number of spatial layers. 216 int ts_number_layers; // Number of temporal layers. 217 // Bitrate allocation for spatial layers. 218 int layer_target_bitrate[VPX_MAX_LAYERS]; 219 int ss_target_bitrate[VPX_SS_MAX_LAYERS]; 220 int ss_enable_auto_arf[VPX_SS_MAX_LAYERS]; 221 // Bitrate allocation (CBR mode) and framerate factor, for temporal layers. 222 int ts_rate_decimator[VPX_TS_MAX_LAYERS]; 223 224 int enable_auto_arf; 225 226 int encode_breakout; // early breakout : for video conf recommend 800 227 228 /* Bitfield defining the error resiliency features to enable. 229 * Can provide decodable frames after losses in previous 230 * frames and decodable partitions after losses in the same frame. 231 */ 232 unsigned int error_resilient_mode; 233 234 /* Bitfield defining the parallel decoding mode where the 235 * decoding in successive frames may be conducted in parallel 236 * just by decoding the frame headers. 237 */ 238 unsigned int frame_parallel_decoding_mode; 239 240 int arnr_max_frames; 241 int arnr_strength; 242 243 int min_gf_interval; 244 int max_gf_interval; 245 246 int tile_columns; 247 int tile_rows; 248 249 int max_threads; 250 251 unsigned int target_level; 252 253 vpx_fixed_buf_t two_pass_stats_in; 254 struct vpx_codec_pkt_list *output_pkt_list; 255 256 #if CONFIG_FP_MB_STATS 257 vpx_fixed_buf_t firstpass_mb_stats_in; 258 #endif 259 260 vp8e_tuning tuning; 261 vp9e_tune_content content; 262 #if CONFIG_VP9_HIGHBITDEPTH 263 int use_highbitdepth; 264 #endif 265 vpx_color_space_t color_space; 266 vpx_color_range_t color_range; 267 int render_width; 268 int render_height; 269 VP9E_TEMPORAL_LAYERING_MODE temporal_layering_mode; 270 271 int row_mt; 272 unsigned int motion_vector_unit_test; 273 } VP9EncoderConfig; 274 275 static INLINE int is_lossless_requested(const VP9EncoderConfig *cfg) { 276 return cfg->best_allowed_q == 0 && cfg->worst_allowed_q == 0; 277 } 278 279 // TODO(jingning) All spatially adaptive variables should go to TileDataEnc. 280 typedef struct TileDataEnc { 281 TileInfo tile_info; 282 int thresh_freq_fact[BLOCK_SIZES][MAX_MODES]; 283 int mode_map[BLOCK_SIZES][MAX_MODES]; 284 FIRSTPASS_DATA fp_data; 285 VP9RowMTSync row_mt_sync; 286 287 // Used for adaptive_rd_thresh with row multithreading 288 int *row_base_thresh_freq_fact; 289 } TileDataEnc; 290 291 typedef struct RowMTInfo { 292 JobQueueHandle job_queue_hdl; 293 #if CONFIG_MULTITHREAD 294 pthread_mutex_t job_mutex; 295 #endif 296 } RowMTInfo; 297 298 typedef struct { 299 TOKENEXTRA *start; 300 TOKENEXTRA *stop; 301 unsigned int count; 302 } TOKENLIST; 303 304 typedef struct MultiThreadHandle { 305 int allocated_tile_rows; 306 int allocated_tile_cols; 307 int allocated_vert_unit_rows; 308 309 // Frame level params 310 int num_tile_vert_sbs[MAX_NUM_TILE_ROWS]; 311 312 // Job Queue structure and handles 313 JobQueue *job_queue; 314 315 int jobs_per_tile_col; 316 317 RowMTInfo row_mt_info[MAX_NUM_TILE_COLS]; 318 int thread_id_to_tile_id[MAX_NUM_THREADS]; // Mapping of threads to tiles 319 } MultiThreadHandle; 320 321 typedef struct RD_COUNTS { 322 vp9_coeff_count coef_counts[TX_SIZES][PLANE_TYPES]; 323 int64_t comp_pred_diff[REFERENCE_MODES]; 324 int64_t filter_diff[SWITCHABLE_FILTER_CONTEXTS]; 325 } RD_COUNTS; 326 327 typedef struct ThreadData { 328 MACROBLOCK mb; 329 RD_COUNTS rd_counts; 330 FRAME_COUNTS *counts; 331 332 PICK_MODE_CONTEXT *leaf_tree; 333 PC_TREE *pc_tree; 334 PC_TREE *pc_root; 335 } ThreadData; 336 337 struct EncWorkerData; 338 339 typedef struct ActiveMap { 340 int enabled; 341 int update; 342 unsigned char *map; 343 } ActiveMap; 344 345 typedef enum { Y, U, V, ALL } STAT_TYPE; 346 347 typedef struct IMAGE_STAT { 348 double stat[ALL + 1]; 349 double worst; 350 } ImageStat; 351 352 // Kf noise filtering currently disabled by default in build. 353 // #define ENABLE_KF_DENOISE 1 354 355 #define CPB_WINDOW_SIZE 4 356 #define FRAME_WINDOW_SIZE 128 357 #define SAMPLE_RATE_GRACE_P 0.015 358 #define VP9_LEVELS 14 359 360 typedef enum { 361 LEVEL_UNKNOWN = 0, 362 LEVEL_1 = 10, 363 LEVEL_1_1 = 11, 364 LEVEL_2 = 20, 365 LEVEL_2_1 = 21, 366 LEVEL_3 = 30, 367 LEVEL_3_1 = 31, 368 LEVEL_4 = 40, 369 LEVEL_4_1 = 41, 370 LEVEL_5 = 50, 371 LEVEL_5_1 = 51, 372 LEVEL_5_2 = 52, 373 LEVEL_6 = 60, 374 LEVEL_6_1 = 61, 375 LEVEL_6_2 = 62, 376 LEVEL_MAX = 255 377 } VP9_LEVEL; 378 379 typedef struct { 380 VP9_LEVEL level; 381 uint64_t max_luma_sample_rate; 382 uint32_t max_luma_picture_size; 383 double average_bitrate; // in kilobits per second 384 double max_cpb_size; // in kilobits 385 double compression_ratio; 386 uint8_t max_col_tiles; 387 uint32_t min_altref_distance; 388 uint8_t max_ref_frame_buffers; 389 } Vp9LevelSpec; 390 391 extern const Vp9LevelSpec vp9_level_defs[VP9_LEVELS]; 392 393 typedef struct { 394 int64_t ts; // timestamp 395 uint32_t luma_samples; 396 uint32_t size; // in bytes 397 } FrameRecord; 398 399 typedef struct { 400 FrameRecord buf[FRAME_WINDOW_SIZE]; 401 uint8_t start; 402 uint8_t len; 403 } FrameWindowBuffer; 404 405 typedef struct { 406 uint8_t seen_first_altref; 407 uint32_t frames_since_last_altref; 408 uint64_t total_compressed_size; 409 uint64_t total_uncompressed_size; 410 double time_encoded; // in seconds 411 FrameWindowBuffer frame_window_buffer; 412 int ref_refresh_map; 413 } Vp9LevelStats; 414 415 typedef struct { 416 Vp9LevelStats level_stats; 417 Vp9LevelSpec level_spec; 418 } Vp9LevelInfo; 419 420 typedef enum { 421 BITRATE_TOO_LARGE = 0, 422 LUMA_PIC_SIZE_TOO_LARGE = 1, 423 LUMA_SAMPLE_RATE_TOO_LARGE = 2, 424 CPB_TOO_LARGE = 3, 425 COMPRESSION_RATIO_TOO_SMALL = 4, 426 TOO_MANY_COLUMN_TILE = 5, 427 ALTREF_DIST_TOO_SMALL = 6, 428 TOO_MANY_REF_BUFFER = 7, 429 TARGET_LEVEL_FAIL_IDS = 8 430 } TARGET_LEVEL_FAIL_ID; 431 432 typedef struct { 433 int8_t level_index; 434 uint8_t rc_config_updated; 435 uint8_t fail_flag; 436 int max_frame_size; // in bits 437 double max_cpb_size; // in bits 438 } LevelConstraint; 439 440 typedef struct ARNRFilterData { 441 YV12_BUFFER_CONFIG *frames[MAX_LAG_BUFFERS]; 442 int strength; 443 int frame_count; 444 int alt_ref_index; 445 struct scale_factors sf; 446 } ARNRFilterData; 447 448 typedef struct VP9_COMP { 449 QUANTS quants; 450 ThreadData td; 451 MB_MODE_INFO_EXT *mbmi_ext_base; 452 DECLARE_ALIGNED(16, int16_t, y_dequant[QINDEX_RANGE][8]); 453 DECLARE_ALIGNED(16, int16_t, uv_dequant[QINDEX_RANGE][8]); 454 VP9_COMMON common; 455 VP9EncoderConfig oxcf; 456 struct lookahead_ctx *lookahead; 457 struct lookahead_entry *alt_ref_source; 458 459 YV12_BUFFER_CONFIG *Source; 460 YV12_BUFFER_CONFIG *Last_Source; // NULL for first frame and alt_ref frames 461 YV12_BUFFER_CONFIG *un_scaled_source; 462 YV12_BUFFER_CONFIG scaled_source; 463 YV12_BUFFER_CONFIG *unscaled_last_source; 464 YV12_BUFFER_CONFIG scaled_last_source; 465 #ifdef ENABLE_KF_DENOISE 466 YV12_BUFFER_CONFIG raw_unscaled_source; 467 YV12_BUFFER_CONFIG raw_scaled_source; 468 #endif 469 YV12_BUFFER_CONFIG *raw_source_frame; 470 471 TileDataEnc *tile_data; 472 int allocated_tiles; // Keep track of memory allocated for tiles. 473 474 // For a still frame, this flag is set to 1 to skip partition search. 475 int partition_search_skippable_frame; 476 477 int scaled_ref_idx[MAX_REF_FRAMES]; 478 int lst_fb_idx; 479 int gld_fb_idx; 480 int alt_fb_idx; 481 482 int refresh_last_frame; 483 int refresh_golden_frame; 484 int refresh_alt_ref_frame; 485 486 int ext_refresh_frame_flags_pending; 487 int ext_refresh_last_frame; 488 int ext_refresh_golden_frame; 489 int ext_refresh_alt_ref_frame; 490 491 int ext_refresh_frame_context_pending; 492 int ext_refresh_frame_context; 493 494 YV12_BUFFER_CONFIG last_frame_uf; 495 496 TOKENEXTRA *tile_tok[4][1 << 6]; 497 uint32_t tok_count[4][1 << 6]; 498 TOKENLIST *tplist[4][1 << 6]; 499 500 // Ambient reconstruction err target for force key frames 501 int64_t ambient_err; 502 503 RD_OPT rd; 504 505 CODING_CONTEXT coding_context; 506 507 int *nmvcosts[2]; 508 int *nmvcosts_hp[2]; 509 int *nmvsadcosts[2]; 510 int *nmvsadcosts_hp[2]; 511 512 int64_t last_time_stamp_seen; 513 int64_t last_end_time_stamp_seen; 514 int64_t first_time_stamp_ever; 515 516 RATE_CONTROL rc; 517 double framerate; 518 519 int interp_filter_selected[MAX_REF_FRAMES][SWITCHABLE]; 520 521 struct vpx_codec_pkt_list *output_pkt_list; 522 523 MBGRAPH_FRAME_STATS mbgraph_stats[MAX_LAG_BUFFERS]; 524 int mbgraph_n_frames; // number of frames filled in the above 525 int static_mb_pct; // % forced skip mbs by segmentation 526 int ref_frame_flags; 527 528 SPEED_FEATURES sf; 529 530 uint32_t max_mv_magnitude; 531 int mv_step_param; 532 533 int allow_comp_inter_inter; 534 535 // Default value is 1. From first pass stats, encode_breakout may be disabled. 536 ENCODE_BREAKOUT_TYPE allow_encode_breakout; 537 538 // Get threshold from external input. A suggested threshold is 800 for HD 539 // clips, and 300 for < HD clips. 540 int encode_breakout; 541 542 uint8_t *segmentation_map; 543 544 // segment threashold for encode breakout 545 int segment_encode_breakout[MAX_SEGMENTS]; 546 547 CYCLIC_REFRESH *cyclic_refresh; 548 ActiveMap active_map; 549 550 fractional_mv_step_fp *find_fractional_mv_step; 551 vp9_full_search_fn_t full_search_sad; 552 vp9_diamond_search_fn_t diamond_search_sad; 553 vp9_variance_fn_ptr_t fn_ptr[BLOCK_SIZES]; 554 uint64_t time_receive_data; 555 uint64_t time_compress_data; 556 uint64_t time_pick_lpf; 557 uint64_t time_encode_sb_row; 558 559 #if CONFIG_FP_MB_STATS 560 int use_fp_mb_stats; 561 #endif 562 563 TWO_PASS twopass; 564 565 // Force recalculation of segment_ids for each mode info 566 uint8_t force_update_segmentation; 567 568 YV12_BUFFER_CONFIG alt_ref_buffer; 569 570 // class responsible for adaptive 571 // quantization of altref frames 572 struct ALT_REF_AQ *alt_ref_aq; 573 574 #if CONFIG_INTERNAL_STATS 575 unsigned int mode_chosen_counts[MAX_MODES]; 576 577 int count; 578 uint64_t total_sq_error; 579 uint64_t total_samples; 580 ImageStat psnr; 581 582 uint64_t totalp_sq_error; 583 uint64_t totalp_samples; 584 ImageStat psnrp; 585 586 double total_blockiness; 587 double worst_blockiness; 588 589 int bytes; 590 double summed_quality; 591 double summed_weights; 592 double summedp_quality; 593 double summedp_weights; 594 unsigned int tot_recode_hits; 595 double worst_ssim; 596 597 ImageStat ssimg; 598 ImageStat fastssim; 599 ImageStat psnrhvs; 600 601 int b_calculate_ssimg; 602 int b_calculate_blockiness; 603 604 int b_calculate_consistency; 605 606 double total_inconsistency; 607 double worst_consistency; 608 Ssimv *ssim_vars; 609 Metrics metrics; 610 #endif 611 int b_calculate_psnr; 612 613 int droppable; 614 615 int initial_width; 616 int initial_height; 617 int initial_mbs; // Number of MBs in the full-size frame; to be used to 618 // normalize the firstpass stats. This will differ from the 619 // number of MBs in the current frame when the frame is 620 // scaled. 621 622 int use_svc; 623 624 SVC svc; 625 626 // Store frame variance info in SOURCE_VAR_BASED_PARTITION search type. 627 diff *source_diff_var; 628 // The threshold used in SOURCE_VAR_BASED_PARTITION search type. 629 unsigned int source_var_thresh; 630 int frames_till_next_var_check; 631 632 int frame_flags; 633 634 search_site_config ss_cfg; 635 636 int mbmode_cost[INTRA_MODES]; 637 unsigned int inter_mode_cost[INTER_MODE_CONTEXTS][INTER_MODES]; 638 int intra_uv_mode_cost[FRAME_TYPES][INTRA_MODES][INTRA_MODES]; 639 int y_mode_costs[INTRA_MODES][INTRA_MODES][INTRA_MODES]; 640 int switchable_interp_costs[SWITCHABLE_FILTER_CONTEXTS][SWITCHABLE_FILTERS]; 641 int partition_cost[PARTITION_CONTEXTS][PARTITION_TYPES]; 642 643 int multi_arf_allowed; 644 int multi_arf_enabled; 645 int multi_arf_last_grp_enabled; 646 647 #if CONFIG_VP9_TEMPORAL_DENOISING 648 VP9_DENOISER denoiser; 649 #endif 650 651 int resize_pending; 652 RESIZE_STATE resize_state; 653 int external_resize; 654 int resize_scale_num; 655 int resize_scale_den; 656 int resize_avg_qp; 657 int resize_buffer_underflow; 658 int resize_count; 659 660 int use_skin_detection; 661 662 int target_level; 663 664 NOISE_ESTIMATE noise_estimate; 665 666 // Count on how many consecutive times a block uses small/zeromv for encoding. 667 uint8_t *consec_zero_mv; 668 669 // VAR_BASED_PARTITION thresholds 670 // 0 - threshold_64x64; 1 - threshold_32x32; 671 // 2 - threshold_16x16; 3 - vbp_threshold_8x8; 672 int64_t vbp_thresholds[4]; 673 int64_t vbp_threshold_minmax; 674 int64_t vbp_threshold_sad; 675 // Threshold used for partition copy 676 int64_t vbp_threshold_copy; 677 BLOCK_SIZE vbp_bsize_min; 678 679 // Multi-threading 680 int num_workers; 681 VPxWorker *workers; 682 struct EncWorkerData *tile_thr_data; 683 VP9LfSync lf_row_sync; 684 struct VP9BitstreamWorkerData *vp9_bitstream_worker_data; 685 686 int keep_level_stats; 687 Vp9LevelInfo level_info; 688 MultiThreadHandle multi_thread_ctxt; 689 void (*row_mt_sync_read_ptr)(VP9RowMTSync *const, int, int); 690 void (*row_mt_sync_write_ptr)(VP9RowMTSync *const, int, int, const int); 691 ARNRFilterData arnr_filter_data; 692 693 int row_mt; 694 unsigned int row_mt_bit_exact; 695 696 // Previous Partition Info 697 BLOCK_SIZE *prev_partition; 698 int8_t *prev_segment_id; 699 // Used to save the status of whether a block has a low variance in 700 // choose_partitioning. 0 for 64x64, 1~2 for 64x32, 3~4 for 32x64, 5~8 for 701 // 32x32, 9~24 for 16x16. 702 // This is for the last frame and is copied to the current frame 703 // when partition copy happens. 704 uint8_t *prev_variance_low; 705 uint8_t *copied_frame_cnt; 706 uint8_t max_copied_frame; 707 // If the last frame is dropped, we don't copy partition. 708 uint8_t last_frame_dropped; 709 710 // For each superblock: keeps track of the last time (in frame distance) the 711 // the superblock did not have low source sad. 712 uint8_t *content_state_sb_fd; 713 714 int compute_source_sad_onepass; 715 716 LevelConstraint level_constraint; 717 } VP9_COMP; 718 719 void vp9_initialize_enc(void); 720 721 struct VP9_COMP *vp9_create_compressor(VP9EncoderConfig *oxcf, 722 BufferPool *const pool); 723 void vp9_remove_compressor(VP9_COMP *cpi); 724 725 void vp9_change_config(VP9_COMP *cpi, const VP9EncoderConfig *oxcf); 726 727 // receive a frames worth of data. caller can assume that a copy of this 728 // frame is made and not just a copy of the pointer.. 729 int vp9_receive_raw_frame(VP9_COMP *cpi, vpx_enc_frame_flags_t frame_flags, 730 YV12_BUFFER_CONFIG *sd, int64_t time_stamp, 731 int64_t end_time_stamp); 732 733 int vp9_get_compressed_data(VP9_COMP *cpi, unsigned int *frame_flags, 734 size_t *size, uint8_t *dest, int64_t *time_stamp, 735 int64_t *time_end, int flush); 736 737 int vp9_get_preview_raw_frame(VP9_COMP *cpi, YV12_BUFFER_CONFIG *dest, 738 vp9_ppflags_t *flags); 739 740 int vp9_use_as_reference(VP9_COMP *cpi, int ref_frame_flags); 741 742 void vp9_update_reference(VP9_COMP *cpi, int ref_frame_flags); 743 744 int vp9_copy_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag, 745 YV12_BUFFER_CONFIG *sd); 746 747 int vp9_set_reference_enc(VP9_COMP *cpi, VP9_REFFRAME ref_frame_flag, 748 YV12_BUFFER_CONFIG *sd); 749 750 int vp9_update_entropy(VP9_COMP *cpi, int update); 751 752 int vp9_set_active_map(VP9_COMP *cpi, unsigned char *map, int rows, int cols); 753 754 int vp9_get_active_map(VP9_COMP *cpi, unsigned char *map, int rows, int cols); 755 756 int vp9_set_internal_size(VP9_COMP *cpi, VPX_SCALING horiz_mode, 757 VPX_SCALING vert_mode); 758 759 int vp9_set_size_literal(VP9_COMP *cpi, unsigned int width, 760 unsigned int height); 761 762 void vp9_set_svc(VP9_COMP *cpi, int use_svc); 763 764 int vp9_get_quantizer(struct VP9_COMP *cpi); 765 766 static INLINE int frame_is_kf_gf_arf(const VP9_COMP *cpi) { 767 return frame_is_intra_only(&cpi->common) || cpi->refresh_alt_ref_frame || 768 (cpi->refresh_golden_frame && !cpi->rc.is_src_frame_alt_ref); 769 } 770 771 static INLINE int get_ref_frame_map_idx(const VP9_COMP *cpi, 772 MV_REFERENCE_FRAME ref_frame) { 773 if (ref_frame == LAST_FRAME) { 774 return cpi->lst_fb_idx; 775 } else if (ref_frame == GOLDEN_FRAME) { 776 return cpi->gld_fb_idx; 777 } else { 778 return cpi->alt_fb_idx; 779 } 780 } 781 782 static INLINE int get_ref_frame_buf_idx(const VP9_COMP *const cpi, 783 int ref_frame) { 784 const VP9_COMMON *const cm = &cpi->common; 785 const int map_idx = get_ref_frame_map_idx(cpi, ref_frame); 786 return (map_idx != INVALID_IDX) ? cm->ref_frame_map[map_idx] : INVALID_IDX; 787 } 788 789 static INLINE YV12_BUFFER_CONFIG *get_ref_frame_buffer( 790 VP9_COMP *cpi, MV_REFERENCE_FRAME ref_frame) { 791 VP9_COMMON *const cm = &cpi->common; 792 const int buf_idx = get_ref_frame_buf_idx(cpi, ref_frame); 793 return buf_idx != INVALID_IDX ? &cm->buffer_pool->frame_bufs[buf_idx].buf 794 : NULL; 795 } 796 797 static INLINE int get_token_alloc(int mb_rows, int mb_cols) { 798 // TODO(JBB): double check we can't exceed this token count if we have a 799 // 32x32 transform crossing a boundary at a multiple of 16. 800 // mb_rows, cols are in units of 16 pixels. We assume 3 planes all at full 801 // resolution. We assume up to 1 token per pixel, and then allow 802 // a head room of 4. 803 return mb_rows * mb_cols * (16 * 16 * 3 + 4); 804 } 805 806 // Get the allocated token size for a tile. It does the same calculation as in 807 // the frame token allocation. 808 static INLINE int allocated_tokens(TileInfo tile) { 809 int tile_mb_rows = (tile.mi_row_end - tile.mi_row_start + 1) >> 1; 810 int tile_mb_cols = (tile.mi_col_end - tile.mi_col_start + 1) >> 1; 811 812 return get_token_alloc(tile_mb_rows, tile_mb_cols); 813 } 814 815 static INLINE void get_start_tok(VP9_COMP *cpi, int tile_row, int tile_col, 816 int mi_row, TOKENEXTRA **tok) { 817 VP9_COMMON *const cm = &cpi->common; 818 const int tile_cols = 1 << cm->log2_tile_cols; 819 TileDataEnc *this_tile = &cpi->tile_data[tile_row * tile_cols + tile_col]; 820 const TileInfo *const tile_info = &this_tile->tile_info; 821 822 int tile_mb_cols = (tile_info->mi_col_end - tile_info->mi_col_start + 1) >> 1; 823 const int mb_row = (mi_row - tile_info->mi_row_start) >> 1; 824 825 *tok = 826 cpi->tile_tok[tile_row][tile_col] + get_token_alloc(mb_row, tile_mb_cols); 827 } 828 829 int64_t vp9_get_y_sse(const YV12_BUFFER_CONFIG *a, const YV12_BUFFER_CONFIG *b); 830 #if CONFIG_VP9_HIGHBITDEPTH 831 int64_t vp9_highbd_get_y_sse(const YV12_BUFFER_CONFIG *a, 832 const YV12_BUFFER_CONFIG *b); 833 #endif // CONFIG_VP9_HIGHBITDEPTH 834 835 void vp9_scale_references(VP9_COMP *cpi); 836 837 void vp9_update_reference_frames(VP9_COMP *cpi); 838 839 void vp9_set_high_precision_mv(VP9_COMP *cpi, int allow_high_precision_mv); 840 841 YV12_BUFFER_CONFIG *vp9_svc_twostage_scale( 842 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled, 843 YV12_BUFFER_CONFIG *scaled_temp, INTERP_FILTER filter_type, 844 int phase_scaler, INTERP_FILTER filter_type2, int phase_scaler2); 845 846 YV12_BUFFER_CONFIG *vp9_scale_if_required( 847 VP9_COMMON *cm, YV12_BUFFER_CONFIG *unscaled, YV12_BUFFER_CONFIG *scaled, 848 int use_normative_scaler, INTERP_FILTER filter_type, int phase_scaler); 849 850 void vp9_apply_encoding_flags(VP9_COMP *cpi, vpx_enc_frame_flags_t flags); 851 852 static INLINE int is_two_pass_svc(const struct VP9_COMP *const cpi) { 853 return cpi->use_svc && cpi->oxcf.pass != 0; 854 } 855 856 static INLINE int is_one_pass_cbr_svc(const struct VP9_COMP *const cpi) { 857 return (cpi->use_svc && cpi->oxcf.pass == 0); 858 } 859 860 #if CONFIG_VP9_TEMPORAL_DENOISING 861 static INLINE int denoise_svc(const struct VP9_COMP *const cpi) { 862 return (!cpi->use_svc || 863 (cpi->use_svc && 864 cpi->svc.spatial_layer_id == cpi->svc.number_spatial_layers - 1)); 865 } 866 #endif 867 868 static INLINE int is_altref_enabled(const VP9_COMP *const cpi) { 869 return !(cpi->oxcf.mode == REALTIME && cpi->oxcf.rc_mode == VPX_CBR) && 870 cpi->oxcf.lag_in_frames > 0 && 871 (cpi->oxcf.enable_auto_arf && 872 (!is_two_pass_svc(cpi) || 873 cpi->oxcf.ss_enable_auto_arf[cpi->svc.spatial_layer_id])); 874 } 875 876 static INLINE void set_ref_ptrs(VP9_COMMON *cm, MACROBLOCKD *xd, 877 MV_REFERENCE_FRAME ref0, 878 MV_REFERENCE_FRAME ref1) { 879 xd->block_refs[0] = 880 &cm->frame_refs[ref0 >= LAST_FRAME ? ref0 - LAST_FRAME : 0]; 881 xd->block_refs[1] = 882 &cm->frame_refs[ref1 >= LAST_FRAME ? ref1 - LAST_FRAME : 0]; 883 } 884 885 static INLINE int get_chessboard_index(const int frame_index) { 886 return frame_index & 0x1; 887 } 888 889 static INLINE int *cond_cost_list(const struct VP9_COMP *cpi, int *cost_list) { 890 return cpi->sf.mv.subpel_search_method != SUBPEL_TREE ? cost_list : NULL; 891 } 892 893 static INLINE int get_num_vert_units(TileInfo tile, int shift) { 894 int num_vert_units = 895 (tile.mi_row_end - tile.mi_row_start + (1 << shift) - 1) >> shift; 896 return num_vert_units; 897 } 898 899 static INLINE int get_num_cols(TileInfo tile, int shift) { 900 int num_cols = 901 (tile.mi_col_end - tile.mi_col_start + (1 << shift) - 1) >> shift; 902 return num_cols; 903 } 904 905 static INLINE int get_level_index(VP9_LEVEL level) { 906 int i; 907 for (i = 0; i < VP9_LEVELS; ++i) { 908 if (level == vp9_level_defs[i].level) return i; 909 } 910 return -1; 911 } 912 913 VP9_LEVEL vp9_get_level(const Vp9LevelSpec *const level_spec); 914 915 void vp9_new_framerate(VP9_COMP *cpi, double framerate); 916 917 void vp9_set_row_mt(VP9_COMP *cpi); 918 919 #define LAYER_IDS_TO_IDX(sl, tl, num_tl) ((sl) * (num_tl) + (tl)) 920 921 #ifdef __cplusplus 922 } // extern "C" 923 #endif 924 925 #endif // VP9_ENCODER_VP9_ENCODER_H_ 926
