visualize.c
上传用户:lctgjx
上传日期:2022-06-04
资源大小:8887k
文件大小:14k
源码类别:

流媒体/Mpeg4/MP4

开发平台:

Visual C++

  1. /*****************************************************************************
  2.  * x264: h264 encoder
  3.  *****************************************************************************
  4.  * Copyright (C) 2005 Tuukka Toivonen <tuukkat@ee.oulu.fi>
  5.  *
  6.  * This program is free software; you can redistribute it and/or modify
  7.  * it under the terms of the GNU General Public License as published by
  8.  * the Free Software Foundation; either version 2 of the License, or
  9.  * (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  19.  *****************************************************************************/
  20. /*
  21.  * Some explanation of the symbols used:
  22.  * Red/pink: intra block
  23.  * Blue: inter block
  24.  * Green: skip block
  25.  * Yellow: B-block (not visualized properly yet)
  26.  *
  27.  * Motion vectors have black dot at their target (ie. at the MB center),
  28.  * instead of arrowhead. The black dot is enclosed in filled diamond with radius
  29.  * depending on reference frame number (one frame back = zero width, normal case).
  30.  *
  31.  * The intra blocks have generally lines drawn perpendicular
  32.  * to the prediction direction, so for example, if there is a pink block
  33.  * with horizontal line at the top of it, it is interpolated by assuming
  34.  * luma to be vertically constant.
  35.  * DC predicted blocks have both horizontal and vertical lines,
  36.  * pink blocks with a diagonal line are predicted using the planar function.
  37.  */
  38. #include "common.h"
  39. #include "visualize.h"
  40. #include "display.h"
  41. typedef struct {
  42.     int     i_type;
  43.     int     i_partition;
  44.     int     i_sub_partition[4];
  45.     int     i_intra16x16_pred_mode;
  46.     int     intra4x4_pred_mode[4][4];
  47.     int8_t  ref[2][4][4];                  /* [list][y][x] */
  48.     int16_t mv[2][4][4][2];                /* [list][y][x][mvxy] */
  49. } visualize_t;
  50. /* {{{ [fold] char *get_string(const stringlist_t *sl, int entries, int code) */
  51. /* Return string from stringlist corresponding to the given code */
  52. #define GET_STRING(sl, code) get_string((sl), sizeof(sl)/sizeof(*(sl)), code)
  53. typedef struct {
  54.     int code;
  55.     char *string;
  56. } stringlist_t;
  57. static char *get_string(const stringlist_t *sl, int entries, int code)
  58. {
  59.     int i;
  60.     for (i=0; i<entries; i++) {
  61.         if (sl[i].code==code) break;
  62.     }
  63.     return (i>=entries) ? "?" : sl[i].string;
  64. }
  65. /* }}} */
  66. /* {{{ [fold] void mv(int x0, int y0, int16_t dmv[2], int ref, int zoom, char *col) */
  67. /* Plot motion vector */
  68. static void mv(int x0, int y0, int16_t dmv[2], int ref, int zoom, char *col)
  69. {
  70.     int dx = dmv[0];
  71.     int dy = dmv[1];
  72.     int i;
  73.     dx = (dx * zoom + 2) >> 2;                     /* Quarter pixel accurate MVs */
  74.     dy = (dy * zoom + 2) >> 2;
  75.     disp_line(0, x0, y0, x0+dx, y0+dy);
  76.     for (i=1; i<ref; i++){
  77.         disp_line(0, x0, y0-i, x0+i, y0);
  78.         disp_line(0, x0+i, y0, x0, y0+i);
  79.         disp_line(0, x0, y0+i, x0-i, y0);
  80.         disp_line(0, x0-i, y0, x0, y0-i);
  81.     }
  82.     disp_setcolor("black");
  83.     disp_point(0, x0, y0);
  84.     disp_setcolor(col);
  85. }
  86. /* }}} */
  87. /* {{{ [fold] void x264_visualize_init( x264_t *h ) */
  88. int x264_visualize_init( x264_t *h )
  89. {
  90.     int mb = h->sps->i_mb_width * h->sps->i_mb_height;
  91.     CHECKED_MALLOC( h->visualize, mb * sizeof(visualize_t) );
  92.     return 0;
  93. fail:
  94.     return -1;
  95. }
  96. /* }}} */
  97. /* {{{ [fold] void x264_visualize_mb( x264_t *h ) */
  98. void x264_visualize_mb( x264_t *h )
  99. {
  100.     visualize_t *v = (visualize_t*)h->visualize + h->mb.i_mb_xy;
  101.     int i, l, x, y;
  102.     /* Save all data for the MB what we need for drawing the visualization */
  103.     v->i_type = h->mb.i_type;
  104.     v->i_partition = h->mb.i_partition;
  105.     for (i=0; i<4; i++) v->i_sub_partition[i] = h->mb.i_sub_partition[i];
  106.     for (y=0; y<4; y++) for (x=0; x<4; x++)
  107.         v->intra4x4_pred_mode[y][x] = h->mb.cache.intra4x4_pred_mode[X264_SCAN8_0+y*8+x];
  108.     for (l=0; l<2; l++) for (y=0; y<4; y++) for (x=0; x<4; x++) {
  109.         for (i=0; i<2; i++) {
  110.             v->mv[l][y][x][i] = h->mb.cache.mv[l][X264_SCAN8_0+y*8+x][i];
  111.         }
  112.         v->ref[l][y][x] = h->mb.cache.ref[l][X264_SCAN8_0+y*8+x];
  113.     }
  114.     v->i_intra16x16_pred_mode = h->mb.i_intra16x16_pred_mode;
  115. }
  116. /* }}} */
  117. /* {{{ [fold] void x264_visualize_close( x264_t *h ) */
  118. void x264_visualize_close( x264_t *h )
  119. {
  120.     x264_free(h->visualize);
  121. }
  122. /* }}} */
  123. /* {{{ [fold] void x264_visualize_show( x264_t *h ) */
  124. /* Display visualization (block types, MVs) of the encoded frame */
  125. /* FIXME: B-type MBs not handled yet properly */
  126. void x264_visualize_show( x264_t *h )
  127. {
  128.     int mb_xy;
  129.     static const stringlist_t mb_types[] = {
  130.         /* Block types marked as NULL will not be drawn */
  131.         { I_4x4   , "red" },
  132.         { I_8x8   , "#ff5640" },
  133.         { I_16x16 , "#ff8060" },
  134.         { I_PCM   , "violet" },
  135.         { P_L0    , "SlateBlue" },
  136.         { P_8x8   , "blue" },
  137.         { P_SKIP  , "green" },
  138.         { B_DIRECT, "yellow" },
  139.         { B_L0_L0 , "yellow" },
  140.         { B_L0_L1 , "yellow" },
  141.         { B_L0_BI , "yellow" },
  142.         { B_L1_L0 , "yellow" },
  143.         { B_L1_L1 , "yellow" },
  144.         { B_L1_BI , "yellow" },
  145.         { B_BI_L0 , "yellow" },
  146.         { B_BI_L1 , "yellow" },
  147.         { B_BI_BI , "yellow" },
  148.         { B_8x8   , "yellow" },
  149.         { B_SKIP  , "yellow" },
  150.     };
  151.     static const int waitkey = 1;     /* Wait for enter after each frame */
  152.     static const int drawbox = 1;     /* Draw box around each block */
  153.     static const int borders = 0;     /* Display extrapolated borders outside frame */
  154.     static const int zoom = 2;        /* Zoom factor */
  155.     static const int pad = 32;
  156.     uint8_t *const frame = h->fdec->plane[0];
  157.     const int width = h->param.i_width;
  158.     const int height = h->param.i_height;
  159.     const int stride = h->fdec->i_stride[0];
  160.     if (borders) {
  161.         disp_gray_zoom(0, frame - pad*stride - pad, width+2*pad, height+2*pad, stride, "fdec", zoom);
  162.     } else {
  163.         disp_gray_zoom(0, frame, width, height, stride, "fdec", zoom);
  164.     }
  165.     for( mb_xy = 0; mb_xy < h->sps->i_mb_width * h->sps->i_mb_height; mb_xy++ )
  166.     {
  167.         visualize_t *const v = (visualize_t*)h->visualize + mb_xy;
  168.         const int mb_y = mb_xy / h->sps->i_mb_width;
  169.         const int mb_x = mb_xy % h->sps->i_mb_width;
  170.         char *const col = GET_STRING(mb_types, v->i_type);
  171.         int x = mb_x*16*zoom;
  172.         int y = mb_y*16*zoom;
  173.         int l = 0;
  174.         unsigned int i, j;
  175.         if (col==NULL) continue;
  176.         if (borders) {
  177.             x += pad*zoom;
  178.             y += pad*zoom;
  179.         }
  180.         disp_setcolor(col);
  181.         if (drawbox) disp_rect(0, x, y, x+16*zoom-1, y+16*zoom-1);
  182.         if (v->i_type==P_L0 || v->i_type==P_8x8 || v->i_type==P_SKIP) {
  183.             /* Predicted (inter) mode, with motion vector */
  184.             if (v->i_partition==D_16x16 || v->i_type==P_SKIP) {
  185.                 mv(x+8*zoom, y+8*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col);
  186.             }
  187.             if (v->i_partition==D_16x8) {
  188.                 if (drawbox) disp_rect(0, x, y, x+16*zoom, y+8*zoom);
  189.                 mv(x+8*zoom, y+4*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col);
  190.                 if (drawbox) disp_rect(0, x, y+8*zoom, x+16*zoom, y+16*zoom);
  191.                 mv(x+8*zoom, y+12*zoom, v->mv[l][2][0], v->ref[l][2][0], zoom, col);
  192.             }
  193.             if (v->i_partition==D_8x16) {
  194.                 if (drawbox) disp_rect(0, x,          y, x+8*zoom,  y+16*zoom);
  195.                 mv(x+4*zoom, y+8*zoom, v->mv[l][0][0], v->ref[l][0][0], zoom, col);
  196.                 if (drawbox) disp_rect(0, x+8*zoom,   y, x+16*zoom, y+16*zoom);
  197.                 mv(x+12*zoom, y+8*zoom, v->mv[l][0][2], v->ref[l][0][2], zoom, col);
  198.             }
  199.             if (v->i_partition==D_8x8) {
  200.                 for (i=0; i<2; i++) for (j=0; j<2; j++) {
  201.                     int sp = v->i_sub_partition[i*2+j];
  202.                     const int x0 = x + j*8*zoom;
  203.                     const int y0 = y + i*8*zoom;
  204.                     l = x264_mb_partition_listX_table[0][sp] ? 0 : 1; /* FIXME: not tested if this works */
  205.                     if (IS_SUB8x8(sp)) {
  206.                         if (drawbox) disp_rect(0, x0, y0, x0+8*zoom, y0+8*zoom);
  207.                         mv(x0+4*zoom, y0+4*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col);
  208.                     }
  209.                     if (IS_SUB8x4(sp)) {
  210.                         if (drawbox) disp_rect(0, x0, y0, x0+8*zoom, y0+4*zoom);
  211.                         if (drawbox) disp_rect(0, x0, y0+4*zoom, x0+8*zoom, y0+8*zoom);
  212.                         mv(x0+4*zoom, y0+2*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col);
  213.                         mv(x0+4*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j], v->ref[l][2*i+1][2*j], zoom, col);
  214.                     }
  215.                     if (IS_SUB4x8(sp)) {
  216.                         if (drawbox) disp_rect(0, x0, y0, x0+4*zoom, y0+8*zoom);
  217.                         if (drawbox) disp_rect(0, x0+4*zoom, y0, x0+8*zoom, y0+8*zoom);
  218.                         mv(x0+2*zoom, y0+4*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col);
  219.                         mv(x0+6*zoom, y0+4*zoom, v->mv[l][2*i][2*j+1], v->ref[l][2*i][2*j+1], zoom, col);
  220.                     }
  221.                     if (IS_SUB4x4(sp)) {
  222.                         if (drawbox) disp_rect(0, x0, y0, x0+4*zoom, y0+4*zoom);
  223.                         if (drawbox) disp_rect(0, x0+4*zoom, y0, x0+8*zoom, y0+4*zoom);
  224.                         if (drawbox) disp_rect(0, x0, y0+4*zoom, x0+4*zoom, y0+8*zoom);
  225.                         if (drawbox) disp_rect(0, x0+4*zoom, y0+4*zoom, x0+8*zoom, y0+8*zoom);
  226.                         mv(x0+2*zoom, y0+2*zoom, v->mv[l][2*i][2*j], v->ref[l][2*i][2*j], zoom, col);
  227.                         mv(x0+6*zoom, y0+2*zoom, v->mv[l][2*i][2*j+1], v->ref[l][2*i][2*j+1], zoom, col);
  228.                         mv(x0+2*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j], v->ref[l][2*i+1][2*j], zoom, col);
  229.                         mv(x0+6*zoom, y0+6*zoom, v->mv[l][2*i+1][2*j+1], v->ref[l][2*i+1][2*j+1], zoom, col);
  230.                     }
  231.                 }
  232.             }
  233.         }
  234.         if (IS_INTRA(v->i_type) || v->i_type==I_PCM) {
  235.             /* Intra coded */
  236.             if (v->i_type==I_16x16) {
  237.                 switch (v->i_intra16x16_pred_mode) {
  238.                 case I_PRED_16x16_V:
  239.                     disp_line(0, x+2*zoom, y+2*zoom, x+14*zoom, y+2*zoom);
  240.                     break;
  241.                 case I_PRED_16x16_H:
  242.                     disp_line(0, x+2*zoom, y+2*zoom, x+2*zoom, y+14*zoom);
  243.                     break;
  244.                 case I_PRED_16x16_DC:
  245.                 case I_PRED_16x16_DC_LEFT:
  246.                 case I_PRED_16x16_DC_TOP:
  247.                 case I_PRED_16x16_DC_128:
  248.                     disp_line(0, x+2*zoom, y+2*zoom, x+14*zoom, y+2*zoom);
  249.                     disp_line(0, x+2*zoom, y+2*zoom, x+2*zoom, y+14*zoom);
  250.                     break;
  251.                 case I_PRED_16x16_P:
  252.                     disp_line(0, x+2*zoom, y+2*zoom, x+8*zoom, y+8*zoom);
  253.                     break;
  254.                 }
  255.             }
  256.             if (v->i_type==I_4x4 || v->i_type==I_8x8) {
  257.                 const int di = v->i_type==I_8x8 ? 2 : 1;
  258.                 const int zoom2 = zoom * di;
  259.                 for (i=0; i<4; i+=di) for (j=0; j<4; j+=di) {
  260.                     const int x0 = x + j*4*zoom;
  261.                     const int y0 = y + i*4*zoom;
  262.                     if (drawbox) disp_rect(0, x0, y0, x0+4*zoom2, y0+4*zoom2);
  263.                     switch (v->intra4x4_pred_mode[i][j]) {
  264.                     case I_PRED_4x4_V: /* Vertical */
  265.                         disp_line(0, x0+0*zoom2, y0+1*zoom2, x0+4*zoom2, y0+1*zoom2);
  266.                         break;
  267.                     case I_PRED_4x4_H: /* Horizontal */
  268.                         disp_line(0, x0+1*zoom2, y0+0*zoom2, x0+1*zoom2, y0+4*zoom2);
  269.                         break;
  270.                     case I_PRED_4x4_DC: /* DC, average from top and left sides */
  271.                     case I_PRED_4x4_DC_LEFT:
  272.                     case I_PRED_4x4_DC_TOP:
  273.                     case I_PRED_4x4_DC_128:
  274.                         disp_line(0, x0+1*zoom2, y0+1*zoom2, x0+4*zoom2, y0+1*zoom2);
  275.                         disp_line(0, x0+1*zoom2, y0+1*zoom2, x0+1*zoom2, y0+4*zoom2);
  276.                         break;
  277.                     case I_PRED_4x4_DDL: /* Topright-bottomleft */
  278.                         disp_line(0, x0+0*zoom2, y0+0*zoom2, x0+4*zoom2, y0+4*zoom2);
  279.                         break;
  280.                     case I_PRED_4x4_DDR: /* Topleft-bottomright */
  281.                         disp_line(0, x0+0*zoom2, y0+4*zoom2, x0+4*zoom2, y0+0*zoom2);
  282.                         break;
  283.                     case I_PRED_4x4_VR: /* Mix of topleft-bottomright and vertical */
  284.                         disp_line(0, x0+0*zoom2, y0+2*zoom2, x0+4*zoom2, y0+1*zoom2);
  285.                         break;
  286.                     case I_PRED_4x4_HD: /* Mix of topleft-bottomright and horizontal */
  287.                         disp_line(0, x0+2*zoom2, y0+0*zoom2, x0+1*zoom2, y0+4*zoom2);
  288.                         break;
  289.                     case I_PRED_4x4_VL: /* Mix of topright-bottomleft and vertical */
  290.                         disp_line(0, x0+0*zoom2, y0+1*zoom2, x0+4*zoom2, y0+2*zoom2);
  291.                         break;
  292.                     case I_PRED_4x4_HU: /* Mix of topright-bottomleft and horizontal */
  293.                         disp_line(0, x0+1*zoom2, y0+0*zoom2, x0+2*zoom2, y0+4*zoom2);
  294.                         break;
  295.                     }
  296.                 }
  297.             }
  298.         }
  299.     }
  300.     disp_sync();
  301.     if (waitkey) getchar();
  302. }
  303. /* }}} */
  304. //EOF