LCOV - code coverage report
Current view: top level - libavcodec - mpegutils.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 92 156 59.0 %
Date: 2017-12-11 04:34:20 Functions: 3 3 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Mpeg video formats-related defines and utility functions
       3             :  *
       4             :  * This file is part of FFmpeg.
       5             :  *
       6             :  * FFmpeg is free software; you can redistribute it and/or
       7             :  * modify it under the terms of the GNU Lesser General Public
       8             :  * License as published by the Free Software Foundation; either
       9             :  * version 2.1 of the License, or (at your option) any later version.
      10             :  *
      11             :  * FFmpeg 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 GNU
      14             :  * Lesser General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU Lesser General Public
      17             :  * License along with FFmpeg; if not, write to the Free Software
      18             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      19             :  */
      20             : 
      21             : #include <stdint.h>
      22             : 
      23             : #include "libavutil/common.h"
      24             : #include "libavutil/frame.h"
      25             : #include "libavutil/pixdesc.h"
      26             : #include "libavutil/motion_vector.h"
      27             : #include "libavutil/avassert.h"
      28             : 
      29             : #include "avcodec.h"
      30             : #include "mpegutils.h"
      31             : 
      32        1014 : static int add_mb(AVMotionVector *mb, uint32_t mb_type,
      33             :                   int dst_x, int dst_y,
      34             :                   int motion_x, int motion_y, int motion_scale,
      35             :                   int direction)
      36             : {
      37        1014 :     mb->w = IS_8X8(mb_type) || IS_8X16(mb_type) ? 8 : 16;
      38        1014 :     mb->h = IS_8X8(mb_type) || IS_16X8(mb_type) ? 8 : 16;
      39        1014 :     mb->motion_x = motion_x;
      40        1014 :     mb->motion_y = motion_y;
      41        1014 :     mb->motion_scale = motion_scale;
      42        1014 :     mb->dst_x = dst_x;
      43        1014 :     mb->dst_y = dst_y;
      44        1014 :     mb->src_x = dst_x + motion_x / motion_scale;
      45        1014 :     mb->src_y = dst_y + motion_y / motion_scale;
      46        1014 :     mb->source = direction ? 1 : -1;
      47        1014 :     mb->flags = 0; // XXX: does mb_type contain extra information that could be exported here?
      48        1014 :     return 1;
      49             : }
      50             : 
      51      188135 : void ff_draw_horiz_band(AVCodecContext *avctx,
      52             :                         AVFrame *cur, AVFrame *last,
      53             :                         int y, int h, int picture_structure,
      54             :                         int first_field, int low_delay)
      55             : {
      56      188135 :     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
      57      188135 :     int vshift = desc->log2_chroma_h;
      58      188135 :     const int field_pic = picture_structure != PICT_FRAME;
      59      188135 :     if (field_pic) {
      60       15272 :         h <<= 1;
      61       15272 :         y <<= 1;
      62             :     }
      63             : 
      64      188135 :     h = FFMIN(h, avctx->height - y);
      65             : 
      66      195785 :     if (field_pic && first_field &&
      67        7650 :         !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))
      68        7650 :         return;
      69             : 
      70      180485 :     if (avctx->draw_horiz_band) {
      71             :         AVFrame *src;
      72             :         int offset[AV_NUM_DATA_POINTERS];
      73             :         int i;
      74             : 
      75        3350 :         if (cur->pict_type == AV_PICTURE_TYPE_B || low_delay ||
      76           0 :            (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
      77        3350 :             src = cur;
      78           0 :         else if (last)
      79           0 :             src = last;
      80             :         else
      81           0 :             return;
      82             : 
      83        3350 :         if (cur->pict_type == AV_PICTURE_TYPE_B &&
      84           0 :             picture_structure == PICT_FRAME &&
      85           0 :             avctx->codec_id != AV_CODEC_ID_SVQ3) {
      86           0 :             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
      87           0 :                 offset[i] = 0;
      88             :         } else {
      89        3350 :             offset[0]= y * src->linesize[0];
      90        3350 :             offset[1]=
      91        3350 :             offset[2]= (y >> vshift) * src->linesize[1];
      92       20100 :             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
      93       16750 :                 offset[i] = 0;
      94             :         }
      95             : 
      96        3350 :         emms_c();
      97             : 
      98        3350 :         avctx->draw_horiz_band(avctx, src, offset,
      99             :                                y, picture_structure, h);
     100             :     }
     101             : }
     102             : 
     103       31980 : void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table,
     104             :                          uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2],
     105             :                          int *low_delay,
     106             :                          int mb_width, int mb_height, int mb_stride, int quarter_sample)
     107             : {
     108       31980 :     if ((avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) && mbtype_table && motion_val[0]) {
     109          60 :         const int shift = 1 + quarter_sample;
     110          60 :         const int scale = 1 << shift;
     111          60 :         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
     112         120 :         const int mv_stride      = (mb_width << mv_sample_log2) +
     113          60 :                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
     114          60 :         int mb_x, mb_y, mbcount = 0;
     115             : 
     116             :         /* size is width * height * 2 * 4 where 2 is for directions and 4 is
     117             :          * for the maximum number of MB (4 MB in case of IS_8x8) */
     118          60 :         AVMotionVector *mvs = av_malloc_array(mb_width * mb_height, 2 * 4 * sizeof(AVMotionVector));
     119          60 :         if (!mvs)
     120           0 :             return;
     121             : 
     122        1260 :         for (mb_y = 0; mb_y < mb_height; mb_y++) {
     123       44400 :             for (mb_x = 0; mb_x < mb_width; mb_x++) {
     124       43200 :                 int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];
     125      129600 :                 for (direction = 0; direction < 2; direction++) {
     126       86400 :                     if (!USES_LIST(mb_type, direction))
     127       85527 :                         continue;
     128         873 :                     if (IS_8X8(mb_type)) {
     129         160 :                         for (i = 0; i < 4; i++) {
     130         128 :                             int sx = mb_x * 16 + 4 + 8 * (i & 1);
     131         128 :                             int sy = mb_y * 16 + 4 + 8 * (i >> 1);
     132         384 :                             int xy = (mb_x * 2 + (i & 1) +
     133         256 :                                       (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
     134         128 :                             int mx = motion_val[direction][xy][0];
     135         128 :                             int my = motion_val[direction][xy][1];
     136         128 :                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
     137             :                         }
     138         841 :                     } else if (IS_16X8(mb_type)) {
     139          90 :                         for (i = 0; i < 2; i++) {
     140          60 :                             int sx = mb_x * 16 + 8;
     141          60 :                             int sy = mb_y * 16 + 4 + 8 * i;
     142          60 :                             int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
     143          60 :                             int mx = motion_val[direction][xy][0];
     144          60 :                             int my = motion_val[direction][xy][1];
     145             : 
     146          60 :                             if (IS_INTERLACED(mb_type))
     147           0 :                                 my *= 2;
     148             : 
     149          60 :                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
     150             :                         }
     151         811 :                     } else if (IS_8X16(mb_type)) {
     152          45 :                         for (i = 0; i < 2; i++) {
     153          30 :                             int sx = mb_x * 16 + 4 + 8 * i;
     154          30 :                             int sy = mb_y * 16 + 8;
     155          30 :                             int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
     156          30 :                             int mx = motion_val[direction][xy][0];
     157          30 :                             int my = motion_val[direction][xy][1];
     158             : 
     159          30 :                             if (IS_INTERLACED(mb_type))
     160           0 :                                 my *= 2;
     161             : 
     162          30 :                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
     163             :                         }
     164             :                     } else {
     165         796 :                           int sx = mb_x * 16 + 8;
     166         796 :                           int sy = mb_y * 16 + 8;
     167         796 :                           int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
     168         796 :                           int mx = motion_val[direction][xy][0];
     169         796 :                           int my = motion_val[direction][xy][1];
     170         796 :                           mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
     171             :                     }
     172             :                 }
     173             :             }
     174             :         }
     175             : 
     176          60 :         if (mbcount) {
     177             :             AVFrameSideData *sd;
     178             : 
     179          27 :             av_log(avctx, AV_LOG_DEBUG, "Adding %d MVs info to frame %d\n", mbcount, avctx->frame_number);
     180          27 :             sd = av_frame_new_side_data(pict, AV_FRAME_DATA_MOTION_VECTORS, mbcount * sizeof(AVMotionVector));
     181          27 :             if (!sd) {
     182           0 :                 av_freep(&mvs);
     183           0 :                 return;
     184             :             }
     185          27 :             memcpy(sd->data, mvs, mbcount * sizeof(AVMotionVector));
     186             :         }
     187             : 
     188          60 :         av_freep(&mvs);
     189             :     }
     190             : 
     191             :     /* TODO: export all the following to make them accessible for users (and filters) */
     192       31980 :     if (avctx->hwaccel || !mbtype_table)
     193           0 :         return;
     194             : 
     195             : 
     196       31980 :     if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
     197             :         int x,y;
     198             : 
     199           0 :         av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
     200           0 :                av_get_picture_type_char(pict->pict_type));
     201           0 :         for (y = 0; y < mb_height; y++) {
     202           0 :             for (x = 0; x < mb_width; x++) {
     203           0 :                 if (avctx->debug & FF_DEBUG_SKIP) {
     204           0 :                     int count = mbskip_table ? mbskip_table[x + y * mb_stride] : 0;
     205           0 :                     if (count > 9)
     206           0 :                         count = 9;
     207           0 :                     av_log(avctx, AV_LOG_DEBUG, "%1d", count);
     208             :                 }
     209           0 :                 if (avctx->debug & FF_DEBUG_QP) {
     210           0 :                     av_log(avctx, AV_LOG_DEBUG, "%2d",
     211           0 :                            qscale_table[x + y * mb_stride]);
     212             :                 }
     213           0 :                 if (avctx->debug & FF_DEBUG_MB_TYPE) {
     214           0 :                     int mb_type = mbtype_table[x + y * mb_stride];
     215             :                     // Type & MV direction
     216           0 :                     if (IS_PCM(mb_type))
     217           0 :                         av_log(avctx, AV_LOG_DEBUG, "P");
     218           0 :                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
     219           0 :                         av_log(avctx, AV_LOG_DEBUG, "A");
     220           0 :                     else if (IS_INTRA4x4(mb_type))
     221           0 :                         av_log(avctx, AV_LOG_DEBUG, "i");
     222           0 :                     else if (IS_INTRA16x16(mb_type))
     223           0 :                         av_log(avctx, AV_LOG_DEBUG, "I");
     224           0 :                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
     225           0 :                         av_log(avctx, AV_LOG_DEBUG, "d");
     226           0 :                     else if (IS_DIRECT(mb_type))
     227           0 :                         av_log(avctx, AV_LOG_DEBUG, "D");
     228           0 :                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
     229           0 :                         av_log(avctx, AV_LOG_DEBUG, "g");
     230           0 :                     else if (IS_GMC(mb_type))
     231           0 :                         av_log(avctx, AV_LOG_DEBUG, "G");
     232           0 :                     else if (IS_SKIP(mb_type))
     233           0 :                         av_log(avctx, AV_LOG_DEBUG, "S");
     234           0 :                     else if (!USES_LIST(mb_type, 1))
     235           0 :                         av_log(avctx, AV_LOG_DEBUG, ">");
     236           0 :                     else if (!USES_LIST(mb_type, 0))
     237           0 :                         av_log(avctx, AV_LOG_DEBUG, "<");
     238             :                     else {
     239             :                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
     240           0 :                         av_log(avctx, AV_LOG_DEBUG, "X");
     241             :                     }
     242             : 
     243             :                     // segmentation
     244           0 :                     if (IS_8X8(mb_type))
     245           0 :                         av_log(avctx, AV_LOG_DEBUG, "+");
     246           0 :                     else if (IS_16X8(mb_type))
     247           0 :                         av_log(avctx, AV_LOG_DEBUG, "-");
     248           0 :                     else if (IS_8X16(mb_type))
     249           0 :                         av_log(avctx, AV_LOG_DEBUG, "|");
     250           0 :                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
     251           0 :                         av_log(avctx, AV_LOG_DEBUG, " ");
     252             :                     else
     253           0 :                         av_log(avctx, AV_LOG_DEBUG, "?");
     254             : 
     255             : 
     256           0 :                     if (IS_INTERLACED(mb_type))
     257           0 :                         av_log(avctx, AV_LOG_DEBUG, "=");
     258             :                     else
     259           0 :                         av_log(avctx, AV_LOG_DEBUG, " ");
     260             :                 }
     261             :             }
     262           0 :             av_log(avctx, AV_LOG_DEBUG, "\n");
     263             :         }
     264             :     }
     265             : 
     266             : #if FF_API_DEBUG_MV
     267             :     if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
     268             :         (avctx->debug_mv)) {
     269             :         int mb_y;
     270             :         int i, ret;
     271             :         int h_chroma_shift, v_chroma_shift, block_height;
     272             :         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
     273             :         const int mv_stride      = (mb_width << mv_sample_log2) +
     274             :                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
     275             : 
     276             :         if (low_delay)
     277             :             *low_delay = 0; // needed to see the vectors without trashing the buffers
     278             : 
     279             :         ret = av_pix_fmt_get_chroma_sub_sample (avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
     280             :         if (ret)
     281             :             return ret;
     282             : 
     283             :         av_frame_make_writable(pict);
     284             : 
     285             :         pict->opaque = NULL;
     286             :         block_height = 16 >> v_chroma_shift;
     287             : 
     288             :         for (mb_y = 0; mb_y < mb_height; mb_y++) {
     289             :             int mb_x;
     290             :             for (mb_x = 0; mb_x < mb_width; mb_x++) {
     291             :                 const int mb_index = mb_x + mb_y * mb_stride;
     292             :                 if ((avctx->debug & FF_DEBUG_VIS_QP)) {
     293             :                     uint64_t c = (qscale_table[mb_index] * 128 / 31) *
     294             :                                  0x0101010101010101ULL;
     295             :                     int y;
     296             :                     for (y = 0; y < block_height; y++) {
     297             :                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
     298             :                                       (block_height * mb_y + y) *
     299             :                                       pict->linesize[1]) = c;
     300             :                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
     301             :                                       (block_height * mb_y + y) *
     302             :                                       pict->linesize[2]) = c;
     303             :                     }
     304             :                 }
     305             :                 if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
     306             :                     motion_val[0]) {
     307             :                     int mb_type = mbtype_table[mb_index];
     308             :                     uint64_t u,v;
     309             :                     int y;
     310             : #define COLOR(theta, r) \
     311             :     u = (int)(128 + r * cos(theta * M_PI / 180)); \
     312             :     v = (int)(128 + r * sin(theta * M_PI / 180));
     313             : 
     314             : 
     315             :                     u = v = 128;
     316             :                     if (IS_PCM(mb_type)) {
     317             :                         COLOR(120, 48)
     318             :                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
     319             :                                IS_INTRA16x16(mb_type)) {
     320             :                         COLOR(30, 48)
     321             :                     } else if (IS_INTRA4x4(mb_type)) {
     322             :                         COLOR(90, 48)
     323             :                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
     324             :                         // COLOR(120, 48)
     325             :                     } else if (IS_DIRECT(mb_type)) {
     326             :                         COLOR(150, 48)
     327             :                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
     328             :                         COLOR(170, 48)
     329             :                     } else if (IS_GMC(mb_type)) {
     330             :                         COLOR(190, 48)
     331             :                     } else if (IS_SKIP(mb_type)) {
     332             :                         // COLOR(180, 48)
     333             :                     } else if (!USES_LIST(mb_type, 1)) {
     334             :                         COLOR(240, 48)
     335             :                     } else if (!USES_LIST(mb_type, 0)) {
     336             :                         COLOR(0, 48)
     337             :                     } else {
     338             :                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
     339             :                         COLOR(300,48)
     340             :                     }
     341             : 
     342             :                     u *= 0x0101010101010101ULL;
     343             :                     v *= 0x0101010101010101ULL;
     344             :                     for (y = 0; y < block_height; y++) {
     345             :                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
     346             :                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
     347             :                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
     348             :                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
     349             :                     }
     350             : 
     351             :                     // segmentation
     352             :                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
     353             :                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
     354             :                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
     355             :                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
     356             :                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
     357             :                     }
     358             :                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
     359             :                         for (y = 0; y < 16; y++)
     360             :                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
     361             :                                           pict->linesize[0]] ^= 0x80;
     362             :                     }
     363             :                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
     364             :                         int dm = 1 << (mv_sample_log2 - 2);
     365             :                         for (i = 0; i < 4; i++) {
     366             :                             int sx = mb_x * 16 + 8 * (i & 1);
     367             :                             int sy = mb_y * 16 + 8 * (i >> 1);
     368             :                             int xy = (mb_x * 2 + (i & 1) +
     369             :                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
     370             :                             // FIXME bidir
     371             :                             int32_t *mv = (int32_t *) &motion_val[0][xy];
     372             :                             if (mv[0] != mv[dm] ||
     373             :                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
     374             :                                 for (y = 0; y < 8; y++)
     375             :                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
     376             :                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
     377             :                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
     378             :                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
     379             :                         }
     380             :                     }
     381             : 
     382             :                     if (IS_INTERLACED(mb_type) &&
     383             :                         avctx->codec->id == AV_CODEC_ID_H264) {
     384             :                         // hmm
     385             :                     }
     386             :                 }
     387             :                 if (mbskip_table)
     388             :                     mbskip_table[mb_index] = 0;
     389             :             }
     390             :         }
     391             :     }
     392             : #endif
     393             : }

Generated by: LCOV version 1.13