From: Fritz Koenig Date: Thu, 4 Nov 2010 23:03:36 +0000 (-0700) Subject: postproc : Re-work posproc calling to allow more flags. X-Git-Tag: v0.9.6~184 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=647df00f3058838cb37a1c257ab0d95c185084a9;p=platform%2Fupstream%2Flibvpx.git postproc : Re-work posproc calling to allow more flags. Debugging in postproc needs more flags to allow for specific block types to be turned on or off in the visualizations. Must be enabled with --enable-postproc-visualizer during configuration time. Change-Id: Ia74f357ddc3ad4fb8082afd3a64f62384e4fcb2d --- diff --git a/configure b/configure index 11e086e..60308b0 100755 --- a/configure +++ b/configure @@ -41,6 +41,7 @@ Advanced options: ${toggle_shared} shared library support ${toggle_small} favor smaller size over speed ${toggle_arm_asm_detok} assembly version of the detokenizer (ARM platforms only) + ${toggle_postproc_visualizer} macro block / block level visualizers Codecs: Codecs can be selectively enabled or disabled individually, or by family: @@ -250,6 +251,7 @@ CONFIG_LIST=" shared small arm_asm_detok + postproc_visualizer " CMDLINE_SELECT=" extra_warnings @@ -289,6 +291,7 @@ CMDLINE_SELECT=" shared small arm_asm_detok + postproc_visualizer " process_cmdline() { @@ -325,8 +328,6 @@ post_process_cmdline() { for c in ${CODECS}; do enabled ${c} && enable ${c##*_}s done - - } @@ -536,6 +537,9 @@ process_toolchain() { # Other toolchain specific defaults case $toolchain in x86*|ppc*|universal*) soft_enable postproc;; esac + + enabled postproc_visualizer && {enabled postproc \ + || die "postproc_visualizer requires postproc to be enabled"} } diff --git a/vp8/common/onyx.h b/vp8/common/onyx.h index a006306..3c199d1 100644 --- a/vp8/common/onyx.h +++ b/vp8/common/onyx.h @@ -204,7 +204,7 @@ extern "C" // and not just a copy of the pointer.. int vp8_receive_raw_frame(VP8_PTR comp, unsigned int frame_flags, YV12_BUFFER_CONFIG *sd, INT64 time_stamp, INT64 end_time_stamp); int vp8_get_compressed_data(VP8_PTR comp, unsigned int *frame_flags, unsigned long *size, unsigned char *dest, INT64 *time_stamp, INT64 *time_end, int flush); - int vp8_get_preview_raw_frame(VP8_PTR comp, YV12_BUFFER_CONFIG *dest, int deblock_level, int noise_level, int flags); + int vp8_get_preview_raw_frame(VP8_PTR comp, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *flags); int vp8_use_as_reference(VP8_PTR comp, int ref_frame_flags); int vp8_update_reference(VP8_PTR comp, int ref_frame_flags); diff --git a/vp8/common/onyxd.h b/vp8/common/onyxd.h index 00a97d9..e53bc31 100644 --- a/vp8/common/onyxd.h +++ b/vp8/common/onyxd.h @@ -51,7 +51,7 @@ extern "C" int vp8dx_get_setting(VP8D_PTR comp, VP8D_SETTING oxst); int vp8dx_receive_compressed_data(VP8D_PTR comp, unsigned long size, const unsigned char *dest, INT64 time_stamp); - int vp8dx_get_raw_frame(VP8D_PTR comp, YV12_BUFFER_CONFIG *sd, INT64 *time_stamp, INT64 *time_end_stamp, int deblock_level, int noise_level, int flags); + int vp8dx_get_raw_frame(VP8D_PTR comp, YV12_BUFFER_CONFIG *sd, INT64 *time_stamp, INT64 *time_end_stamp, vp8_ppflags_t *flags); int vp8dx_get_reference(VP8D_PTR comp, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd); int vp8dx_set_reference(VP8D_PTR comp, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd); diff --git a/vp8/common/postproc.c b/vp8/common/postproc.c index e797e10..15b1c2c 100644 --- a/vp8/common/postproc.c +++ b/vp8/common/postproc.c @@ -26,7 +26,7 @@ ( (0.439*(float)(t>>16)) - (0.368*(float)(t>>8&0xff)) - (0.071*(float)(t&0xff)) + 128) /* global constants */ - +#if CONFIG_POSTPROC_VISUALIZER static const unsigned char MB_PREDICTION_MODE_colors[MB_MODE_COUNT][3] = { { RGB_TO_YUV(0x98FB98) }, /* PaleGreen */ @@ -59,13 +59,14 @@ static const unsigned char B_PREDICTION_MODE_colors[B_MODE_COUNT][3] = { RGB_TO_YUV(0xccff33) }, /* Yellow */ }; -static const unsigned char MV_REFERENCE_FRAME_colors[MB_MODE_COUNT][3] = +static const unsigned char MV_REFERENCE_FRAME_colors[MAX_REF_FRAMES][3] = { { RGB_TO_YUV(0x00ff00) }, /* Blue */ { RGB_TO_YUV(0x0000ff) }, /* Green */ { RGB_TO_YUV(0xffff00) }, /* Yellow */ { RGB_TO_YUV(0xff0000) }, /* Red */ }; +#endif static const short kernel5[] = { @@ -677,10 +678,13 @@ static void constrain_line (int x0, int *x1, int y0, int *y1, int width, int hei #define RTCD_VTABLE(oci) NULL #endif -int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_level, int noise_level, int flags) +int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *ppflags) { char message[512]; int q = oci->filter_level * 10 / 6; + int flags = ppflags->post_proc_flag; + int deblock_level = ppflags->deblocking_level; + int noise_level = ppflags->noise_level; if (!oci->frame_to_show) return -1; @@ -737,7 +741,8 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l oci->post_proc_buffer.y_stride); } - if (flags & VP8D_DEBUG_LEVEL1) +#if CONFIG_POSTPROC_VISUALIZER + if (flags & VP8D_DEBUG_TXT_FRAME_INFO) { sprintf(message, "F%1dG%1dQ%3dF%3dP%d_s%dx%d", (oci->frame_type == KEY_FRAME), @@ -749,7 +754,7 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l vp8_blit_text(message, oci->post_proc_buffer.y_buffer, oci->post_proc_buffer.y_stride); } - if (flags & VP8D_DEBUG_LEVEL2) + if (flags & VP8D_DEBUG_TXT_MBLK_MODES) { int i, j; unsigned char *y_ptr; @@ -781,7 +786,7 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l } } - if (flags & VP8D_DEBUG_LEVEL3) + if (flags & VP8D_DEBUG_TXT_DC_DIFF) { int i, j; unsigned char *y_ptr; @@ -816,45 +821,14 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l } } - if (flags & VP8D_DEBUG_LEVEL4) + if (flags & VP8D_DEBUG_TXT_RATE_INFO) { sprintf(message, "Bitrate: %10.2f frame_rate: %10.2f ", oci->bitrate, oci->framerate); vp8_blit_text(message, oci->post_proc_buffer.y_buffer, oci->post_proc_buffer.y_stride); -#if 0 - int i, j; - unsigned char *y_ptr; - YV12_BUFFER_CONFIG *post = &oci->post_proc_buffer; - int mb_rows = post->y_height >> 4; - int mb_cols = post->y_width >> 4; - int mb_index = 0; - MODE_INFO *mi = oci->mi; - - y_ptr = post->y_buffer + 4 * post->y_stride + 4; - - /* vp8_filter each macro block */ - for (i = 0; i < mb_rows; i++) - { - for (j = 0; j < mb_cols; j++) - { - char zz[4]; - - sprintf(zz, "%c", mi[mb_index].mbmi.dc_diff + '0'); - vp8_blit_text(zz, y_ptr, post->y_stride); - mb_index ++; - y_ptr += 16; - } - - mb_index ++; /* border */ - y_ptr += post->y_stride * 16 - post->y_width; - - } - -#endif - } /* Draw motion vectors */ - if (flags & VP8D_DEBUG_DRAW_MV) + if ((flags & VP8D_DEBUG_DRAW_MV) && ppflags->display_mv_flag) { YV12_BUFFER_CONFIG *post = &oci->post_proc_buffer; int width = post->y_width; @@ -871,6 +845,12 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l { int x1, y1; + if (!(ppflags->display_mv_flag & (1<mbmi.mode))) + { + mi++; + continue; + } + if (mi->mbmi.mode == SPLITMV) { switch (mi->mbmi.partitioning) @@ -996,6 +976,7 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l else vp8_blit_line (lx0, x1, ly0, y1, y_buffer, y_stride); } + mi++; } mi++; @@ -1003,7 +984,8 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l } /* Color in block modes */ - if (flags & VP8D_DEBUG_CLR_BLK_MODES) + if ((flags & VP8D_DEBUG_CLR_BLK_MODES) + && (ppflags->display_mb_modes_flag || ppflags->display_b_modes_flag)) { int y, x; YV12_BUFFER_CONFIG *post = &oci->post_proc_buffer; @@ -1021,7 +1003,8 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l { int Y = 0, U = 0, V = 0; - if (mi->mbmi.mode == B_PRED) + if (mi->mbmi.mode == B_PRED && + ((ppflags->display_mb_modes_flag & B_PRED) || ppflags->display_b_modes_flag)) { int by, bx; unsigned char *yl, *ul, *vl; @@ -1035,13 +1018,16 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l { for (bx = 0; bx < 16; bx += 4) { - Y = B_PREDICTION_MODE_colors[bmi->mode][0]; - U = B_PREDICTION_MODE_colors[bmi->mode][1]; - V = B_PREDICTION_MODE_colors[bmi->mode][2]; - - POSTPROC_INVOKE(RTCD_VTABLE(oci), blend_b) - (yl+bx, ul+(bx>>1), vl+(bx>>1), Y, U, V, 0xc000, y_stride); + if ((ppflags->display_b_modes_flag & (1<mbmi.mode)) + || (ppflags->display_mb_modes_flag & B_PRED)) + { + Y = B_PREDICTION_MODE_colors[bmi->mode][0]; + U = B_PREDICTION_MODE_colors[bmi->mode][1]; + V = B_PREDICTION_MODE_colors[bmi->mode][2]; + POSTPROC_INVOKE(RTCD_VTABLE(oci), blend_b) + (yl+bx, ul+(bx>>1), vl+(bx>>1), Y, U, V, 0xc000, y_stride); + } bmi++; } @@ -1050,7 +1036,7 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l vl += y_stride*1; } } - else + else if (ppflags->display_mb_modes_flag & (1<mbmi.mode)) { Y = MB_PREDICTION_MODE_colors[mi->mbmi.mode][0]; U = MB_PREDICTION_MODE_colors[mi->mbmi.mode][1]; @@ -1059,6 +1045,7 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l POSTPROC_INVOKE(RTCD_VTABLE(oci), blend_mb_inner) (y_ptr+x, u_ptr+(x>>1), v_ptr+(x>>1), Y, U, V, 0xc000, y_stride); } + mi++; } y_ptr += y_stride*16; @@ -1070,7 +1057,7 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l } /* Color in frame reference blocks */ - if (flags & VP8D_DEBUG_CLR_FRM_REF_BLKS) + if ((flags & VP8D_DEBUG_CLR_FRM_REF_BLKS) && ppflags->display_ref_frame_flag) { int y, x; YV12_BUFFER_CONFIG *post = &oci->post_proc_buffer; @@ -1088,12 +1075,15 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l { int Y = 0, U = 0, V = 0; - Y = MV_REFERENCE_FRAME_colors[mi->mbmi.ref_frame][0]; - U = MV_REFERENCE_FRAME_colors[mi->mbmi.ref_frame][1]; - V = MV_REFERENCE_FRAME_colors[mi->mbmi.ref_frame][2]; + if (ppflags->display_ref_frame_flag & (1<mbmi.ref_frame)) + { + Y = MV_REFERENCE_FRAME_colors[mi->mbmi.ref_frame][0]; + U = MV_REFERENCE_FRAME_colors[mi->mbmi.ref_frame][1]; + V = MV_REFERENCE_FRAME_colors[mi->mbmi.ref_frame][2]; - POSTPROC_INVOKE(RTCD_VTABLE(oci), blend_mb_outer) - (y_ptr+x, u_ptr+(x>>1), v_ptr+(x>>1), Y, U, V, 0xc000, y_stride); + POSTPROC_INVOKE(RTCD_VTABLE(oci), blend_mb_outer) + (y_ptr+x, u_ptr+(x>>1), v_ptr+(x>>1), Y, U, V, 0xc000, y_stride); + } mi++; } @@ -1104,6 +1094,7 @@ int vp8_post_proc_frame(VP8_COMMON *oci, YV12_BUFFER_CONFIG *dest, int deblock_l mi++; } } +#endif *dest = oci->post_proc_buffer; diff --git a/vp8/common/postproc.h b/vp8/common/postproc.h index 7485135..c641b9c 100644 --- a/vp8/common/postproc.h +++ b/vp8/common/postproc.h @@ -111,7 +111,7 @@ struct postproc_state #include "onyxc_int.h" #include "ppflags.h" int vp8_post_proc_frame(struct VP8Common *oci, YV12_BUFFER_CONFIG *dest, - int deblock_level, int noise_level, int flags); + vp8_ppflags_t *flags); void vp8_de_noise(YV12_BUFFER_CONFIG *source, diff --git a/vp8/common/ppflags.h b/vp8/common/ppflags.h index b8d713c..65b0cab 100644 --- a/vp8/common/ppflags.h +++ b/vp8/common/ppflags.h @@ -17,13 +17,24 @@ enum VP8D_DEBLOCK = 1<<0, VP8D_DEMACROBLOCK = 1<<1, VP8D_ADDNOISE = 1<<2, - VP8D_DEBUG_LEVEL1 = 1<<3, - VP8D_DEBUG_LEVEL2 = 1<<4, - VP8D_DEBUG_LEVEL3 = 1<<5, - VP8D_DEBUG_LEVEL4 = 1<<6, + VP8D_DEBUG_TXT_FRAME_INFO = 1<<3, + VP8D_DEBUG_TXT_MBLK_MODES = 1<<4, + VP8D_DEBUG_TXT_DC_DIFF = 1<<5, + VP8D_DEBUG_TXT_RATE_INFO = 1<<6, VP8D_DEBUG_DRAW_MV = 1<<7, VP8D_DEBUG_CLR_BLK_MODES = 1<<8, VP8D_DEBUG_CLR_FRM_REF_BLKS = 1<<9 }; +typedef struct +{ + int post_proc_flag; + int deblocking_level; + int noise_level; + int display_ref_frame_flag; + int display_mb_modes_flag; + int display_b_modes_flag; + int display_mv_flag; +} vp8_ppflags_t; + #endif diff --git a/vp8/decoder/onyxd_if.c b/vp8/decoder/onyxd_if.c index 6eda45e..aa2709f 100644 --- a/vp8/decoder/onyxd_if.c +++ b/vp8/decoder/onyxd_if.c @@ -506,7 +506,7 @@ int vp8dx_receive_compressed_data(VP8D_PTR ptr, unsigned long size, const unsign pbi->common.error.setjmp = 0; return retcode; } -int vp8dx_get_raw_frame(VP8D_PTR ptr, YV12_BUFFER_CONFIG *sd, INT64 *time_stamp, INT64 *time_end_stamp, int deblock_level, int noise_level, int flags) +int vp8dx_get_raw_frame(VP8D_PTR ptr, YV12_BUFFER_CONFIG *sd, INT64 *time_stamp, INT64 *time_end_stamp, vp8_ppflags_t *flags) { int ret = -1; VP8D_COMP *pbi = (VP8D_COMP *) ptr; @@ -524,7 +524,7 @@ int vp8dx_get_raw_frame(VP8D_PTR ptr, YV12_BUFFER_CONFIG *sd, INT64 *time_stamp, sd->clrtype = pbi->common.clr_type; #if CONFIG_POSTPROC - ret = vp8_post_proc_frame(&pbi->common, sd, deblock_level, noise_level, flags); + ret = vp8_post_proc_frame(&pbi->common, sd, flags); #else if (pbi->common.frame_to_show) diff --git a/vp8/encoder/onyx_if.c b/vp8/encoder/onyx_if.c index 93e13d1..ba7bb10 100644 --- a/vp8/encoder/onyx_if.c +++ b/vp8/encoder/onyx_if.c @@ -5224,7 +5224,7 @@ int vp8_get_compressed_data(VP8_PTR ptr, unsigned int *frame_flags, unsigned lon return 0; } -int vp8_get_preview_raw_frame(VP8_PTR comp, YV12_BUFFER_CONFIG *dest, int deblock_level, int noise_level, int flags) +int vp8_get_preview_raw_frame(VP8_PTR comp, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *flags) { VP8_COMP *cpi = (VP8_COMP *) comp; @@ -5234,7 +5234,7 @@ int vp8_get_preview_raw_frame(VP8_PTR comp, YV12_BUFFER_CONFIG *dest, int debloc { int ret; #if CONFIG_POSTPROC - ret = vp8_post_proc_frame(&cpi->common, dest, deblock_level, noise_level, flags); + ret = vp8_post_proc_frame(&cpi->common, dest, flags); #else if (cpi->common.frame_to_show) diff --git a/vp8/vp8_cx_iface.c b/vp8/vp8_cx_iface.c index 8e50b7f..6a28720 100644 --- a/vp8/vp8_cx_iface.c +++ b/vp8/vp8_cx_iface.c @@ -860,8 +860,16 @@ static vpx_image_t *vp8e_get_preview(vpx_codec_alg_priv_t *ctx) { YV12_BUFFER_CONFIG sd; + vp8_ppflags_t flags = {0}; - if (0 == vp8_get_preview_raw_frame(ctx->cpi, &sd, ctx->preview_ppcfg.deblocking_level, ctx->preview_ppcfg.noise_level, ctx->preview_ppcfg.post_proc_flag)) + if (ctx->preview_ppcfg.post_proc_flag) + { + flags.post_proc_flag = ctx->preview_ppcfg.post_proc_flag; + flags.deblocking_level = ctx->preview_ppcfg.deblocking_level; + flags.noise_level = ctx->preview_ppcfg.noise_level; + } + + if (0 == vp8_get_preview_raw_frame(ctx->cpi, &sd, &flags)) { /* diff --git a/vp8/vp8_dx_iface.c b/vp8/vp8_dx_iface.c index 9964124..9dd4922 100644 --- a/vp8/vp8_dx_iface.c +++ b/vp8/vp8_dx_iface.c @@ -65,12 +65,19 @@ struct vpx_codec_alg_priv vpx_codec_priv_t base; vpx_codec_mmap_t mmaps[NELEMENTS(vp8_mem_req_segs)-1]; vpx_codec_dec_cfg_t cfg; - vp8_stream_info_t si; + vp8_stream_info_t si; int defer_alloc; int decoder_init; VP8D_PTR pbi; int postproc_cfg_set; vp8_postproc_cfg_t postproc_cfg; +#if CONFIG_POSTPROC_VISUALIZER + unsigned int dbg_postproc_flag; + int dbg_color_ref_frame_flag; + int dbg_color_mb_modes_flag; + int dbg_color_b_modes_flag; + int dbg_display_mv_flag; +#endif vpx_image_t img; int img_setup; int img_avail; @@ -416,15 +423,27 @@ static vpx_codec_err_t vp8_decode(vpx_codec_alg_priv_t *ctx, { YV12_BUFFER_CONFIG sd; INT64 time_stamp = 0, time_end_stamp = 0; - int ppflag = 0; - int ppdeblocking = 0; - int ppnoise = 0; + vp8_ppflags_t flags = {0}; if (ctx->base.init_flags & VPX_CODEC_USE_POSTPROC) { - ppflag = ctx->postproc_cfg.post_proc_flag; - ppdeblocking = ctx->postproc_cfg.deblocking_level; - ppnoise = ctx->postproc_cfg.noise_level; + flags.post_proc_flag= ctx->postproc_cfg.post_proc_flag +#if CONFIG_POSTPROC_VISUALIZER + + | ((ctx->dbg_color_ref_frame_flag != 0) ? VP8D_DEBUG_CLR_FRM_REF_BLKS : 0) + | ((ctx->dbg_color_mb_modes_flag != 0) ? VP8D_DEBUG_CLR_BLK_MODES : 0) + | ((ctx->dbg_color_b_modes_flag != 0) ? VP8D_DEBUG_CLR_BLK_MODES : 0) + | ((ctx->dbg_display_mv_flag != 0) ? VP8D_DEBUG_DRAW_MV : 0) +#endif + ; + flags.deblocking_level = ctx->postproc_cfg.deblocking_level; + flags.noise_level = ctx->postproc_cfg.noise_level; +#if CONFIG_POSTPROC_VISUALIZER + flags.display_ref_frame_flag= ctx->dbg_color_ref_frame_flag; + flags.display_mb_modes_flag = ctx->dbg_color_mb_modes_flag; + flags.display_b_modes_flag = ctx->dbg_color_b_modes_flag; + flags.display_mv_flag = ctx->dbg_display_mv_flag; +#endif } if (vp8dx_receive_compressed_data(ctx->pbi, data_sz, data, deadline)) @@ -433,7 +452,7 @@ static vpx_codec_err_t vp8_decode(vpx_codec_alg_priv_t *ctx, res = update_error_state(ctx, &pbi->common.error); } - if (!res && 0 == vp8dx_get_raw_frame(ctx->pbi, &sd, &time_stamp, &time_end_stamp, ppdeblocking, ppnoise, ppflag)) + if (!res && 0 == vp8dx_get_raw_frame(ctx->pbi, &sd, &time_stamp, &time_end_stamp, &flags)) { /* Align width/height */ unsigned int a_w = (sd.y_width + 15) & ~15; @@ -646,12 +665,38 @@ static vpx_codec_err_t vp8_set_postproc(vpx_codec_alg_priv_t *ctx, #endif } +static vpx_codec_err_t vp8_set_dbg_options(vpx_codec_alg_priv_t *ctx, + int ctrl_id, + va_list args) +{ +#if CONFIG_POSTPROC_VISUALIZER && CONFIG_POSTPROC + int data = va_arg(args, int); + +#define MAP(id, var) case id: var = data; break; + + switch (ctrl_id) + { + MAP (VP8_SET_DBG_COLOR_REF_FRAME, ctx->dbg_color_ref_frame_flag); + MAP (VP8_SET_DBG_COLOR_MB_MODES, ctx->dbg_color_mb_modes_flag); + MAP (VP8_SET_DBG_COLOR_B_MODES, ctx->dbg_color_b_modes_flag); + MAP (VP8_SET_DBG_DISPLAY_MV, ctx->dbg_display_mv_flag); + } + + return VPX_CODEC_OK; +#else + return VPX_CODEC_INCAPABLE; +#endif +} vpx_codec_ctrl_fn_map_t vp8_ctf_maps[] = { - {VP8_SET_REFERENCE, vp8_set_reference}, - {VP8_COPY_REFERENCE, vp8_get_reference}, - {VP8_SET_POSTPROC, vp8_set_postproc}, + {VP8_SET_REFERENCE, vp8_set_reference}, + {VP8_COPY_REFERENCE, vp8_get_reference}, + {VP8_SET_POSTPROC, vp8_set_postproc}, + {VP8_SET_DBG_COLOR_REF_FRAME, vp8_set_dbg_options}, + {VP8_SET_DBG_COLOR_MB_MODES, vp8_set_dbg_options}, + {VP8_SET_DBG_COLOR_B_MODES, vp8_set_dbg_options}, + {VP8_SET_DBG_DISPLAY_MV, vp8_set_dbg_options}, { -1, NULL}, }; diff --git a/vpx/vp8.h b/vpx/vp8.h index d7ed8d8..32c0132 100644 --- a/vpx/vp8.h +++ b/vpx/vp8.h @@ -38,9 +38,13 @@ */ enum vp8_dec_control_id { - VP8_SET_REFERENCE = 1, /**< pass in an external frame into decoder to be used as reference frame */ - VP8_COPY_REFERENCE = 2, /**< get a copy of reference frame from the decoder */ - VP8_SET_POSTPROC = 3, /**< set decoder's the post processing settings */ + VP8_SET_REFERENCE = 1, /**< pass in an external frame into decoder to be used as reference frame */ + VP8_COPY_REFERENCE = 2, /**< get a copy of reference frame from the decoder */ + VP8_SET_POSTPROC = 3, /**< set the decoder's post processing settings */ + VP8_SET_DBG_COLOR_REF_FRAME = 4, /**< set the reference frames to color for each macroblock */ + VP8_SET_DBG_COLOR_MB_MODES = 5, /**< set which macro block modes to color */ + VP8_SET_DBG_COLOR_B_MODES = 6, /**< set which blocks modes to color */ + VP8_SET_DBG_DISPLAY_MV = 7, /**< set which motion vector modes to draw */ VP8_COMMON_CTRL_ID_MAX }; @@ -50,10 +54,14 @@ enum vp8_dec_control_id */ enum vp8_postproc_level { - VP8_NOFILTERING = 0, - VP8_DEBLOCK = 1, - VP8_DEMACROBLOCK = 2, - VP8_ADDNOISE = 4 + VP8_NOFILTERING = 0, + VP8_DEBLOCK = 1<<0, + VP8_DEMACROBLOCK = 1<<1, + VP8_ADDNOISE = 1<<2, + VP8_DEBUG_TXT_FRAME_INFO = 1<<3, /**< print frame information */ + VP8_DEBUG_TXT_MBLK_MODES = 1<<4, /**< print macro block modes over each macro block */ + VP8_DEBUG_TXT_DC_DIFF = 1<<5, /**< print dc diff for each macro block */ + VP8_DEBUG_TXT_RATE_INFO = 1<<6, /**< print video rate info (encoder only) */ }; /*!\brief post process flags @@ -65,9 +73,9 @@ enum vp8_postproc_level typedef struct vp8_postproc_cfg { - int post_proc_flag; /**< the types of post processing to be done, should be combination of "vp8_postproc_level" */ - int deblocking_level; /**< the strength of deblocking, valid range [0, 16] */ - int noise_level; /**< the strength of additive noise, valid range [0, 16] */ + int post_proc_flag; /**< the types of post processing to be done, should be combination of "vp8_postproc_level" */ + int deblocking_level; /**< the strength of deblocking, valid range [0, 16] */ + int noise_level; /**< the strength of additive noise, valid range [0, 16] */ } vp8_postproc_cfg_t; /*!\brief reference frame type @@ -95,12 +103,16 @@ typedef struct vpx_ref_frame /*!\brief vp8 decoder control funciton parameter type * - * defines the data type for each of VP8 decoder control funciton requires + * defines the data type for each of VP8 decoder control function requires */ VPX_CTRL_USE_TYPE(VP8_SET_REFERENCE, vpx_ref_frame_t *) VPX_CTRL_USE_TYPE(VP8_COPY_REFERENCE, vpx_ref_frame_t *) VPX_CTRL_USE_TYPE(VP8_SET_POSTPROC, vp8_postproc_cfg_t *) +VPX_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_REF_FRAME, int) +VPX_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_MB_MODES, int) +VPX_CTRL_USE_TYPE(VP8_SET_DBG_COLOR_B_MODES, int) +VPX_CTRL_USE_TYPE(VP8_SET_DBG_DISPLAY_MV, int) /*! @} - end defgroup vp8 */ diff --git a/vpxdec.c b/vpxdec.c index 9b565b0..5eb0beb 100644 --- a/vpxdec.c +++ b/vpxdec.c @@ -108,11 +108,19 @@ static const arg_def_t demacroblock_level = ARG_DEF(NULL, "demacroblock-level", "Enable VP8 demacroblocking, w/ level"); static const arg_def_t pp_debug_info = ARG_DEF(NULL, "pp-debug-info", 1, "Enable VP8 visible debug info"); - +static const arg_def_t pp_disp_ref_frame = ARG_DEF(NULL, "pp-dbg-ref-frame", 1, + "Display only selected reference frame per macro block"); +static const arg_def_t pp_disp_mb_modes = ARG_DEF(NULL, "pp-dbg-mb-modes", 1, + "Display only selected macro block modes"); +static const arg_def_t pp_disp_b_modes = ARG_DEF(NULL, "pp-dbg-b-modes", 1, + "Display only selected block modes"); +static const arg_def_t pp_disp_mvs = ARG_DEF(NULL, "pp-dbg-mvs", 1, + "Draw only selected motion vectors"); static const arg_def_t *vp8_pp_args[] = { &addnoise_level, &deblock, &demacroblock_level, &pp_debug_info, + &pp_disp_ref_frame, &pp_disp_mb_modes, &pp_disp_b_modes, &pp_disp_mvs, NULL }; #endif @@ -705,6 +713,10 @@ int main(int argc, const char **argv_) vpx_codec_dec_cfg_t cfg = {0}; #if CONFIG_VP8_DECODER vp8_postproc_cfg_t vp8_pp_cfg = {0}; + int vp8_dbg_color_ref_frame = 0; + int vp8_dbg_color_mb_modes = 0; + int vp8_dbg_color_b_modes = 0; + int vp8_dbg_display_mv = 0; #endif struct input_ctx input = {0}; @@ -790,6 +802,42 @@ int main(int argc, const char **argv_) if (level) vp8_pp_cfg.post_proc_flag |= level; } + else if (arg_match(&arg, &pp_disp_ref_frame, argi)) + { + unsigned int flags = arg_parse_int(&arg); + if (flags) + { + postproc = 1; + vp8_dbg_color_ref_frame = flags; + } + } + else if (arg_match(&arg, &pp_disp_mb_modes, argi)) + { + unsigned int flags = arg_parse_int(&arg); + if (flags) + { + postproc = 1; + vp8_dbg_color_mb_modes = flags; + } + } + else if (arg_match(&arg, &pp_disp_b_modes, argi)) + { + unsigned int flags = arg_parse_int(&arg); + if (flags) + { + postproc = 1; + vp8_dbg_color_b_modes = flags; + } + } + else if (arg_match(&arg, &pp_disp_mvs, argi)) + { + unsigned int flags = arg_parse_int(&arg); + if (flags) + { + postproc = 1; + vp8_dbg_display_mv = flags; + } + } #endif else @@ -929,6 +977,33 @@ int main(int argc, const char **argv_) return EXIT_FAILURE; } + if (vp8_dbg_color_ref_frame + && vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_REF_FRAME, vp8_dbg_color_ref_frame)) + { + fprintf(stderr, "Failed to configure reference block visualizer: %s\n", vpx_codec_error(&decoder)); + return EXIT_FAILURE; + } + + if (vp8_dbg_color_mb_modes + && vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_MB_MODES, vp8_dbg_color_mb_modes)) + { + fprintf(stderr, "Failed to configure macro block visualizer: %s\n", vpx_codec_error(&decoder)); + return EXIT_FAILURE; + } + + if (vp8_dbg_color_b_modes + && vpx_codec_control(&decoder, VP8_SET_DBG_COLOR_B_MODES, vp8_dbg_color_b_modes)) + { + fprintf(stderr, "Failed to configure block visualizer: %s\n", vpx_codec_error(&decoder)); + return EXIT_FAILURE; + } + + if (vp8_dbg_display_mv + && vpx_codec_control(&decoder, VP8_SET_DBG_DISPLAY_MV, vp8_dbg_display_mv)) + { + fprintf(stderr, "Failed to configure motion vector visualizer: %s\n", vpx_codec_error(&decoder)); + return EXIT_FAILURE; + } #endif /* Decode file */