falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
100813 Commits
32 Branches
940MB
Tree: c3f3b562c9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c3f3b562c9'
${ noResults }
FFmpeg/libavcodec/mpegutils.c

266 lines
11KB
Raw Blame History 

  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. 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.     mb->w = IS_8X8(mb_type) || IS_8X16(mb_type) ? 8 : 16;

  38.     mb->h = IS_8X8(mb_type) || IS_16X8(mb_type) ? 8 : 16;

  39.     mb->motion_x = motion_x;

  40.     mb->motion_y = motion_y;

  41.     mb->motion_scale = motion_scale;

  42.     mb->dst_x = dst_x;

  43.     mb->dst_y = dst_y;

  44.     mb->src_x = dst_x + motion_x / motion_scale;

  45.     mb->src_y = dst_y + motion_y / motion_scale;

  46.     mb->source = direction ? 1 : -1;

  47.     mb->flags = 0; // XXX: does mb_type contain extra information that could be exported here?

  48.     return 1;

  49. }

  50. 

  51. 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.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);

  57.     int vshift = desc->log2_chroma_h;

  58.     const int field_pic = picture_structure != PICT_FRAME;

  59.     if (field_pic) {

  60.         h <<= 1;

  61.         y <<= 1;

  62.     }

  63. 

  64.     h = FFMIN(h, avctx->height - y);

  65. 

  66.     if (field_pic && first_field &&

  67.         !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))

  68.         return;

  69. 

  70.     if (avctx->draw_horiz_band) {

  71.         AVFrame *src;

  72.         int offset[AV_NUM_DATA_POINTERS];

  73.         int i;

  74. 

  75.         if (cur->pict_type == AV_PICTURE_TYPE_B || low_delay ||

  76.            (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))

  77.             src = cur;

  78.         else if (last)

  79.             src = last;

  80.         else

  81.             return;

  82. 

  83.         if (cur->pict_type == AV_PICTURE_TYPE_B &&

  84.             picture_structure == PICT_FRAME &&

  85.             avctx->codec_id != AV_CODEC_ID_SVQ3) {

  86.             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)

  87.                 offset[i] = 0;

  88.         } else {

  89.             offset[0]= y * src->linesize[0];

  90.             offset[1]=

  91.             offset[2]= (y >> vshift) * src->linesize[1];

  92.             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)

  93.                 offset[i] = 0;

  94.         }

  95. 

  96.         emms_c();

  97. 

  98.         avctx->draw_horiz_band(avctx, src, offset,

  99.                                y, picture_structure, h);

  100.     }

  101. }

  102. 

  103. 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.     if ((avctx->export_side_data & AV_CODEC_EXPORT_DATA_MVS) && mbtype_table && motion_val[0]) {

  109.         const int shift = 1 + quarter_sample;

  110.         const int scale = 1 << shift;

  111.         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;

  112.         const int mv_stride      = (mb_width << mv_sample_log2) +

  113.                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);

  114.         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.         AVMotionVector *mvs = av_malloc_array(mb_width * mb_height, 2 * 4 * sizeof(AVMotionVector));

  119.         if (!mvs)

  120.             return;

  121. 

  122.         for (mb_y = 0; mb_y < mb_height; mb_y++) {

  123.             for (mb_x = 0; mb_x < mb_width; mb_x++) {

  124.                 int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];

  125.                 for (direction = 0; direction < 2; direction++) {

  126.                     if (!USES_LIST(mb_type, direction))

  127.                         continue;

  128.                     if (IS_8X8(mb_type)) {

  129.                         for (i = 0; i < 4; i++) {

  130.                             int sx = mb_x * 16 + 4 + 8 * (i & 1);

  131.                             int sy = mb_y * 16 + 4 + 8 * (i >> 1);

  132.                             int xy = (mb_x * 2 + (i & 1) +

  133.                                       (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);

  134.                             int mx = motion_val[direction][xy][0];

  135.                             int my = motion_val[direction][xy][1];

  136.                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);

  137.                         }

  138.                     } else if (IS_16X8(mb_type)) {

  139.                         for (i = 0; i < 2; i++) {

  140.                             int sx = mb_x * 16 + 8;

  141.                             int sy = mb_y * 16 + 4 + 8 * i;

  142.                             int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);

  143.                             int mx = motion_val[direction][xy][0];

  144.                             int my = motion_val[direction][xy][1];

  145. 

  146.                             if (IS_INTERLACED(mb_type))

  147.                                 my *= 2;

  148. 

  149.                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);

  150.                         }

  151.                     } else if (IS_8X16(mb_type)) {

  152.                         for (i = 0; i < 2; i++) {

  153.                             int sx = mb_x * 16 + 4 + 8 * i;

  154.                             int sy = mb_y * 16 + 8;

  155.                             int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);

  156.                             int mx = motion_val[direction][xy][0];

  157.                             int my = motion_val[direction][xy][1];

  158. 

  159.                             if (IS_INTERLACED(mb_type))

  160.                                 my *= 2;

  161. 

  162.                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);

  163.                         }

  164.                     } else {

  165.                           int sx = mb_x * 16 + 8;

  166.                           int sy = mb_y * 16 + 8;

  167.                           int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;

  168.                           int mx = motion_val[direction][xy][0];

  169.                           int my = motion_val[direction][xy][1];

  170.                           mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);

  171.                     }

  172.                 }

  173.             }

  174.         }

  175. 

  176.         if (mbcount) {

  177.             AVFrameSideData *sd;

  178. 

  179.             av_log(avctx, AV_LOG_DEBUG, "Adding %d MVs info to frame %d\n", mbcount, avctx->frame_number);

  180.             sd = av_frame_new_side_data(pict, AV_FRAME_DATA_MOTION_VECTORS, mbcount * sizeof(AVMotionVector));

  181.             if (!sd) {

  182.                 av_freep(&mvs);

  183.                 return;

  184.             }

  185.             memcpy(sd->data, mvs, mbcount * sizeof(AVMotionVector));

  186.         }

  187. 

  188.         av_freep(&mvs);

  189.     }

  190. 

  191.     /* TODO: export all the following to make them accessible for users (and filters) */

  192.     if (avctx->hwaccel || !mbtype_table)

  193.         return;

  194. 

  195. 

  196.     if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {

  197.         int x,y;

  198. 

  199.         av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",

  200.                av_get_picture_type_char(pict->pict_type));

  201.         for (y = 0; y < mb_height; y++) {

  202.             for (x = 0; x < mb_width; x++) {

  203.                 if (avctx->debug & FF_DEBUG_SKIP) {

  204.                     int count = mbskip_table ? mbskip_table[x + y * mb_stride] : 0;

  205.                     if (count > 9)

  206.                         count = 9;

  207.                     av_log(avctx, AV_LOG_DEBUG, "%1d", count);

  208.                 }

  209.                 if (avctx->debug & FF_DEBUG_QP) {

  210.                     av_log(avctx, AV_LOG_DEBUG, "%2d",

  211.                            qscale_table[x + y * mb_stride]);

  212.                 }

  213.                 if (avctx->debug & FF_DEBUG_MB_TYPE) {

  214.                     int mb_type = mbtype_table[x + y * mb_stride];

  215.                     // Type & MV direction

  216.                     if (IS_PCM(mb_type))

  217.                         av_log(avctx, AV_LOG_DEBUG, "P");

  218.                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))

  219.                         av_log(avctx, AV_LOG_DEBUG, "A");

  220.                     else if (IS_INTRA4x4(mb_type))

  221.                         av_log(avctx, AV_LOG_DEBUG, "i");

  222.                     else if (IS_INTRA16x16(mb_type))

  223.                         av_log(avctx, AV_LOG_DEBUG, "I");

  224.                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))

  225.                         av_log(avctx, AV_LOG_DEBUG, "d");

  226.                     else if (IS_DIRECT(mb_type))

  227.                         av_log(avctx, AV_LOG_DEBUG, "D");

  228.                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))

  229.                         av_log(avctx, AV_LOG_DEBUG, "g");

  230.                     else if (IS_GMC(mb_type))

  231.                         av_log(avctx, AV_LOG_DEBUG, "G");

  232.                     else if (IS_SKIP(mb_type))

  233.                         av_log(avctx, AV_LOG_DEBUG, "S");

  234.                     else if (!USES_LIST(mb_type, 1))

  235.                         av_log(avctx, AV_LOG_DEBUG, ">");

  236.                     else if (!USES_LIST(mb_type, 0))

  237.                         av_log(avctx, AV_LOG_DEBUG, "<");

  238.                     else {

  239.                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));

  240.                         av_log(avctx, AV_LOG_DEBUG, "X");

  241.                     }

  242. 

  243.                     // segmentation

  244.                     if (IS_8X8(mb_type))

  245.                         av_log(avctx, AV_LOG_DEBUG, "+");

  246.                     else if (IS_16X8(mb_type))

  247.                         av_log(avctx, AV_LOG_DEBUG, "-");

  248.                     else if (IS_8X16(mb_type))

  249.                         av_log(avctx, AV_LOG_DEBUG, "|");

  250.                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))

  251.                         av_log(avctx, AV_LOG_DEBUG, " ");

  252.                     else

  253.                         av_log(avctx, AV_LOG_DEBUG, "?");

  254. 

  255. 

  256.                     if (IS_INTERLACED(mb_type))

  257.                         av_log(avctx, AV_LOG_DEBUG, "=");

  258.                     else

  259.                         av_log(avctx, AV_LOG_DEBUG, " ");

  260.                 }

  261.             }

  262.             av_log(avctx, AV_LOG_DEBUG, "\n");

  263.         }

  264.     }

  265. }