git.sesse.net Git - ffmpeg/blob - libavcodec/mpegutils.c

   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 }