FFmpeg
mpegutils.c
Go to the documentation of this file.
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 mb_width, int mb_height, int mb_stride, int quarter_sample)
106 {
107  if ((avctx->export_side_data & AV_CODEC_EXPORT_DATA_MVS) && mbtype_table && motion_val[0]) {
108  const int shift = 1 + quarter_sample;
109  const int scale = 1 << shift;
110  const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
111  const int mv_stride = (mb_width << mv_sample_log2) +
112  (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
113  int mb_x, mb_y, mbcount = 0;
114 
115  /* size is width * height * 2 * 4 where 2 is for directions and 4 is
116  * for the maximum number of MB (4 MB in case of IS_8x8) */
117  AVMotionVector *mvs = av_malloc_array(mb_width * mb_height, 2 * 4 * sizeof(AVMotionVector));
118  if (!mvs)
119  return;
120 
121  for (mb_y = 0; mb_y < mb_height; mb_y++) {
122  for (mb_x = 0; mb_x < mb_width; mb_x++) {
123  int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];
124  for (direction = 0; direction < 2; direction++) {
125  if (!USES_LIST(mb_type, direction))
126  continue;
127  if (IS_8X8(mb_type)) {
128  for (i = 0; i < 4; i++) {
129  int sx = mb_x * 16 + 4 + 8 * (i & 1);
130  int sy = mb_y * 16 + 4 + 8 * (i >> 1);
131  int xy = (mb_x * 2 + (i & 1) +
132  (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
133  int mx = motion_val[direction][xy][0];
134  int my = motion_val[direction][xy][1];
135  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
136  }
137  } else if (IS_16X8(mb_type)) {
138  for (i = 0; i < 2; i++) {
139  int sx = mb_x * 16 + 8;
140  int sy = mb_y * 16 + 4 + 8 * i;
141  int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
142  int mx = motion_val[direction][xy][0];
143  int my = motion_val[direction][xy][1];
144 
145  if (IS_INTERLACED(mb_type))
146  my *= 2;
147 
148  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
149  }
150  } else if (IS_8X16(mb_type)) {
151  for (i = 0; i < 2; i++) {
152  int sx = mb_x * 16 + 4 + 8 * i;
153  int sy = mb_y * 16 + 8;
154  int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
155  int mx = motion_val[direction][xy][0];
156  int my = motion_val[direction][xy][1];
157 
158  if (IS_INTERLACED(mb_type))
159  my *= 2;
160 
161  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
162  }
163  } else {
164  int sx = mb_x * 16 + 8;
165  int sy = mb_y * 16 + 8;
166  int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
167  int mx = motion_val[direction][xy][0];
168  int my = motion_val[direction][xy][1];
169  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
170  }
171  }
172  }
173  }
174 
175  if (mbcount) {
176  AVFrameSideData *sd;
177 
178  av_log(avctx, AV_LOG_DEBUG, "Adding %d MVs info to frame %d\n", mbcount, avctx->frame_number);
179  sd = av_frame_new_side_data(pict, AV_FRAME_DATA_MOTION_VECTORS, mbcount * sizeof(AVMotionVector));
180  if (!sd) {
181  av_freep(&mvs);
182  return;
183  }
184  memcpy(sd->data, mvs, mbcount * sizeof(AVMotionVector));
185  }
186 
187  av_freep(&mvs);
188  }
189 
190  /* TODO: export all the following to make them accessible for users (and filters) */
191  if (avctx->hwaccel || !mbtype_table)
192  return;
193 
194 
195  if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
196  int x,y;
197 
198  av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
199  av_get_picture_type_char(pict->pict_type));
200  for (y = 0; y < mb_height; y++) {
201  for (x = 0; x < mb_width; x++) {
202  if (avctx->debug & FF_DEBUG_SKIP) {
203  int count = mbskip_table ? mbskip_table[x + y * mb_stride] : 0;
204  if (count > 9)
205  count = 9;
206  av_log(avctx, AV_LOG_DEBUG, "%1d", count);
207  }
208  if (avctx->debug & FF_DEBUG_QP) {
209  av_log(avctx, AV_LOG_DEBUG, "%2d",
210  qscale_table[x + y * mb_stride]);
211  }
212  if (avctx->debug & FF_DEBUG_MB_TYPE) {
213  int mb_type = mbtype_table[x + y * mb_stride];
214  // Type & MV direction
215  if (IS_PCM(mb_type))
216  av_log(avctx, AV_LOG_DEBUG, "P");
217  else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
218  av_log(avctx, AV_LOG_DEBUG, "A");
219  else if (IS_INTRA4x4(mb_type))
220  av_log(avctx, AV_LOG_DEBUG, "i");
221  else if (IS_INTRA16x16(mb_type))
222  av_log(avctx, AV_LOG_DEBUG, "I");
223  else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
224  av_log(avctx, AV_LOG_DEBUG, "d");
225  else if (IS_DIRECT(mb_type))
226  av_log(avctx, AV_LOG_DEBUG, "D");
227  else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
228  av_log(avctx, AV_LOG_DEBUG, "g");
229  else if (IS_GMC(mb_type))
230  av_log(avctx, AV_LOG_DEBUG, "G");
231  else if (IS_SKIP(mb_type))
232  av_log(avctx, AV_LOG_DEBUG, "S");
233  else if (!USES_LIST(mb_type, 1))
234  av_log(avctx, AV_LOG_DEBUG, ">");
235  else if (!USES_LIST(mb_type, 0))
236  av_log(avctx, AV_LOG_DEBUG, "<");
237  else {
238  av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
239  av_log(avctx, AV_LOG_DEBUG, "X");
240  }
241 
242  // segmentation
243  if (IS_8X8(mb_type))
244  av_log(avctx, AV_LOG_DEBUG, "+");
245  else if (IS_16X8(mb_type))
246  av_log(avctx, AV_LOG_DEBUG, "-");
247  else if (IS_8X16(mb_type))
248  av_log(avctx, AV_LOG_DEBUG, "|");
249  else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
250  av_log(avctx, AV_LOG_DEBUG, " ");
251  else
252  av_log(avctx, AV_LOG_DEBUG, "?");
253 
254 
255  if (IS_INTERLACED(mb_type))
256  av_log(avctx, AV_LOG_DEBUG, "=");
257  else
258  av_log(avctx, AV_LOG_DEBUG, " ");
259  }
260  }
261  av_log(avctx, AV_LOG_DEBUG, "\n");
262  }
263  }
264 }
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
IS_INTRA4x4
#define IS_INTRA4x4(a)
Definition: mpegutils.h:74
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1359
IS_8X8
#define IS_8X8(a)
Definition: mpegutils.h:88
IS_GMC
#define IS_GMC(a)
Definition: mpegutils.h:84
IS_ACPRED
#define IS_ACPRED(a)
Definition: mpegutils.h:93
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:605
SLICE_FLAG_CODED_ORDER
#define SLICE_FLAG_CODED_ORDER
draw_horiz_band() is called in coded order instead of display
Definition: avcodec.h:847
AVMotionVector
Definition: motion_vector.h:24
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2660
SLICE_FLAG_ALLOW_FIELD
#define SLICE_FLAG_ALLOW_FIELD
allow draw_horiz_band() with field slices (MPEG-2 field pics)
Definition: avcodec.h:848
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
pixdesc.h
mpegutils.h
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:392
USES_LIST
#define USES_LIST(a, list)
Definition: mpegutils.h:98
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1388
avassert.h
motion_vector.h
IS_16X8
#define IS_16X8(a)
Definition: mpegutils.h:86
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
IS_SKIP
#define IS_SKIP(a)
Definition: mpegutils.h:80
IS_INTRA
#define IS_INTRA(x, y)
AV_CODEC_ID_SVQ3
@ AV_CODEC_ID_SVQ3
Definition: codec_id.h:73
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:393
ff_print_debug_info2
void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table, uint32_t *mbtype_table, int8_t *qscale_table, int16_t(*motion_val[2])[2], int mb_width, int mb_height, int mb_stride, int quarter_sample)
Print debugging info for the given picture.
Definition: mpegutils.c:103
AVCodecContext::slice_flags
int slice_flags
slice flags
Definition: avcodec.h:846
FF_DEBUG_MB_TYPE
#define FF_DEBUG_MB_TYPE
Definition: avcodec.h:1306
src
#define src
Definition: vp8dsp.c:255
IS_INTERLACED
#define IS_INTERLACED(a)
Definition: mpegutils.h:82
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:414
ff_draw_horiz_band
void ff_draw_horiz_band(AVCodecContext *avctx, AVFrame *cur, AVFrame *last, int y, int h, int picture_structure, int first_field, int low_delay)
Draw a horizontal band if supported.
Definition: mpegutils.c:51
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:318
AVFrameSideData::data
uint8_t * data
Definition: frame.h:225
frame.h
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
IS_INTRA16x16
#define IS_INTRA16x16(a)
Definition: mpegutils.h:75
mb
#define mb
Definition: vf_colormatrix.c:101
IS_DIRECT
#define IS_DIRECT(a)
Definition: mpegutils.h:83
IS_16X16
#define IS_16X16(a)
Definition: mpegutils.h:85
AVCodec::id
enum AVCodecID id
Definition: codec.h:216
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:83
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
FF_DEBUG_SKIP
#define FF_DEBUG_SKIP
Definition: avcodec.h:1309
common.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
avcodec.h
FF_DEBUG_QP
#define FF_DEBUG_QP
Definition: avcodec.h:1307
AVCodecContext::draw_horiz_band
void(* draw_horiz_band)(struct AVCodecContext *s, const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], int y, int type, int height)
If non NULL, 'draw_horiz_band' is called by the libavcodec decoder to draw a horizontal band.
Definition: avcodec.h:618
AVCodecContext
main external API structure.
Definition: avcodec.h:383
IS_PCM
#define IS_PCM(a)
Definition: mpegutils.h:76
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
AVCodecContext::export_side_data
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:1984
IS_8X16
#define IS_8X16(a)
Definition: mpegutils.h:87
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1302
shift
static int shift(int a, int b)
Definition: sonic.c:83
desc
const char * desc
Definition: libsvtav1.c:79
AV_CODEC_EXPORT_DATA_MVS
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:342
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1023
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:223
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
add_mb
static int add_mb(AVMotionVector *mb, uint32_t mb_type, int dst_x, int dst_y, int motion_x, int motion_y, int motion_scale, int direction)
Definition: mpegutils.c:32
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AV_FRAME_DATA_MOTION_VECTORS
@ AV_FRAME_DATA_MOTION_VECTORS
Motion vectors exported by some codecs (on demand through the export_mvs flag set in the libavcodec A...
Definition: frame.h:96
h
h
Definition: vp9dsp_template.c:2038
first_field
static int first_field(const struct video_data *s)
Definition: v4l2.c:236
Generated on Wed Aug 24 2022 21:37:48 for FFmpeg by   doxygen 1.8.17