| /* |
| * Copyright (c) 2021, Alliance for Open Media. All rights reserved |
| * |
| * This source code is subject to the terms of the BSD 3-Clause Clear License |
| * and the Alliance for Open Media Patent License 1.0. If the BSD 3-Clause Clear |
| * License was not distributed with this source code in the LICENSE file, you |
| * can obtain it at aomedia.org/license/software-license/bsd-3-c-c/. If the |
| * Alliance for Open Media Patent License 1.0 was not distributed with this |
| * source code in the PATENTS file, you can obtain it at |
| * aomedia.org/license/patent-license/. |
| */ |
| |
| #include <limits.h> |
| #include <math.h> |
| #include <stdio.h> |
| |
| #include "config/aom_dsp_rtcd.h" |
| #include "config/aom_scale_rtcd.h" |
| |
| #include "aom_dsp/aom_dsp_common.h" |
| #include "aom_dsp/variance.h" |
| #include "aom_mem/aom_mem.h" |
| #include "aom_ports/mem.h" |
| #include "aom_ports/system_state.h" |
| #include "aom_scale/aom_scale.h" |
| #include "aom_scale/yv12config.h" |
| |
| #include "av1/common/entropymv.h" |
| #include "av1/common/quant_common.h" |
| #include "av1/common/reconinter.h" // av1_setup_dst_planes() |
| #include "av1/common/txb_common.h" |
| #include "av1/encoder/aq_variance.h" |
| #include "av1/encoder/av1_quantize.h" |
| #include "av1/encoder/block.h" |
| #include "av1/encoder/dwt.h" |
| #include "av1/encoder/encodeframe.h" |
| #include "av1/encoder/encodemb.h" |
| #include "av1/encoder/encodemv.h" |
| #include "av1/encoder/encoder.h" |
| #include "av1/encoder/encode_strategy.h" |
| #include "av1/encoder/ethread.h" |
| #include "av1/encoder/extend.h" |
| #include "av1/encoder/firstpass.h" |
| #include "av1/encoder/mcomp.h" |
| #include "av1/encoder/rd.h" |
| #include "av1/encoder/reconinter_enc.h" |
| |
| #define OUTPUT_FPF 0 |
| |
| #define FIRST_PASS_Q 10.0 |
| #define INTRA_MODE_PENALTY 1024 |
| #define NEW_MV_MODE_PENALTY 32 |
| #define DARK_THRESH 64 |
| |
| #define NCOUNT_INTRA_THRESH 8192 |
| #define NCOUNT_INTRA_FACTOR 3 |
| |
| static AOM_INLINE void output_stats(FIRSTPASS_STATS *stats, |
| struct aom_codec_pkt_list *pktlist) { |
| struct aom_codec_cx_pkt pkt; |
| pkt.kind = AOM_CODEC_STATS_PKT; |
| pkt.data.twopass_stats.buf = stats; |
| pkt.data.twopass_stats.sz = sizeof(FIRSTPASS_STATS); |
| if (pktlist != NULL) aom_codec_pkt_list_add(pktlist, &pkt); |
| |
| // TEMP debug code |
| #if OUTPUT_FPF |
| { |
| FILE *fpfile; |
| fpfile = fopen("firstpass.stt", "a"); |
| |
| fprintf(fpfile, |
| "%12.0lf %12.4lf %12.0lf %12.0lf %12.0lf %12.4lf %12.4lf" |
| "%12.4lf %12.4lf %12.4lf %12.4lf %12.4lf %12.4lf %12.4lf %12.4lf" |
| "%12.4lf %12.4lf %12.0lf %12.0lf %12.0lf %12.4lf %12.4lf\n", |
| stats->frame, stats->weight, stats->intra_error, stats->coded_error, |
| stats->sr_coded_error, stats->pcnt_inter, stats->pcnt_motion, |
| stats->pcnt_second_ref, stats->pcnt_neutral, stats->intra_skip_pct, |
| stats->inactive_zone_rows, stats->inactive_zone_cols, stats->MVr, |
| stats->mvr_abs, stats->MVc, stats->mvc_abs, stats->MVrv, |
| stats->MVcv, stats->mv_in_out_count, stats->new_mv_count, |
| stats->count, stats->duration); |
| fclose(fpfile); |
| } |
| #endif |
| } |
| |
| void av1_twopass_zero_stats(FIRSTPASS_STATS *section) { |
| section->frame = 0.0; |
| section->weight = 0.0; |
| section->intra_error = 0.0; |
| section->frame_avg_wavelet_energy = 0.0; |
| section->coded_error = 0.0; |
| section->sr_coded_error = 0.0; |
| section->pcnt_inter = 0.0; |
| section->pcnt_motion = 0.0; |
| section->pcnt_second_ref = 0.0; |
| section->pcnt_neutral = 0.0; |
| section->intra_skip_pct = 0.0; |
| section->inactive_zone_rows = 0.0; |
| section->inactive_zone_cols = 0.0; |
| section->MVr = 0.0; |
| section->mvr_abs = 0.0; |
| section->MVc = 0.0; |
| section->mvc_abs = 0.0; |
| section->MVrv = 0.0; |
| section->MVcv = 0.0; |
| section->mv_in_out_count = 0.0; |
| section->new_mv_count = 0.0; |
| section->count = 0.0; |
| section->duration = 1.0; |
| } |
| |
| void av1_accumulate_stats(FIRSTPASS_STATS *section, |
| const FIRSTPASS_STATS *frame) { |
| section->frame += frame->frame; |
| section->weight += frame->weight; |
| section->intra_error += frame->intra_error; |
| section->frame_avg_wavelet_energy += frame->frame_avg_wavelet_energy; |
| section->coded_error += frame->coded_error; |
| section->sr_coded_error += frame->sr_coded_error; |
| section->pcnt_inter += frame->pcnt_inter; |
| section->pcnt_motion += frame->pcnt_motion; |
| section->pcnt_second_ref += frame->pcnt_second_ref; |
| section->pcnt_neutral += frame->pcnt_neutral; |
| section->intra_skip_pct += frame->intra_skip_pct; |
| section->inactive_zone_rows += frame->inactive_zone_rows; |
| section->inactive_zone_cols += frame->inactive_zone_cols; |
| section->MVr += frame->MVr; |
| section->mvr_abs += frame->mvr_abs; |
| section->MVc += frame->MVc; |
| section->mvc_abs += frame->mvc_abs; |
| section->MVrv += frame->MVrv; |
| section->MVcv += frame->MVcv; |
| section->mv_in_out_count += frame->mv_in_out_count; |
| section->new_mv_count += frame->new_mv_count; |
| section->count += frame->count; |
| section->duration += frame->duration; |
| } |
| |
| void av1_end_first_pass(AV1_COMP *cpi) { |
| if (cpi->twopass.stats_buf_ctx->total_stats) |
| output_stats(cpi->twopass.stats_buf_ctx->total_stats, cpi->output_pkt_list); |
| } |
| |
| static aom_variance_fn_t highbd_get_block_variance_fn(BLOCK_SIZE bsize, |
| int bd) { |
| switch (bd) { |
| default: |
| switch (bsize) { |
| case BLOCK_8X8: return aom_highbd_8_mse8x8; |
| case BLOCK_16X8: return aom_highbd_8_mse16x8; |
| case BLOCK_8X16: return aom_highbd_8_mse8x16; |
| default: return aom_highbd_8_mse16x16; |
| } |
| break; |
| case 10: |
| switch (bsize) { |
| case BLOCK_8X8: return aom_highbd_10_mse8x8; |
| case BLOCK_16X8: return aom_highbd_10_mse16x8; |
| case BLOCK_8X16: return aom_highbd_10_mse8x16; |
| default: return aom_highbd_10_mse16x16; |
| } |
| break; |
| case 12: |
| switch (bsize) { |
| case BLOCK_8X8: return aom_highbd_12_mse8x8; |
| case BLOCK_16X8: return aom_highbd_12_mse16x8; |
| case BLOCK_8X16: return aom_highbd_12_mse8x16; |
| default: return aom_highbd_12_mse16x16; |
| } |
| break; |
| } |
| } |
| |
| static unsigned int highbd_get_prediction_error(BLOCK_SIZE bsize, |
| const struct buf_2d *src, |
| const struct buf_2d *ref, |
| int bd) { |
| unsigned int sse; |
| const aom_variance_fn_t fn = highbd_get_block_variance_fn(bsize, bd); |
| fn(src->buf, src->stride, ref->buf, ref->stride, &sse); |
| return sse; |
| } |
| |
| // Refine the motion search range according to the frame dimension |
| // for first pass test. |
| static int get_search_range(const InitialDimensions *initial_dimensions) { |
| int sr = 0; |
| const int dim = AOMMIN(initial_dimensions->width, initial_dimensions->height); |
| |
| while ((dim << sr) < MAX_FULL_PEL_VAL) ++sr; |
| return sr; |
| } |
| |
| static AOM_INLINE void first_pass_motion_search(AV1_COMP *cpi, MACROBLOCK *x, |
| const MV *ref_mv, |
| FULLPEL_MV *best_mv, |
| int *best_motion_err) { |
| #if CONFIG_FLEX_MVRES |
| const AV1_COMMON *cm = &cpi->common; |
| #endif |
| MACROBLOCKD *const xd = &x->e_mbd; |
| FULLPEL_MV start_mv = get_fullmv_from_mv(ref_mv); |
| int tmp_err; |
| const BLOCK_SIZE bsize = xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART]; |
| const int new_mv_mode_penalty = NEW_MV_MODE_PENALTY; |
| const int sr = get_search_range(&cpi->initial_dimensions); |
| const int step_param = 3 + sr; |
| |
| const search_site_config *first_pass_search_sites = |
| cpi->mv_search_params.search_site_cfg[SS_CFG_FPF]; |
| const int fine_search_interval = |
| #if CONFIG_FLEX_MVRES |
| cpi->is_screen_content_type && cm->features.allow_intrabc; |
| #else |
| cpi->is_screen_content_type && cpi->common.features.allow_intrabc; |
| #endif |
| if (fine_search_interval) { |
| av1_set_speed_features_framesize_independent(cpi, cpi->oxcf.speed); |
| } |
| #if CONFIG_FLEX_MVRES |
| const MvSubpelPrecision pb_mv_precision = cm->features.fr_mv_precision; |
| #if CONFIG_BVCOST_UPDATE |
| const int is_ibc_cost = 0; |
| #endif |
| #endif |
| |
| FULLPEL_MOTION_SEARCH_PARAMS ms_params; |
| #if CONFIG_FLEX_MVRES |
| av1_make_default_fullpel_ms_params( |
| &ms_params, cpi, x, bsize, ref_mv, pb_mv_precision, |
| #if CONFIG_BVCOST_UPDATE |
| is_ibc_cost, |
| #endif |
| first_pass_search_sites, fine_search_interval); |
| #else |
| av1_make_default_fullpel_ms_params(&ms_params, cpi, x, bsize, ref_mv, |
| first_pass_search_sites, |
| fine_search_interval); |
| #endif |
| av1_set_mv_search_method(&ms_params, first_pass_search_sites, NSTEP); |
| |
| #if CONFIG_FLEX_MVRES |
| full_pel_lower_mv_precision(&start_mv, pb_mv_precision); |
| #endif |
| |
| FULLPEL_MV this_best_mv; |
| tmp_err = av1_full_pixel_search(start_mv, &ms_params, step_param, NULL, |
| &this_best_mv, NULL); |
| |
| #if CONFIG_FLEX_MVRES |
| assert(is_this_mv_precision_compliant(get_mv_from_fullmv(&this_best_mv), |
| pb_mv_precision)); |
| #endif |
| |
| if (tmp_err < INT_MAX) { |
| aom_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[bsize]; |
| const MSBuffers *ms_buffers = &ms_params.ms_buffers; |
| tmp_err = av1_get_mvpred_sse(&ms_params.mv_cost_params, this_best_mv, |
| &v_fn_ptr, ms_buffers->src, ms_buffers->ref) + |
| new_mv_mode_penalty; |
| } |
| |
| if (tmp_err < *best_motion_err) { |
| *best_motion_err = tmp_err; |
| *best_mv = this_best_mv; |
| } |
| } |
| |
| static BLOCK_SIZE get_bsize(const CommonModeInfoParams *const mi_params, |
| int mb_row, int mb_col) { |
| if (mi_size_wide[BLOCK_16X16] * mb_col + mi_size_wide[BLOCK_8X8] < |
| mi_params->mi_cols) { |
| return mi_size_wide[BLOCK_16X16] * mb_row + mi_size_wide[BLOCK_8X8] < |
| mi_params->mi_rows |
| ? BLOCK_16X16 |
| : BLOCK_16X8; |
| } else { |
| return mi_size_wide[BLOCK_16X16] * mb_row + mi_size_wide[BLOCK_8X8] < |
| mi_params->mi_rows |
| ? BLOCK_8X16 |
| : BLOCK_8X8; |
| } |
| } |
| |
| static int find_fp_qindex(aom_bit_depth_t bit_depth) { |
| aom_clear_system_state(); |
| return av1_find_qindex(FIRST_PASS_Q, bit_depth, 0, |
| bit_depth == AOM_BITS_8 ? QINDEX_RANGE_8_BITS - 1 |
| : bit_depth == AOM_BITS_10 ? QINDEX_RANGE_10_BITS - 1 |
| : QINDEX_RANGE - 1); |
| } |
| |
| static double raw_motion_error_stdev(int *raw_motion_err_list, |
| int raw_motion_err_counts) { |
| int64_t sum_raw_err = 0; |
| double raw_err_avg = 0; |
| double raw_err_stdev = 0; |
| if (raw_motion_err_counts == 0) return 0; |
| |
| int i; |
| for (i = 0; i < raw_motion_err_counts; i++) { |
| sum_raw_err += raw_motion_err_list[i]; |
| } |
| raw_err_avg = (double)sum_raw_err / raw_motion_err_counts; |
| for (i = 0; i < raw_motion_err_counts; i++) { |
| raw_err_stdev += (raw_motion_err_list[i] - raw_err_avg) * |
| (raw_motion_err_list[i] - raw_err_avg); |
| } |
| // Calculate the standard deviation for the motion error of all the inter |
| // blocks of the 0,0 motion using the last source |
| // frame as the reference. |
| raw_err_stdev = sqrt(raw_err_stdev / raw_motion_err_counts); |
| return raw_err_stdev; |
| } |
| |
| #define UL_INTRA_THRESH 50 |
| #define INVALID_ROW -1 |
| // Computes and returns the intra pred error of a block. |
| // intra pred error: sum of squared error of the intra predicted residual. |
| // Inputs: |
| // cpi: the encoder setting. Only a few params in it will be used. |
| // this_frame: the current frame buffer. |
| // tile: tile information (not used in first pass, already init to zero) |
| // mb_row: row index in the unit of first pass block size. |
| // mb_col: column index in the unit of first pass block size. |
| // y_offset: the offset of y frame buffer, indicating the starting point of |
| // the current block. |
| // uv_offset: the offset of u and v frame buffer, indicating the starting |
| // point of the current block. |
| // fp_block_size: first pass block size. |
| // qindex: quantization step size to encode the frame. |
| // stats: frame encoding stats. |
| // Modifies: |
| // stats->intra_skip_count |
| // stats->image_data_start_row |
| // stats->intra_factor |
| // stats->brightness_factor |
| // stats->intra_error |
| // stats->frame_avg_wavelet_energy |
| // Returns: |
| // this_intra_error. |
| static int firstpass_intra_prediction( |
| AV1_COMP *cpi, ThreadData *td, YV12_BUFFER_CONFIG *const this_frame, |
| const TileInfo *const tile, const int mb_row, const int mb_col, |
| const int y_offset, const int uv_offset, const BLOCK_SIZE fp_block_size, |
| const int qindex, FRAME_STATS *const stats) { |
| const AV1_COMMON *const cm = &cpi->common; |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| const SequenceHeader *const seq_params = &cm->seq_params; |
| MACROBLOCK *const x = &td->mb; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| const int mb_scale = mi_size_wide[fp_block_size]; |
| const int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row); |
| const int num_planes = av1_num_planes(cm); |
| const BLOCK_SIZE bsize = get_bsize(mi_params, mb_row, mb_col); |
| #if CONFIG_C071_SUBBLK_WARPMV |
| const int mi_width = mi_size_wide[bsize]; |
| const int mi_height = mi_size_high[bsize]; |
| const int x_inside_boundary = |
| AOMMIN(mi_width, mi_params->mi_cols - xd->mi_col); |
| const int y_inside_boundary = |
| AOMMIN(mi_height, mi_params->mi_rows - xd->mi_row); |
| #endif // CONFIG_C071_SUBBLK_WARPMV |
| |
| aom_clear_system_state(); |
| set_mi_offsets(mi_params, xd, mb_row * mb_scale, mb_col * mb_scale |
| #if CONFIG_C071_SUBBLK_WARPMV |
| , |
| x_inside_boundary, y_inside_boundary |
| #endif // CONFIG_C071_SUBBLK_WARPMV |
| ); |
| xd->plane[0].dst.buf = this_frame->y_buffer + y_offset; |
| xd->plane[1].dst.buf = this_frame->u_buffer + uv_offset; |
| xd->plane[2].dst.buf = this_frame->v_buffer + uv_offset; |
| xd->left_available = (mb_col != 0); |
| xd->mi[0]->sb_type[xd->tree_type == CHROMA_PART] = bsize; |
| xd->mi[0]->ref_frame[0] = INTRA_FRAME; |
| set_mi_row_col(xd, tile, mb_row * mb_scale, mi_size_high[bsize], |
| mb_col * mb_scale, mi_size_wide[bsize], mi_params->mi_rows, |
| mi_params->mi_cols, NULL); |
| set_plane_n4(xd, mi_size_wide[bsize], mi_size_high[bsize], num_planes, NULL); |
| xd->mi[0]->segment_id = 0; |
| xd->lossless[xd->mi[0]->segment_id] = (qindex == 0); |
| xd->mi[0]->mode = DC_PRED; |
| xd->mi[0]->tx_size = |
| use_dc_pred ? (bsize >= fp_block_size ? TX_16X16 : TX_8X8) : TX_4X4; |
| |
| av1_encode_intra_block_plane(cpi, x, bsize, 0, DRY_RUN_NORMAL, 0); |
| int this_intra_error = aom_get_mb_ss(x->plane[0].src_diff); |
| switch (seq_params->bit_depth) { |
| case AOM_BITS_8: break; |
| case AOM_BITS_10: this_intra_error >>= 4; break; |
| case AOM_BITS_12: this_intra_error >>= 8; break; |
| default: |
| assert(0 && |
| "seq_params->bit_depth should be AOM_BITS_8, " |
| "AOM_BITS_10 or AOM_BITS_12"); |
| return -1; |
| } |
| |
| if (this_intra_error < UL_INTRA_THRESH) { |
| ++stats->intra_skip_count; |
| } else if ((mb_col > 0) && (stats->image_data_start_row == INVALID_ROW)) { |
| stats->image_data_start_row = mb_row; |
| } |
| |
| aom_clear_system_state(); |
| double log_intra = log(this_intra_error + 1.0); |
| if (log_intra < 10.0) { |
| stats->intra_factor += 1.0 + ((10.0 - log_intra) * 0.05); |
| } else { |
| stats->intra_factor += 1.0; |
| } |
| |
| int level_sample; |
| level_sample = x->plane[0].src.buf[0]; |
| |
| switch (seq_params->bit_depth) { |
| case AOM_BITS_8: break; |
| case AOM_BITS_10: level_sample >>= 2; break; |
| case AOM_BITS_12: level_sample >>= 4; break; |
| default: |
| assert(0 && |
| "seq_params->bit_depth should be AOM_BITS_8, " |
| "AOM_BITS_10 or AOM_BITS_12"); |
| return -1; |
| } |
| if ((level_sample < DARK_THRESH) && (log_intra < 9.0)) { |
| stats->brightness_factor += 1.0 + (0.01 * (DARK_THRESH - level_sample)); |
| } else { |
| stats->brightness_factor += 1.0; |
| } |
| |
| // Intrapenalty below deals with situations where the intra and inter |
| // error scores are very low (e.g. a plain black frame). |
| // We do not have special cases in first pass for 0,0 and nearest etc so |
| // all inter modes carry an overhead cost estimate for the mv. |
| // When the error score is very low this causes us to pick all or lots of |
| // INTRA modes and throw lots of key frames. |
| // This penalty adds a cost matching that of a 0,0 mv to the intra case. |
| this_intra_error += INTRA_MODE_PENALTY; |
| |
| // Accumulate the intra error. |
| stats->intra_error += (int64_t)this_intra_error; |
| |
| const int stride = x->plane[0].src.stride; |
| uint16_t *buf = x->plane[0].src.buf; |
| for (int r8 = 0; r8 < 2; ++r8) { |
| for (int c8 = 0; c8 < 2; ++c8) { |
| stats->frame_avg_wavelet_energy += av1_haar_ac_sad_8x8_uint8_input( |
| buf + c8 * 8 + r8 * 8 * stride, stride); |
| } |
| } |
| |
| return this_intra_error; |
| } |
| |
| // Returns the sum of square error between source and reference blocks. |
| static int get_prediction_error_bitdepth(const int bitdepth, |
| const BLOCK_SIZE block_size, |
| const struct buf_2d *src, |
| const struct buf_2d *ref) { |
| return highbd_get_prediction_error(block_size, src, ref, bitdepth); |
| } |
| |
| // Accumulates motion vector stats. |
| // Modifies member variables of "stats". |
| static void accumulate_mv_stats(const MV best_mv, const FULLPEL_MV mv, |
| const int mb_row, const int mb_col, |
| const int mb_rows, const int mb_cols, |
| MV *last_mv, FRAME_STATS *stats) { |
| if (is_zero_mv(&best_mv)) return; |
| |
| ++stats->mv_count; |
| // Non-zero vector, was it different from the last non zero vector? |
| if (!is_equal_mv(&best_mv, last_mv)) ++stats->new_mv_count; |
| *last_mv = best_mv; |
| |
| // Does the row vector point inwards or outwards? |
| if (mb_row < mb_rows / 2) { |
| if (mv.row > 0) { |
| --stats->sum_in_vectors; |
| } else if (mv.row < 0) { |
| ++stats->sum_in_vectors; |
| } |
| } else if (mb_row > mb_rows / 2) { |
| if (mv.row > 0) { |
| ++stats->sum_in_vectors; |
| } else if (mv.row < 0) { |
| --stats->sum_in_vectors; |
| } |
| } |
| |
| // Does the col vector point inwards or outwards? |
| if (mb_col < mb_cols / 2) { |
| if (mv.col > 0) { |
| --stats->sum_in_vectors; |
| } else if (mv.col < 0) { |
| ++stats->sum_in_vectors; |
| } |
| } else if (mb_col > mb_cols / 2) { |
| if (mv.col > 0) { |
| ++stats->sum_in_vectors; |
| } else if (mv.col < 0) { |
| --stats->sum_in_vectors; |
| } |
| } |
| } |
| |
| #define LOW_MOTION_ERROR_THRESH 25 |
| // Computes and returns the inter prediction error from the last frame. |
| // Computes inter prediction errors from the golden and alt ref frams and |
| // Updates stats accordingly. |
| // Inputs: |
| // cpi: the encoder setting. Only a few params in it will be used. |
| // last_frame: the frame buffer of the last frame. |
| // golden_frame: the frame buffer of the golden frame. |
| // alt_ref_frame: the frame buffer of the alt ref frame. |
| // mb_row: row index in the unit of first pass block size. |
| // mb_col: column index in the unit of first pass block size. |
| // recon_yoffset: the y offset of the reconstructed frame buffer, |
| // indicating the starting point of the current block. |
| // recont_uvoffset: the u/v offset of the reconstructed frame buffer, |
| // indicating the starting point of the current block. |
| // src_yoffset: the y offset of the source frame buffer. |
| // alt_ref_frame_offset: the y offset of the alt ref frame buffer. |
| // fp_block_size: first pass block size. |
| // this_intra_error: the intra prediction error of this block. |
| // raw_motion_err_counts: the count of raw motion vectors. |
| // raw_motion_err_list: the array that records the raw motion error. |
| // best_ref_mv: best reference mv found so far. |
| // last_mv: last mv. |
| // stats: frame encoding stats. |
| // Modifies: |
| // raw_motion_err_list |
| // best_ref_mv |
| // last_mv |
| // stats: many member params in it. |
| // Returns: |
| // this_inter_error |
| static int firstpass_inter_prediction( |
| AV1_COMP *cpi, ThreadData *td, const YV12_BUFFER_CONFIG *const last_frame, |
| const YV12_BUFFER_CONFIG *const golden_frame, |
| const YV12_BUFFER_CONFIG *const alt_ref_frame, const int mb_row, |
| const int mb_col, const int recon_yoffset, const int recon_uvoffset, |
| const int src_yoffset, const int alt_ref_frame_yoffset, |
| const BLOCK_SIZE fp_block_size, const int this_intra_error, |
| const int raw_motion_err_counts, int *raw_motion_err_list, MV *best_ref_mv, |
| MV *last_mv, FRAME_STATS *stats) { |
| int this_inter_error = this_intra_error; |
| AV1_COMMON *const cm = &cpi->common; |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| CurrentFrame *const current_frame = &cm->current_frame; |
| MACROBLOCK *const x = &td->mb; |
| MACROBLOCKD *const xd = &x->e_mbd; |
| const int bitdepth = xd->bd; |
| const int mb_scale = mi_size_wide[fp_block_size]; |
| const BLOCK_SIZE bsize = get_bsize(mi_params, mb_row, mb_col); |
| const int fp_block_size_height = block_size_wide[fp_block_size]; |
| // Assume 0,0 motion with no mv overhead. |
| FULLPEL_MV mv = kZeroFullMv; |
| FULLPEL_MV tmp_mv = kZeroFullMv; |
| xd->plane[0].pre[0].buf = last_frame->y_buffer + recon_yoffset; |
| // Set up limit values for motion vectors to prevent them extending |
| // outside the UMV borders. |
| av1_set_mv_col_limits(mi_params, &x->mv_limits, (mb_col << FP_MIB_SIZE_LOG2), |
| (fp_block_size_height >> MI_SIZE_LOG2), |
| cpi->oxcf.border_in_pixels); |
| |
| int motion_error = get_prediction_error_bitdepth( |
| bitdepth, bsize, &x->plane[0].src, &xd->plane[0].pre[0]); |
| |
| // Compute the motion error of the 0,0 motion using the last source |
| // frame as the reference. Skip the further motion search on |
| // reconstructed frame if this error is small. |
| struct buf_2d unscaled_last_source_buf_2d; |
| unscaled_last_source_buf_2d.buf = |
| cpi->unscaled_last_source->y_buffer + src_yoffset; |
| unscaled_last_source_buf_2d.stride = cpi->unscaled_last_source->y_stride; |
| const int raw_motion_error = get_prediction_error_bitdepth( |
| bitdepth, bsize, &x->plane[0].src, &unscaled_last_source_buf_2d); |
| raw_motion_err_list[raw_motion_err_counts] = raw_motion_error; |
| |
| // TODO(pengchong): Replace the hard-coded threshold |
| if (raw_motion_error > LOW_MOTION_ERROR_THRESH) { |
| // Test last reference frame using the previous best mv as the |
| // starting point (best reference) for the search. |
| first_pass_motion_search(cpi, x, best_ref_mv, &mv, &motion_error); |
| |
| // If the current best reference mv is not centered on 0,0 then do a |
| // 0,0 based search as well. |
| if (!is_zero_mv(best_ref_mv)) { |
| int tmp_err = INT_MAX; |
| first_pass_motion_search(cpi, x, &kZeroMv, &tmp_mv, &tmp_err); |
| |
| if (tmp_err < motion_error) { |
| motion_error = tmp_err; |
| mv = tmp_mv; |
| } |
| } |
| |
| // Motion search in 2nd reference frame. |
| int gf_motion_error = motion_error; |
| if ((current_frame->frame_number > 1) && golden_frame != NULL) { |
| // Assume 0,0 motion with no mv overhead. |
| xd->plane[0].pre[0].buf = golden_frame->y_buffer + recon_yoffset; |
| xd->plane[0].pre[0].stride = golden_frame->y_stride; |
| gf_motion_error = get_prediction_error_bitdepth( |
| bitdepth, bsize, &x->plane[0].src, &xd->plane[0].pre[0]); |
| first_pass_motion_search(cpi, x, &kZeroMv, &tmp_mv, &gf_motion_error); |
| } |
| if (gf_motion_error < motion_error && gf_motion_error < this_intra_error) { |
| ++stats->second_ref_count; |
| } |
| // In accumulating a score for the 2nd reference frame take the |
| // best of the motion predicted score and the intra coded error |
| // (just as will be done for) accumulation of "coded_error" for |
| // the last frame. |
| if ((current_frame->frame_number > 1) && golden_frame != NULL) { |
| stats->sr_coded_error += AOMMIN(gf_motion_error, this_intra_error); |
| } else { |
| // TODO(chengchen): I believe logically this should also be changed to |
| // stats->sr_coded_error += AOMMIN(gf_motion_error, this_intra_error). |
| stats->sr_coded_error += motion_error; |
| } |
| |
| // Motion search in 3rd reference frame. |
| int alt_motion_error = motion_error; |
| if (alt_ref_frame != NULL) { |
| xd->plane[0].pre[0].buf = alt_ref_frame->y_buffer + alt_ref_frame_yoffset; |
| xd->plane[0].pre[0].stride = alt_ref_frame->y_stride; |
| alt_motion_error = get_prediction_error_bitdepth( |
| bitdepth, bsize, &x->plane[0].src, &xd->plane[0].pre[0]); |
| first_pass_motion_search(cpi, x, &kZeroMv, &tmp_mv, &alt_motion_error); |
| } |
| if (alt_motion_error < motion_error && alt_motion_error < gf_motion_error && |
| alt_motion_error < this_intra_error) { |
| ++stats->third_ref_count; |
| } |
| // In accumulating a score for the 3rd reference frame take the |
| // best of the motion predicted score and the intra coded error |
| // (just as will be done for) accumulation of "coded_error" for |
| // the last frame. |
| if (alt_ref_frame != NULL) { |
| stats->tr_coded_error += AOMMIN(alt_motion_error, this_intra_error); |
| } else { |
| // TODO(chengchen): I believe logically this should also be changed to |
| // stats->tr_coded_error += AOMMIN(alt_motion_error, this_intra_error). |
| stats->tr_coded_error += motion_error; |
| } |
| |
| // Reset to last frame as reference buffer. |
| xd->plane[0].pre[0].buf = last_frame->y_buffer + recon_yoffset; |
| xd->plane[1].pre[0].buf = last_frame->u_buffer + recon_uvoffset; |
| xd->plane[2].pre[0].buf = last_frame->v_buffer + recon_uvoffset; |
| } else { |
| stats->sr_coded_error += motion_error; |
| stats->tr_coded_error += motion_error; |
| } |
| |
| // Start by assuming that intra mode is best. |
| best_ref_mv->row = 0; |
| best_ref_mv->col = 0; |
| |
| if (motion_error <= this_intra_error) { |
| aom_clear_system_state(); |
| |
| // Keep a count of cases where the inter and intra were very close |
| // and very low. This helps with scene cut detection for example in |
| // cropped clips with black bars at the sides or top and bottom. |
| if (((this_intra_error - INTRA_MODE_PENALTY) * 9 <= motion_error * 10) && |
| (this_intra_error < (2 * INTRA_MODE_PENALTY))) { |
| stats->neutral_count += 1.0; |
| // Also track cases where the intra is not much worse than the inter |
| // and use this in limiting the GF/arf group length. |
| } else if ((this_intra_error > NCOUNT_INTRA_THRESH) && |
| (this_intra_error < (NCOUNT_INTRA_FACTOR * motion_error))) { |
| stats->neutral_count += |
| (double)motion_error / DOUBLE_DIVIDE_CHECK((double)this_intra_error); |
| } |
| |
| const MV best_mv = get_mv_from_fullmv(&mv); |
| this_inter_error = motion_error; |
| xd->mi[0]->mode = NEWMV; |
| xd->mi[0]->mv[0].as_mv = best_mv; |
| xd->mi[0]->tx_size = TX_4X4; |
| xd->mi[0]->ref_frame[0] = get_closest_pastcur_ref_index(cm); |
| xd->mi[0]->ref_frame[1] = NONE_FRAME; |
| av1_enc_build_inter_predictor(cm, xd, mb_row * mb_scale, mb_col * mb_scale, |
| NULL, bsize, AOM_PLANE_Y, AOM_PLANE_Y); |
| av1_encode_sby_pass1(cpi, x, bsize); |
| stats->sum_mvr += best_mv.row; |
| stats->sum_mvr_abs += abs(best_mv.row); |
| stats->sum_mvc += best_mv.col; |
| stats->sum_mvc_abs += abs(best_mv.col); |
| stats->sum_mvrs += best_mv.row * best_mv.row; |
| stats->sum_mvcs += best_mv.col * best_mv.col; |
| ++stats->inter_count; |
| |
| *best_ref_mv = best_mv; |
| accumulate_mv_stats(best_mv, mv, mb_row, mb_col, mi_params->mb_rows, |
| mi_params->mb_cols, last_mv, stats); |
| } |
| |
| return this_inter_error; |
| } |
| |
| // Updates the first pass stats of this frame. |
| // Input: |
| // cpi: the encoder setting. Only a few params in it will be used. |
| // stats: stats accumulated for this frame. |
| // raw_err_stdev: the statndard deviation for the motion error of all the |
| // inter blocks of the (0,0) motion using the last source |
| // frame as the reference. |
| // frame_number: current frame number. |
| // ts_duration: Duration of the frame / collection of frames. |
| // Updates: |
| // twopass->total_stats: the accumulated stats. |
| // twopass->stats_buf_ctx->stats_in_end: the pointer to the current stats, |
| // update its value and its position |
| // in the buffer. |
| static void update_firstpass_stats(AV1_COMP *cpi, |
| const FRAME_STATS *const stats, |
| const double raw_err_stdev, |
| const int frame_number, |
| const int64_t ts_duration) { |
| TWO_PASS *twopass = &cpi->twopass; |
| AV1_COMMON *const cm = &cpi->common; |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| FIRSTPASS_STATS *this_frame_stats = twopass->stats_buf_ctx->stats_in_end; |
| FIRSTPASS_STATS fps; |
| // The minimum error here insures some bit allocation to frames even |
| // in static regions. The allocation per MB declines for larger formats |
| // where the typical "real" energy per MB also falls. |
| // Initial estimate here uses sqrt(mbs) to define the min_err, where the |
| // number of mbs is proportional to the image area. |
| const int num_mbs = (cpi->oxcf.resize_cfg.resize_mode != RESIZE_NONE) |
| ? cpi->initial_mbs |
| : mi_params->MBs; |
| const double min_err = 200 * sqrt(num_mbs); |
| |
| fps.weight = stats->intra_factor * stats->brightness_factor; |
| fps.frame = frame_number; |
| fps.coded_error = (double)(stats->coded_error >> 8) + min_err; |
| fps.sr_coded_error = (double)(stats->sr_coded_error >> 8) + min_err; |
| fps.tr_coded_error = (double)(stats->tr_coded_error >> 8) + min_err; |
| fps.intra_error = (double)(stats->intra_error >> 8) + min_err; |
| fps.frame_avg_wavelet_energy = (double)stats->frame_avg_wavelet_energy; |
| fps.count = 1.0; |
| fps.pcnt_inter = (double)stats->inter_count / num_mbs; |
| fps.pcnt_second_ref = (double)stats->second_ref_count / num_mbs; |
| fps.pcnt_third_ref = (double)stats->third_ref_count / num_mbs; |
| fps.pcnt_neutral = (double)stats->neutral_count / num_mbs; |
| fps.intra_skip_pct = (double)stats->intra_skip_count / num_mbs; |
| fps.inactive_zone_rows = (double)stats->image_data_start_row; |
| fps.inactive_zone_cols = (double)0; // TODO(paulwilkins): fix |
| fps.raw_error_stdev = raw_err_stdev; |
| |
| if (stats->mv_count > 0) { |
| fps.MVr = (double)stats->sum_mvr / stats->mv_count; |
| fps.mvr_abs = (double)stats->sum_mvr_abs / stats->mv_count; |
| fps.MVc = (double)stats->sum_mvc / stats->mv_count; |
| fps.mvc_abs = (double)stats->sum_mvc_abs / stats->mv_count; |
| fps.MVrv = ((double)stats->sum_mvrs - |
| ((double)stats->sum_mvr * stats->sum_mvr / stats->mv_count)) / |
| stats->mv_count; |
| fps.MVcv = ((double)stats->sum_mvcs - |
| ((double)stats->sum_mvc * stats->sum_mvc / stats->mv_count)) / |
| stats->mv_count; |
| fps.mv_in_out_count = (double)stats->sum_in_vectors / (stats->mv_count * 2); |
| fps.new_mv_count = stats->new_mv_count; |
| fps.pcnt_motion = (double)stats->mv_count / num_mbs; |
| } else { |
| fps.MVr = 0.0; |
| fps.mvr_abs = 0.0; |
| fps.MVc = 0.0; |
| fps.mvc_abs = 0.0; |
| fps.MVrv = 0.0; |
| fps.MVcv = 0.0; |
| fps.mv_in_out_count = 0.0; |
| fps.new_mv_count = 0.0; |
| fps.pcnt_motion = 0.0; |
| } |
| |
| // TODO(paulwilkins): Handle the case when duration is set to 0, or |
| // something less than the full time between subsequent values of |
| // cpi->source_time_stamp. |
| fps.duration = (double)ts_duration; |
| |
| // We will store the stats inside the persistent twopass struct (and NOT the |
| // local variable 'fps'), and then cpi->output_pkt_list will point to it. |
| *this_frame_stats = fps; |
| output_stats(this_frame_stats, cpi->output_pkt_list); |
| if (cpi->twopass.stats_buf_ctx->total_stats != NULL) { |
| av1_accumulate_stats(cpi->twopass.stats_buf_ctx->total_stats, &fps); |
| } |
| /*In the case of two pass, first pass uses it as a circular buffer, |
| * when LAP is enabled it is used as a linear buffer*/ |
| twopass->stats_buf_ctx->stats_in_end++; |
| if ((cpi->oxcf.pass == 1) && (twopass->stats_buf_ctx->stats_in_end >= |
| twopass->stats_buf_ctx->stats_in_buf_end)) { |
| twopass->stats_buf_ctx->stats_in_end = |
| twopass->stats_buf_ctx->stats_in_start; |
| } |
| } |
| |
| static void print_reconstruction_frame( |
| const YV12_BUFFER_CONFIG *const last_frame, int frame_number, |
| int do_print) { |
| if (!do_print) return; |
| |
| char filename[512]; |
| FILE *recon_file; |
| snprintf(filename, sizeof(filename), "enc%04d.yuv", frame_number); |
| |
| if (frame_number == 0) { |
| recon_file = fopen(filename, "wb"); |
| } else { |
| recon_file = fopen(filename, "ab"); |
| } |
| |
| fwrite(last_frame->buffer_alloc, last_frame->frame_size, 1, recon_file); |
| fclose(recon_file); |
| } |
| |
| static FRAME_STATS accumulate_frame_stats(FRAME_STATS *mb_stats, int mb_rows, |
| int mb_cols) { |
| FRAME_STATS stats = { 0 }; |
| int i, j; |
| |
| stats.image_data_start_row = INVALID_ROW; |
| for (j = 0; j < mb_rows; j++) { |
| for (i = 0; i < mb_cols; i++) { |
| FRAME_STATS mb_stat = mb_stats[j * mb_cols + i]; |
| stats.brightness_factor += mb_stat.brightness_factor; |
| stats.coded_error += mb_stat.coded_error; |
| stats.frame_avg_wavelet_energy += mb_stat.frame_avg_wavelet_energy; |
| if (stats.image_data_start_row == INVALID_ROW && |
| mb_stat.image_data_start_row != INVALID_ROW) { |
| stats.image_data_start_row = mb_stat.image_data_start_row; |
| } |
| stats.inter_count += mb_stat.inter_count; |
| stats.intra_error += mb_stat.intra_error; |
| stats.intra_factor += mb_stat.intra_factor; |
| stats.intra_skip_count += mb_stat.intra_skip_count; |
| stats.mv_count += mb_stat.mv_count; |
| stats.neutral_count += mb_stat.neutral_count; |
| stats.new_mv_count += mb_stat.new_mv_count; |
| stats.second_ref_count += mb_stat.second_ref_count; |
| stats.sr_coded_error += mb_stat.sr_coded_error; |
| stats.sum_in_vectors += mb_stat.sum_in_vectors; |
| stats.sum_mvc += mb_stat.sum_mvc; |
| stats.sum_mvc_abs += mb_stat.sum_mvc_abs; |
| stats.sum_mvcs += mb_stat.sum_mvcs; |
| stats.sum_mvr += mb_stat.sum_mvr; |
| stats.sum_mvr_abs += mb_stat.sum_mvr_abs; |
| stats.sum_mvrs += mb_stat.sum_mvrs; |
| stats.third_ref_count += mb_stat.third_ref_count; |
| stats.tr_coded_error += mb_stat.tr_coded_error; |
| } |
| } |
| return stats; |
| } |
| |
| static void setup_firstpass_data(AV1_COMMON *const cm, |
| FirstPassData *firstpass_data) { |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| CHECK_MEM_ERROR(cm, firstpass_data->raw_motion_err_list, |
| aom_calloc(mi_params->mb_rows * mi_params->mb_cols, |
| sizeof(*firstpass_data->raw_motion_err_list))); |
| CHECK_MEM_ERROR(cm, firstpass_data->mb_stats, |
| aom_calloc(mi_params->mb_rows * mi_params->mb_cols, |
| sizeof(*firstpass_data->mb_stats))); |
| for (int j = 0; j < mi_params->mb_rows; j++) { |
| for (int i = 0; i < mi_params->mb_cols; i++) { |
| firstpass_data->mb_stats[j * mi_params->mb_cols + i] |
| .image_data_start_row = INVALID_ROW; |
| } |
| } |
| } |
| |
| static void free_firstpass_data(FirstPassData *firstpass_data) { |
| aom_free(firstpass_data->raw_motion_err_list); |
| aom_free(firstpass_data->mb_stats); |
| } |
| |
| int av1_get_mb_rows_in_tile(TileInfo tile) { |
| int mi_rows_aligned_to_mb = |
| ALIGN_POWER_OF_TWO(tile.mi_row_end - tile.mi_row_start, FP_MIB_SIZE_LOG2); |
| int mb_rows = mi_rows_aligned_to_mb >> FP_MIB_SIZE_LOG2; |
| |
| return mb_rows; |
| } |
| |
| int av1_get_mb_cols_in_tile(TileInfo tile) { |
| int mi_cols_aligned_to_mb = |
| ALIGN_POWER_OF_TWO(tile.mi_col_end - tile.mi_col_start, FP_MIB_SIZE_LOG2); |
| int mb_cols = mi_cols_aligned_to_mb >> FP_MIB_SIZE_LOG2; |
| |
| return mb_cols; |
| } |
| |
| #define FIRST_PASS_ALT_REF_DISTANCE 16 |
| static void first_pass_tile(AV1_COMP *cpi, ThreadData *td, |
| TileDataEnc *tile_data) { |
| TileInfo *tile = &tile_data->tile_info; |
| for (int mi_row = tile->mi_row_start; mi_row < tile->mi_row_end; |
| mi_row += FP_MIB_SIZE) { |
| av1_first_pass_row(cpi, td, tile_data, mi_row >> FP_MIB_SIZE_LOG2); |
| } |
| } |
| |
| static void first_pass_tiles(AV1_COMP *cpi) { |
| AV1_COMMON *const cm = &cpi->common; |
| const int tile_cols = cm->tiles.cols; |
| const int tile_rows = cm->tiles.rows; |
| for (int tile_row = 0; tile_row < tile_rows; ++tile_row) { |
| for (int tile_col = 0; tile_col < tile_cols; ++tile_col) { |
| TileDataEnc *const tile_data = |
| &cpi->tile_data[tile_row * tile_cols + tile_col]; |
| first_pass_tile(cpi, &cpi->td, tile_data); |
| } |
| } |
| } |
| |
| // First pass inter prediction relies on last and golden frames as reference |
| // frames. In new reference framework, references with rank 0 and 2 are used |
| // as their proxies. |
| #define LAST_FRAME_PROXY 0 |
| #define GOLDEN_FRAME_PROXY 2 // Any proxy index will do |
| |
| void av1_first_pass_row(AV1_COMP *cpi, ThreadData *td, TileDataEnc *tile_data, |
| int mb_row) { |
| MACROBLOCK *const x = &td->mb; |
| AV1_COMMON *const cm = &cpi->common; |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| CurrentFrame *const current_frame = &cm->current_frame; |
| const SequenceHeader *const seq_params = &cm->seq_params; |
| const int num_planes = av1_num_planes(cm); |
| MACROBLOCKD *const xd = &x->e_mbd; |
| TileInfo *tile = &tile_data->tile_info; |
| const int qindex = find_fp_qindex(seq_params->bit_depth); |
| // First pass coding proceeds in raster scan order with unit size of 16x16. |
| const BLOCK_SIZE fp_block_size = BLOCK_16X16; |
| const int fp_block_size_width = block_size_high[fp_block_size]; |
| const int fp_block_size_height = block_size_wide[fp_block_size]; |
| int raw_motion_err_counts = 0; |
| int mb_row_in_tile = mb_row - (tile->mi_row_start >> FP_MIB_SIZE_LOG2); |
| int mb_col_start = tile->mi_col_start >> FP_MIB_SIZE_LOG2; |
| int mb_cols_in_tile = av1_get_mb_cols_in_tile(*tile); |
| MultiThreadInfo *const mt_info = &cpi->mt_info; |
| AV1EncRowMultiThreadInfo *const enc_row_mt = &mt_info->enc_row_mt; |
| AV1EncRowMultiThreadSync *const row_mt_sync = &tile_data->row_mt_sync; |
| |
| xd->tile = *tile; |
| const YV12_BUFFER_CONFIG *const last_frame = |
| get_ref_frame_yv12_buf(cm, LAST_FRAME_PROXY); |
| const YV12_BUFFER_CONFIG *golden_frame = |
| get_ref_frame_yv12_buf(cm, GOLDEN_FRAME_PROXY); |
| const YV12_BUFFER_CONFIG *alt_ref_frame = NULL; |
| const int alt_ref_offset = |
| FIRST_PASS_ALT_REF_DISTANCE - |
| (current_frame->frame_number % FIRST_PASS_ALT_REF_DISTANCE); |
| if (alt_ref_offset < FIRST_PASS_ALT_REF_DISTANCE) { |
| const struct lookahead_entry *const alt_ref_frame_buffer = |
| av1_lookahead_peek(cpi->lookahead, alt_ref_offset, |
| cpi->compressor_stage); |
| if (alt_ref_frame_buffer != NULL) { |
| alt_ref_frame = &alt_ref_frame_buffer->img; |
| } |
| } |
| YV12_BUFFER_CONFIG *const this_frame = &cm->cur_frame->buf; |
| |
| PICK_MODE_CONTEXT *ctx = td->firstpass_ctx; |
| FRAME_STATS *mb_stats = |
| cpi->firstpass_data.mb_stats + mb_row * mi_params->mb_cols + mb_col_start; |
| int *raw_motion_err_list = cpi->firstpass_data.raw_motion_err_list + |
| mb_row * mi_params->mb_cols + mb_col_start; |
| MV *first_top_mv = &tile_data->firstpass_top_mv; |
| |
| for (int i = 0; i < num_planes; ++i) { |
| x->plane[i].coeff = ctx->coeff[i]; |
| x->plane[i].qcoeff = ctx->qcoeff[i]; |
| x->plane[i].eobs = ctx->eobs[i]; |
| x->plane[i].txb_entropy_ctx = ctx->txb_entropy_ctx[i]; |
| x->plane[i].dqcoeff = ctx->dqcoeff[i]; |
| } |
| |
| const int src_y_stride = cpi->source->y_stride; |
| const int recon_y_stride = this_frame->y_stride; |
| const int recon_uv_stride = this_frame->uv_stride; |
| const int uv_mb_height = |
| fp_block_size_height >> (this_frame->y_height > this_frame->uv_height); |
| |
| MV best_ref_mv = kZeroMv; |
| MV last_mv = { 0, 0 }; |
| |
| // Reset above block coeffs. |
| xd->up_available = (mb_row_in_tile != 0); |
| int recon_yoffset = (mb_row * recon_y_stride * fp_block_size_height) + |
| (mb_col_start * fp_block_size_width); |
| int src_yoffset = (mb_row * src_y_stride * fp_block_size_height) + |
| (mb_col_start * fp_block_size_width); |
| int recon_uvoffset = |
| (mb_row * recon_uv_stride * uv_mb_height) + (mb_col_start * uv_mb_height); |
| int alt_ref_frame_yoffset = |
| (alt_ref_frame != NULL) |
| ? (mb_row * alt_ref_frame->y_stride * fp_block_size_height) + |
| (mb_col_start * fp_block_size_width) |
| : -1; |
| |
| // Set up limit values for motion vectors to prevent them extending |
| // outside the UMV borders. |
| av1_set_mv_row_limits(mi_params, &x->mv_limits, (mb_row << FP_MIB_SIZE_LOG2), |
| (fp_block_size_height >> MI_SIZE_LOG2), |
| cpi->oxcf.border_in_pixels); |
| |
| av1_setup_src_planes(x, cpi->source, mb_row << FP_MIB_SIZE_LOG2, |
| tile->mi_col_start, num_planes, NULL); |
| |
| // Fix - zero the 16x16 block first. This ensures correct this_intra_error for |
| // block sizes smaller than 16x16. |
| av1_zero_array(x->plane[0].src_diff, 256); |
| |
| for (int mi_col = tile->mi_col_start; mi_col < tile->mi_col_end; |
| mi_col += FP_MIB_SIZE) { |
| int mb_col = mi_col >> FP_MIB_SIZE_LOG2; |
| int mb_col_in_tile = mb_col - mb_col_start; |
| |
| (*(enc_row_mt->sync_read_ptr))(row_mt_sync, mb_row_in_tile, mb_col_in_tile); |
| |
| if (mb_col_in_tile == 0) { |
| last_mv = *first_top_mv; |
| } |
| int this_intra_error = firstpass_intra_prediction( |
| cpi, td, this_frame, tile, mb_row, mb_col, recon_yoffset, |
| recon_uvoffset, fp_block_size, qindex, mb_stats); |
| |
| if (!frame_is_intra_only(cm)) { |
| const int this_inter_error = firstpass_inter_prediction( |
| cpi, td, last_frame, golden_frame, alt_ref_frame, mb_row, mb_col, |
| recon_yoffset, recon_uvoffset, src_yoffset, alt_ref_frame_yoffset, |
| fp_block_size, this_intra_error, raw_motion_err_counts, |
| raw_motion_err_list, &best_ref_mv, &last_mv, mb_stats); |
| if (mb_col_in_tile == 0) { |
| *first_top_mv = last_mv; |
| } |
| mb_stats->coded_error += this_inter_error; |
| ++raw_motion_err_counts; |
| } else { |
| mb_stats->sr_coded_error += this_intra_error; |
| mb_stats->tr_coded_error += this_intra_error; |
| mb_stats->coded_error += this_intra_error; |
| } |
| |
| // Adjust to the next column of MBs. |
| x->plane[0].src.buf += fp_block_size_width; |
| x->plane[1].src.buf += uv_mb_height; |
| x->plane[2].src.buf += uv_mb_height; |
| |
| recon_yoffset += fp_block_size_width; |
| src_yoffset += fp_block_size_width; |
| recon_uvoffset += uv_mb_height; |
| alt_ref_frame_yoffset += fp_block_size_width; |
| mb_stats++; |
| |
| (*(enc_row_mt->sync_write_ptr))(row_mt_sync, mb_row_in_tile, mb_col_in_tile, |
| mb_cols_in_tile); |
| } |
| } |
| |
| void av1_first_pass(AV1_COMP *cpi, const int64_t ts_duration) { |
| MACROBLOCK *const x = &cpi->td.mb; |
| AV1_COMMON *const cm = &cpi->common; |
| const CommonModeInfoParams *const mi_params = &cm->mi_params; |
| CurrentFrame *const current_frame = &cm->current_frame; |
| const SequenceHeader *const seq_params = &cm->seq_params; |
| const int num_planes = av1_num_planes(cm); |
| MACROBLOCKD *const xd = &x->e_mbd; |
| const int qindex = find_fp_qindex(seq_params->bit_depth); |
| // Detect if the key frame is screen content type. |
| if (frame_is_intra_only(cm)) { |
| FeatureFlags *const features = &cm->features; |
| av1_set_screen_content_options(cpi, features); |
| cpi->is_screen_content_type = features->allow_screen_content_tools; |
| } |
| #if CONFIG_ADAPTIVE_DS_FILTER |
| #if DS_FRAME_LEVEL |
| if (cm->current_frame.frame_type == KEY_FRAME) { |
| FeatureFlags *const features = &cm->features; |
| av1_set_downsample_filter_options(cpi, features); |
| #else |
| if (cpi->common.current_frame.absolute_poc == 0) { |
| av1_set_downsample_filter_options(cpi); |
| #endif // DS_FRAME_LEVEL |
| } |
| #endif // CONFIG_ADAPTIVE_DS_FILTER |
| // First pass coding proceeds in raster scan order with unit size of 16x16. |
| const BLOCK_SIZE fp_block_size = BLOCK_16X16; |
| |
| setup_firstpass_data(cm, &cpi->firstpass_data); |
| int *raw_motion_err_list = cpi->firstpass_data.raw_motion_err_list; |
| FRAME_STATS *mb_stats = cpi->firstpass_data.mb_stats; |
| |
| // multi threading info |
| MultiThreadInfo *const mt_info = &cpi->mt_info; |
| AV1EncRowMultiThreadInfo *const enc_row_mt = &mt_info->enc_row_mt; |
| |
| const int tile_cols = cm->tiles.cols; |
| const int tile_rows = cm->tiles.rows; |
| if (cpi->allocated_tiles < tile_cols * tile_rows) { |
| av1_row_mt_mem_dealloc(cpi); |
| av1_alloc_tile_data(cpi); |
| } |
| |
| av1_init_tile_data(cpi); |
| |
| const YV12_BUFFER_CONFIG *const last_frame = |
| get_ref_frame_yv12_buf(cm, LAST_FRAME_PROXY); |
| const YV12_BUFFER_CONFIG *golden_frame = |
| get_ref_frame_yv12_buf(cm, GOLDEN_FRAME_PROXY); |
| YV12_BUFFER_CONFIG *const this_frame = &cm->cur_frame->buf; |
| // First pass code requires valid last and new frame buffers. |
| assert(this_frame != NULL); |
| assert(frame_is_intra_only(cm) || (last_frame != NULL)); |
| |
| av1_setup_frame_size(cpi); |
| aom_clear_system_state(); |
| |
| set_mi_offsets(mi_params, xd, 0, 0 |
| #if CONFIG_C071_SUBBLK_WARPMV |
| , |
| 0, 0 |
| #endif // CONFIG_C071_SUBBLK_WARPMV |
| ); |
| xd->mi[0]->sb_type[PLANE_TYPE_Y] = fp_block_size; |
| xd->mi[0]->sb_type[PLANE_TYPE_UV] = fp_block_size; |
| |
| // Do not use periodic key frames. |
| cpi->rc.frames_to_key = INT_MAX; |
| |
| av1_set_quantizer(cm, cpi->oxcf.q_cfg.qm_minlevel, |
| cpi->oxcf.q_cfg.qm_maxlevel, qindex, |
| cpi->oxcf.q_cfg.enable_chroma_deltaq); |
| |
| av1_setup_block_planes(xd, seq_params->subsampling_x, |
| seq_params->subsampling_y, num_planes); |
| |
| av1_setup_src_planes(x, cpi->source, 0, 0, num_planes, NULL); |
| av1_setup_dst_planes(xd->plane, this_frame, 0, 0, 0, num_planes, NULL); |
| |
| if (!frame_is_intra_only(cm)) { |
| av1_setup_pre_planes(xd, 0, last_frame, 0, 0, NULL, num_planes, NULL); |
| } |
| |
| set_mi_offsets(mi_params, xd, 0, 0 |
| #if CONFIG_C071_SUBBLK_WARPMV |
| , |
| 0, 0 |
| #endif // CONFIG_C071_SUBBLK_WARPMV |
| ); |
| |
| // Don't store luma on the fist pass since chroma is not computed |
| xd->cfl.store_y = 0; |
| av1_frame_init_quantizer(cpi); |
| |
| av1_init_mv_probs(cm); |
| av1_initialize_rd_consts(cpi); |
| |
| enc_row_mt->sync_read_ptr = av1_row_mt_sync_read_dummy; |
| enc_row_mt->sync_write_ptr = av1_row_mt_sync_write_dummy; |
| |
| if (mt_info->num_workers > 1) { |
| enc_row_mt->sync_read_ptr = av1_row_mt_sync_read; |
| enc_row_mt->sync_write_ptr = av1_row_mt_sync_write; |
| av1_fp_encode_tiles_row_mt(cpi); |
| } else { |
| first_pass_tiles(cpi); |
| } |
| |
| FRAME_STATS stats = |
| accumulate_frame_stats(mb_stats, mi_params->mb_rows, mi_params->mb_cols); |
| int total_raw_motion_err_count = |
| frame_is_intra_only(cm) ? 0 : mi_params->mb_rows * mi_params->mb_cols; |
| const double raw_err_stdev = |
| raw_motion_error_stdev(raw_motion_err_list, total_raw_motion_err_count); |
| free_firstpass_data(&cpi->firstpass_data); |
| |
| // Clamp the image start to rows/2. This number of rows is discarded top |
| // and bottom as dead data so rows / 2 means the frame is blank. |
| if ((stats.image_data_start_row > mi_params->mb_rows / 2) || |
| (stats.image_data_start_row == INVALID_ROW)) { |
| stats.image_data_start_row = mi_params->mb_rows / 2; |
| } |
| // Exclude any image dead zone |
| if (stats.image_data_start_row > 0) { |
| stats.intra_skip_count = |
| AOMMAX(0, stats.intra_skip_count - |
| (stats.image_data_start_row * mi_params->mb_cols * 2)); |
| } |
| |
| TWO_PASS *twopass = &cpi->twopass; |
| const int num_mbs = (cpi->oxcf.resize_cfg.resize_mode != RESIZE_NONE) |
| ? cpi->initial_mbs |
| : mi_params->MBs; |
| stats.intra_factor = stats.intra_factor / (double)num_mbs; |
| stats.brightness_factor = stats.brightness_factor / (double)num_mbs; |
| FIRSTPASS_STATS *this_frame_stats = twopass->stats_buf_ctx->stats_in_end; |
| update_firstpass_stats(cpi, &stats, raw_err_stdev, |
| current_frame->frame_number, ts_duration); |
| |
| // Copy the previous Last Frame back into gf buffer if the prediction is good |
| // enough... but also don't allow it to lag too far. |
| if ((twopass->sr_update_lag > 3) || |
| ((current_frame->frame_number > 0) && |
| (this_frame_stats->pcnt_inter > 0.20) && |
| ((this_frame_stats->intra_error / |
| DOUBLE_DIVIDE_CHECK(this_frame_stats->coded_error)) > 2.0))) { |
| if (golden_frame != NULL) { |
| assign_frame_buffer_p( |
| &cm->ref_frame_map[get_ref_frame_map_idx(cm, GOLDEN_FRAME_PROXY)], |
| cm->ref_frame_map[get_ref_frame_map_idx(cm, LAST_FRAME_PROXY)]); |
| } |
| twopass->sr_update_lag = 1; |
| } else { |
| ++twopass->sr_update_lag; |
| } |
| |
| aom_extend_frame_borders(this_frame, num_planes); |
| |
| // The frame we just compressed now becomes the last frame. |
| assign_frame_buffer_p( |
| &cm->ref_frame_map[get_ref_frame_map_idx(cm, LAST_FRAME_PROXY)], |
| cm->cur_frame); |
| |
| // Special case for the first frame. Copy into the GF buffer as a second |
| // reference. |
| if (current_frame->frame_number == 0 && |
| get_ref_frame_map_idx(cm, GOLDEN_FRAME_PROXY) != INVALID_IDX) { |
| assign_frame_buffer_p( |
| &cm->ref_frame_map[get_ref_frame_map_idx(cm, GOLDEN_FRAME_PROXY)], |
| cm->ref_frame_map[get_ref_frame_map_idx(cm, LAST_FRAME_PROXY)]); |
| } |
| |
| print_reconstruction_frame(last_frame, current_frame->frame_number, |
| /*do_print=*/0); |
| |
| ++current_frame->frame_number; |
| } |