Add mismatch debug tool Now it supports inter blocks only Change-Id: I6307664452588e654853b4ff18b83cce0343268b
diff --git a/aom_util/aom_util.cmake b/aom_util/aom_util.cmake index 144d773..34e2261 100644 --- a/aom_util/aom_util.cmake +++ b/aom_util/aom_util.cmake
@@ -14,14 +14,9 @@ set(AOM_UTIL_SOURCES "${AOM_ROOT}/aom_util/aom_thread.c" "${AOM_ROOT}/aom_util/aom_thread.h" - "${AOM_ROOT}/aom_util/endian_inl.h") - -if (CONFIG_BITSTREAM_DEBUG) - set(AOM_UTIL_SOURCES - ${AOM_UTIL_SOURCES} - "${AOM_ROOT}/aom_util/debug_util.c" - "${AOM_ROOT}/aom_util/debug_util.h") -endif () + "${AOM_ROOT}/aom_util/endian_inl.h" + "${AOM_ROOT}/aom_util/debug_util.c" + "${AOM_ROOT}/aom_util/debug_util.h") # Creates the aom_util build target and makes libaom depend on it. The libaom # target must exist before this function is called.
diff --git a/aom_util/aom_util.mk b/aom_util/aom_util.mk index 14b484a..c9e26a0 100644 --- a/aom_util/aom_util.mk +++ b/aom_util/aom_util.mk
@@ -13,6 +13,6 @@ UTIL_SRCS-yes += aom_util.mk UTIL_SRCS-yes += aom_thread.c UTIL_SRCS-yes += aom_thread.h -UTIL_SRCS-$(CONFIG_BITSTREAM_DEBUG) += debug_util.c -UTIL_SRCS-$(CONFIG_BITSTREAM_DEBUG) += debug_util.h +UTIL_SRCS-yes += debug_util.c +UTIL_SRCS-yes += debug_util.h UTIL_SRCS-yes += endian_inl.h
diff --git a/aom_util/debug_util.c b/aom_util/debug_util.c index ea73df8..4f9bdc1 100644 --- a/aom_util/debug_util.c +++ b/aom_util/debug_util.c
@@ -14,17 +14,6 @@ #include <string.h> #include "aom_util/debug_util.h" -#define QUEUE_MAX_SIZE 2000000 -static int result_queue[QUEUE_MAX_SIZE]; -static int nsymbs_queue[QUEUE_MAX_SIZE]; -static aom_cdf_prob cdf_queue[QUEUE_MAX_SIZE][16]; - -static int queue_r = 0; -static int queue_w = 0; -static int queue_prev_w = -1; -static int skip_r = 0; -static int skip_w = 0; - static int frame_idx_w = 0; static int frame_idx_r = 0; @@ -37,6 +26,18 @@ int bitstream_queue_get_frame_read(void) { return frame_idx_r; } +#if CONFIG_BITSTREAM_DEBUG +#define QUEUE_MAX_SIZE 2000000 +static int result_queue[QUEUE_MAX_SIZE]; +static int nsymbs_queue[QUEUE_MAX_SIZE]; +static aom_cdf_prob cdf_queue[QUEUE_MAX_SIZE][16]; + +static int queue_r = 0; +static int queue_w = 0; +static int queue_prev_w = -1; +static int skip_r = 0; +static int skip_w = 0; + void bitstream_queue_set_skip_write(int skip) { skip_w = skip; } void bitstream_queue_set_skip_read(int skip) { skip_r = skip; } @@ -74,3 +75,178 @@ } } } +#endif // CONFIG_BITSTREAM_DEBUG + +#if CONFIG_MISMATCH_DEBUG +static int frame_buf_idx_r = 0; +static int frame_buf_idx_w = 0; +static int max_frame_buf_num = 5; +#define MAX_FRAME_STRIDE 1280 +#define MAX_FRAME_HEIGHT 720 +static uint8_t + frame_pre[5][3][MAX_FRAME_STRIDE * MAX_FRAME_HEIGHT]; // prediction only +static uint8_t + frame_tx[5][3][MAX_FRAME_STRIDE * MAX_FRAME_HEIGHT]; // prediction + txfm +static int frame_stride = MAX_FRAME_STRIDE; +static int frame_height = MAX_FRAME_HEIGHT; +static int frame_size = MAX_FRAME_STRIDE * MAX_FRAME_HEIGHT; +void mismatch_move_frame_idx_w() { + frame_buf_idx_w = (frame_buf_idx_w + 1) % max_frame_buf_num; + if (frame_buf_idx_w == frame_buf_idx_r) { + printf("frame_buf overflow\n"); + assert(0); + } +} + +void mismatch_reset_frame() { + for (int plane = 0; plane < 3; ++plane) { + memset(frame_pre[frame_buf_idx_w][plane], 0, + sizeof(frame_pre[frame_buf_idx_w][plane][0]) * frame_size); + memset(frame_tx[frame_buf_idx_w][plane], 0, + sizeof(frame_tx[frame_buf_idx_w][plane][0]) * frame_size); + } +} + +void mismatch_move_frame_idx_r() { + if (frame_buf_idx_w == frame_buf_idx_r) { + printf("frame_buf underflow\n"); + assert(0); + } + frame_buf_idx_r = (frame_buf_idx_r + 1) % max_frame_buf_num; +} + +void mismatch_record_block_pre(const uint8_t *src, int src_stride, int plane, + int pixel_c, int pixel_r, int blk_w, int blk_h) { + if (pixel_c + blk_w >= frame_stride || pixel_r + blk_h >= frame_height) { + printf("frame_buf undersized\n"); + assert(0); + } + for (int r = 0; r < blk_h; ++r) { + for (int c = 0; c < blk_w; ++c) { + frame_pre[frame_buf_idx_w][plane][(r + pixel_r) * frame_stride + c + + pixel_c] = src[r * src_stride + c]; + } + } +#if 0 + int ref_frame_idx = 3; + int ref_plane = 1; + int ref_pixel_c = 162; + int ref_pixel_r = 16; + if (frame_idx_w == ref_frame_idx && plane == ref_plane && + ref_pixel_c >= pixel_c && ref_pixel_c < pixel_c + blk_w && + ref_pixel_r >= pixel_r && ref_pixel_r < pixel_r + blk_h) { + printf( + "\nrecord_block_pre frame_idx %d plane %d pixel_c %d pixel_r %d blk_w " + "%d blk_h %d\n", + frame_idx_w, plane, pixel_c, pixel_r, blk_w, blk_h); + } +#endif +} +void mismatch_record_block_tx(const uint8_t *src, int src_stride, int plane, + int pixel_c, int pixel_r, int blk_w, int blk_h) { + if (pixel_c + blk_w >= frame_stride || pixel_r + blk_h >= frame_height) { + printf("frame_buf undersized\n"); + assert(0); + } + for (int r = 0; r < blk_h; ++r) { + for (int c = 0; c < blk_w; ++c) { + frame_tx[frame_buf_idx_w][plane][(r + pixel_r) * frame_stride + c + + pixel_c] = src[r * src_stride + c]; + } + } +#if 0 + int ref_frame_idx = 3; + int ref_plane = 1; + int ref_pixel_c = 162; + int ref_pixel_r = 16; + if (frame_idx_w == ref_frame_idx && plane == ref_plane && + ref_pixel_c >= pixel_c && ref_pixel_c < pixel_c + blk_w && + ref_pixel_r >= pixel_r && ref_pixel_r < pixel_r + blk_h) { + printf( + "\nrecord_block_tx frame_idx %d plane %d pixel_c %d pixel_r %d blk_w " + "%d blk_h %d\n", + frame_idx_w, plane, pixel_c, pixel_r, blk_w, blk_h); + } +#endif +} +void mismatch_check_block_pre(const uint8_t *src, int src_stride, int plane, + int pixel_c, int pixel_r, int blk_w, int blk_h) { + if (pixel_c + blk_w >= frame_stride || pixel_r + blk_h >= frame_height) { + printf("frame_buf undersized\n"); + assert(0); + } + int mismatch = 0; + for (int r = 0; r < blk_h; ++r) { + for (int c = 0; c < blk_w; ++c) { + if (frame_pre[frame_buf_idx_r][plane] + [(r + pixel_r) * frame_stride + c + pixel_c] != + src[r * src_stride + c]) { + mismatch = 1; + } + } + } + if (mismatch) { + printf( + "\ncheck_block_pre failed frame_idx %d plane %d pixel_c %d pixel_r " + "%d blk_w %d blk_h %d\n", + frame_idx_r, plane, pixel_c, pixel_r, blk_w, blk_h); + printf("enc\n"); + for (int rr = 0; rr < blk_h; ++rr) { + for (int cc = 0; cc < blk_w; ++cc) { + printf("%d ", frame_pre[frame_buf_idx_r][plane] + [(rr + pixel_r) * frame_stride + cc + pixel_c]); + } + printf("\n"); + } + + printf("dec\n"); + for (int rr = 0; rr < blk_h; ++rr) { + for (int cc = 0; cc < blk_w; ++cc) { + printf("%d ", src[rr * src_stride + cc]); + } + printf("\n"); + } + assert(0); + } +} +void mismatch_check_block_tx(const uint8_t *src, int src_stride, int plane, + int pixel_c, int pixel_r, int blk_w, int blk_h) { + if (pixel_c + blk_w >= frame_stride || pixel_r + blk_h >= frame_height) { + printf("frame_buf undersized\n"); + assert(0); + } + int mismatch = 0; + for (int r = 0; r < blk_h; ++r) { + for (int c = 0; c < blk_w; ++c) { + if (frame_tx[frame_buf_idx_r][plane] + [(r + pixel_r) * frame_stride + c + pixel_c] != + src[r * src_stride + c]) { + mismatch = 1; + } + } + } + if (mismatch) { + printf( + "\ncheck_block_tx failed frame_idx %d plane %d pixel_c %d pixel_r " + "%d blk_w %d blk_h %d\n", + frame_idx_r, plane, pixel_c, pixel_r, blk_w, blk_h); + printf("enc\n"); + for (int rr = 0; rr < blk_h; ++rr) { + for (int cc = 0; cc < blk_w; ++cc) { + printf("%d ", frame_tx[frame_buf_idx_r][plane] + [(rr + pixel_r) * frame_stride + cc + pixel_c]); + } + printf("\n"); + } + + printf("dec\n"); + for (int rr = 0; rr < blk_h; ++rr) { + for (int cc = 0; cc < blk_w; ++cc) { + printf("%d ", src[rr * src_stride + cc]); + } + printf("\n"); + } + assert(0); + } +} +#endif // CONFIG_MISMATCH_DEBUG
diff --git a/aom_util/debug_util.h b/aom_util/debug_util.h index 3740620..11c1296 100644 --- a/aom_util/debug_util.h +++ b/aom_util/debug_util.h
@@ -19,6 +19,12 @@ extern "C" { #endif +void bitstream_queue_set_frame_write(int frame_idx); +int bitstream_queue_get_frame_write(void); +void bitstream_queue_set_frame_read(int frame_idx); +int bitstream_queue_get_frame_read(void); + +#if CONFIG_BITSTREAM_DEBUG /* This is a debug tool used to detect bitstream error. On encoder side, it * pushes each bit and probability into a queue before the bit is written into * the Arithmetic coder. On decoder side, whenever a bit is read out from the @@ -35,10 +41,21 @@ void bitstream_queue_push(int result, const aom_cdf_prob *cdf, int nsymbs); void bitstream_queue_set_skip_write(int skip); void bitstream_queue_set_skip_read(int skip); -void bitstream_queue_set_frame_write(int frame_idx); -int bitstream_queue_get_frame_write(void); -void bitstream_queue_set_frame_read(int frame_idx); -int bitstream_queue_get_frame_read(void); +#endif // CONFIG_BITSTREAM_DEBUG + +#if CONFIG_MISMATCH_DEBUG +void mismatch_move_frame_idx_w(); +void mismatch_move_frame_idx_r(); +void mismatch_reset_frame(); +void mismatch_record_block_pre(const uint8_t *src, int src_stride, int plane, + int pixel_c, int pixel_r, int blk_w, int blk_h); +void mismatch_record_block_tx(const uint8_t *src, int src_stride, int plane, + int pixel_c, int pixel_r, int blk_w, int blk_h); +void mismatch_check_block_pre(const uint8_t *src, int src_stride, int plane, + int pixel_c, int pixel_r, int blk_w, int blk_h); +void mismatch_check_block_tx(const uint8_t *src, int src_stride, int plane, + int pixel_c, int pixel_r, int blk_w, int blk_h); +#endif // CONFIG_MISMATCH_DEBUG #ifdef __cplusplus } // extern "C"
diff --git a/av1/common/blockd.h b/av1/common/blockd.h index fe9dd7b..1cd667a 100644 --- a/av1/common/blockd.h +++ b/av1/common/blockd.h
@@ -470,6 +470,17 @@ block_size_allowed; } +#if CONFIG_MISMATCH_DEBUG +static INLINE void mi_to_pixel_loc(int *pixel_c, int *pixel_r, int mi_col, + int mi_row, int tx_blk_col, int tx_blk_row, + int subsampling_x, int subsampling_y) { + *pixel_c = ((mi_col >> subsampling_x) << MI_SIZE_LOG2) + + (tx_blk_col << tx_size_wide_log2[0]); + *pixel_r = ((mi_row >> subsampling_y) << MI_SIZE_LOG2) + + (tx_blk_row << tx_size_high_log2[0]); +} +#endif + enum mv_precision { MV_PRECISION_Q3, MV_PRECISION_Q4 }; struct buf_2d {
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c index 22517f4..7200a91 100644 --- a/av1/decoder/decodeframe.c +++ b/av1/decoder/decodeframe.c
@@ -29,9 +29,9 @@ #include "aom_scale/aom_scale.h" #include "aom_util/aom_thread.h" -#if CONFIG_BITSTREAM_DEBUG +#if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG #include "aom_util/debug_util.h" -#endif // CONFIG_BITSTREAM_DEBUG +#endif // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG #include "av1/common/alloccommon.h" #include "av1/common/cdef.h" @@ -229,7 +229,10 @@ aom_reader *r, MB_MODE_INFO *const mbmi, int plane, BLOCK_SIZE plane_bsize, int blk_row, int blk_col, int block, - TX_SIZE tx_size, int *eob_total) { + TX_SIZE tx_size, int *eob_total, int mi_row, + int mi_col) { + (void)mi_row; + (void)mi_col; const struct macroblockd_plane *const pd = &xd->plane[plane]; const BLOCK_SIZE bsize = txsize_to_bsize[tx_size]; const int tx_row = blk_row >> (1 - pd->subsampling_y); @@ -278,11 +281,20 @@ ++cm->txb_count; #endif - inverse_transform_block( - xd, plane, tx_type, tx_size, + uint8_t *dst = &pd->dst - .buf[(blk_row * pd->dst.stride + blk_col) << tx_size_wide_log2[0]], - pd->dst.stride, max_scan_line, eob, cm->reduced_tx_set_used); + .buf[(blk_row * pd->dst.stride + blk_col) << tx_size_wide_log2[0]]; + inverse_transform_block(xd, plane, tx_type, tx_size, dst, pd->dst.stride, + max_scan_line, eob, cm->reduced_tx_set_used); +#if CONFIG_MISMATCH_DEBUG + int pixel_c, pixel_r; + int blk_w = block_size_wide[plane_bsize]; + int blk_h = block_size_high[plane_bsize]; + mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, blk_col, blk_row, + pd->subsampling_x, pd->subsampling_y); + mismatch_check_block_tx(dst, pd->dst.stride, plane, pixel_c, pixel_r, blk_w, + blk_h); +#endif *eob_total += eob; } else { const TX_SIZE sub_txs = sub_tx_size_map[1][tx_size]; @@ -302,7 +314,8 @@ if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize, offsetr, - offsetc, block, sub_txs, eob_total); + offsetc, block, sub_txs, eob_total, mi_row, + mi_col); block += sub_step; } } @@ -496,6 +509,21 @@ if (mbmi->motion_mode == OBMC_CAUSAL) { av1_build_obmc_inter_predictors_sb(cm, xd, mi_row, mi_col); } + +#if CONFIG_MISMATCH_DEBUG + for (int plane = 0; plane < 3; ++plane) { + const struct macroblockd_plane *pd = &xd->plane[plane]; + int pixel_c, pixel_r; + mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0, + pd->subsampling_x, pd->subsampling_y); + if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, + pd->subsampling_y)) + continue; + mismatch_check_block_pre(pd->dst.buf, pd->dst.stride, plane, pixel_c, + pixel_r, pd->width, pd->height); + } +#endif + // Reconstruction if (!mbmi->skip) { int eobtotal = 0; @@ -552,7 +580,7 @@ for (blk_col = col; blk_col < unit_width; blk_col += bw_var_tx) { decode_reconstruct_tx(cm, xd, r, mbmi, plane, plane_bsize, blk_row, blk_col, block, max_tx_size, - &eobtotal); + &eobtotal, mi_row, mi_col); block += step; } } @@ -3315,6 +3343,9 @@ #if CONFIG_BITSTREAM_DEBUG bitstream_queue_set_frame_read(cm->current_video_frame * 2 + cm->show_frame); #endif +#if CONFIG_MISMATCH_DEBUG + mismatch_move_frame_idx_r(); +#endif for (int i = LAST_FRAME; i <= ALTREF_FRAME; ++i) { cm->global_motion[i] = default_warp_params;
diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c index 170d403..7f511bf 100644 --- a/av1/encoder/encodeframe.c +++ b/av1/encoder/encodeframe.c
@@ -23,6 +23,10 @@ #include "aom_ports/aom_timer.h" #include "aom_ports/system_state.h" +#if CONFIG_MISMATCH_DEBUG +#include "aom_util/debug_util.h" +#endif // CONFIG_MISMATCH_DEBUG + #if CONFIG_CFL #include "av1/common/cfl.h" #endif @@ -4150,6 +4154,10 @@ #endif // CONFIG_FRAME_SIGN_BIAS #endif // CONFIG_FRAME_MARKER +#if CONFIG_MISMATCH_DEBUG + mismatch_reset_frame(); +#endif + // In the longer term the encoder should be generalized to match the // decoder such that we allow compound where one of the 3 buffers has a // different sign bias and that buffer is then the fixed ref. However, this @@ -4709,7 +4717,23 @@ av1_build_obmc_inter_predictors_sb(cm, xd, mi_row, mi_col); } - av1_encode_sb((AV1_COMMON *)cm, x, block_size, mi_row, mi_col); +#if CONFIG_MISMATCH_DEBUG + if (dry_run == OUTPUT_ENABLED) { + for (int plane = 0; plane < 3; ++plane) { + const struct macroblockd_plane *pd = &xd->plane[plane]; + int pixel_c, pixel_r; + mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, 0, 0, + pd->subsampling_x, pd->subsampling_y); + if (!is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, + pd->subsampling_y)) + continue; + mismatch_record_block_pre(pd->dst.buf, pd->dst.stride, plane, pixel_c, + pixel_r, pd->width, pd->height); + } + } +#endif + + av1_encode_sb((AV1_COMMON *)cm, x, block_size, mi_row, mi_col, dry_run); if (mbmi->skip) mbmi->min_tx_size = get_min_tx_size(mbmi->tx_size); av1_tokenize_sb_vartx(cpi, td, t, dry_run, mi_row, mi_col, block_size, rate, tile_data->allow_update_cdf);
diff --git a/av1/encoder/encodemb.c b/av1/encoder/encodemb.c index c98bfef..915b388 100644 --- a/av1/encoder/encodemb.c +++ b/av1/encoder/encodemb.c
@@ -18,6 +18,10 @@ #include "aom_mem/aom_mem.h" #include "aom_ports/mem.h" +#if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG +#include "aom_util/debug_util.h" +#endif // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG + #include "av1/common/idct.h" #include "av1/common/reconinter.h" #include "av1/common/reconintra.h" @@ -33,7 +37,6 @@ #include "av1/common/daala_inv_txfm.h" #endif #include "av1/encoder/rd.h" -#include "av1/encoder/tokenize.h" #if CONFIG_CFL #include "av1/common/cfl.h" @@ -610,7 +613,11 @@ } static void encode_block(int plane, int block, int blk_row, int blk_col, - BLOCK_SIZE plane_bsize, TX_SIZE tx_size, void *arg) { + BLOCK_SIZE plane_bsize, TX_SIZE tx_size, void *arg, + int mi_row, int mi_col, RUN_TYPE dry_run) { + (void)mi_row; + (void)mi_col; + (void)dry_run; struct encode_b_args *const args = arg; AV1_COMMON *cm = args->cm; MACROBLOCK *const x = args->x; @@ -654,11 +661,25 @@ pd->dst.stride, p->eobs[block], cm->reduced_tx_set_used); } +#if CONFIG_MISMATCH_DEBUG + if (dry_run == OUTPUT_ENABLED) { + int pixel_c, pixel_r; + int blk_w = block_size_wide[plane_bsize]; + int blk_h = block_size_high[plane_bsize]; + mi_to_pixel_loc(&pixel_c, &pixel_r, mi_col, mi_row, blk_col, blk_row, + pd->subsampling_x, pd->subsampling_y); + mismatch_record_block_tx(dst, pd->dst.stride, plane, pixel_c, pixel_r, + blk_w, blk_h); + } +#endif } static void encode_block_inter(int plane, int block, int blk_row, int blk_col, BLOCK_SIZE plane_bsize, TX_SIZE tx_size, - void *arg) { + void *arg, int mi_row, int mi_col, + RUN_TYPE dry_run) { + (void)mi_row; + (void)mi_col; struct encode_b_args *const args = arg; MACROBLOCK *const x = args->x; MACROBLOCKD *const xd = &x->e_mbd; @@ -682,7 +703,8 @@ || pd->subsampling_x || pd->subsampling_y #endif // DISABLE_VARTX_FOR_CHROMA ) { - encode_block(plane, block, blk_row, blk_col, plane_bsize, tx_size, arg); + encode_block(plane, block, blk_row, blk_col, plane_bsize, tx_size, arg, + mi_row, mi_col, dry_run); } else { assert(tx_size < TX_SIZES_ALL); const TX_SIZE sub_txs = sub_tx_size_map[1][tx_size]; @@ -702,7 +724,7 @@ if (offsetr >= max_blocks_high || offsetc >= max_blocks_wide) continue; encode_block_inter(plane, block, offsetr, offsetc, plane_bsize, sub_txs, - arg); + arg, mi_row, mi_col, dry_run); block += step; } } @@ -768,7 +790,8 @@ } void av1_encode_sb(AV1_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE bsize, int mi_row, - int mi_col) { + int mi_col, RUN_TYPE dry_run) { + (void)dry_run; MACROBLOCKD *const xd = &x->e_mbd; struct optimize_ctx ctx; MB_MODE_INFO *mbmi = &xd->mi[0]->mbmi; @@ -841,7 +864,7 @@ for (blk_row = idy; blk_row < unit_height; blk_row += bh) { for (blk_col = idx; blk_col < unit_width; blk_col += bw) { encode_block_inter(plane, block, blk_row, blk_col, plane_bsize, - max_tx_size, &arg); + max_tx_size, &arg, mi_row, mi_col, dry_run); block += step; } }
diff --git a/av1/encoder/encodemb.h b/av1/encoder/encodemb.h index adea7cd..cf7d3dd 100644 --- a/av1/encoder/encodemb.h +++ b/av1/encoder/encodemb.h
@@ -15,7 +15,7 @@ #include "./aom_config.h" #include "av1/common/onyxc_int.h" #include "av1/encoder/block.h" - +#include "av1/encoder/tokenize.h" #ifdef __cplusplus extern "C" { #endif @@ -44,7 +44,7 @@ } AV1_XFORM_QUANT; void av1_encode_sb(AV1_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE bsize, int mi_row, - int mi_col); + int mi_col, RUN_TYPE dry_run); void av1_encode_sby_pass1(AV1_COMMON *cm, MACROBLOCK *x, BLOCK_SIZE bsize); void av1_xform_quant(const AV1_COMMON *cm, MACROBLOCK *x, int plane, int block, int blk_row, int blk_col, BLOCK_SIZE plane_bsize,
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c index 96a6fd8..0aac2cb 100644 --- a/av1/encoder/encoder.c +++ b/av1/encoder/encoder.c
@@ -68,9 +68,9 @@ #include "aom_ports/mem.h" #include "aom_ports/system_state.h" #include "aom_scale/aom_scale.h" -#if CONFIG_BITSTREAM_DEBUG +#if CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG #include "aom_util/debug_util.h" -#endif // CONFIG_BITSTREAM_DEBUG +#endif // CONFIG_BITSTREAM_DEBUG || CONFIG_MISMATCH_DEBUG #if CONFIG_ENTROPY_STATS FRAME_COUNTS aggregate_fc; @@ -5877,6 +5877,9 @@ #if !CONFIG_XIPHRC static void Pass2Encode(AV1_COMP *cpi, size_t *size, uint8_t *dest, unsigned int *frame_flags) { +#if CONFIG_MISMATCH_DEBUG + mismatch_move_frame_idx_w(); +#endif encode_frame_to_data_rate(cpi, size, dest, 0, frame_flags); // Do not do post-encoding update for those frames that do not have a spot in
diff --git a/build/cmake/aom_config_defaults.cmake b/build/cmake/aom_config_defaults.cmake index 62db8dd..64ec98b 100644 --- a/build/cmake/aom_config_defaults.cmake +++ b/build/cmake/aom_config_defaults.cmake
@@ -85,6 +85,7 @@ # Debugging flags. set(CONFIG_BITSTREAM_DEBUG 0 CACHE NUMBER "Bitstream debugging flag.") set(CONFIG_DEBUG 0 CACHE NUMBER "Debug build flag.") +set(CONFIG_MISMATCH_DEBUG 0 CACHE NUMBER "Mismatch debugging flag.") # Testing flags. set(CONFIG_DECODE_PERF_TESTS 0 CACHE NUMBER "Enables decoder performance test.")
diff --git a/configure b/configure index d82d5e4..6cbfbed 100755 --- a/configure +++ b/configure
@@ -374,6 +374,7 @@ decode_perf_tests encode_perf_tests bitstream_debug + mismatch_debug symbolrate coefficient_range_checking lowbitdepth @@ -433,6 +434,7 @@ encode_perf_tests coefficient_range_checking bitstream_debug + mismatch_debug symbolrate lowbitdepth highbitdepth