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/bprint.h"
24 #include "libavutil/common.h"
25 #include "libavutil/emms.h"
26 #include "libavutil/frame.h"
27 #include "libavutil/mem.h"
28 #include "libavutil/pixdesc.h"
29 #include "libavutil/motion_vector.h"
30 #include "libavutil/avassert.h"
31 
32 #include "avcodec.h"
33 #include "mpegutils.h"
34 
35 static int add_mb(AVMotionVector *mb, uint32_t mb_type,
36  int dst_x, int dst_y,
37  int motion_x, int motion_y, int motion_scale,
38  int direction)
39 {
40  mb->w = IS_8X8(mb_type) || IS_8X16(mb_type) ? 8 : 16;
41  mb->h = IS_8X8(mb_type) || IS_16X8(mb_type) ? 8 : 16;
42  mb->motion_x = motion_x;
43  mb->motion_y = motion_y;
44  mb->motion_scale = motion_scale;
45  mb->dst_x = dst_x;
46  mb->dst_y = dst_y;
47  mb->src_x = dst_x + motion_x / motion_scale;
48  mb->src_y = dst_y + motion_y / motion_scale;
49  mb->source = direction ? 1 : -1;
50  mb->flags = 0; // XXX: does mb_type contain extra information that could be exported here?
51  return 1;
52 }
53 
54 void ff_draw_horiz_band(AVCodecContext *avctx,
55  const AVFrame *cur, const AVFrame *last,
56  int y, int h, int picture_structure,
57  int first_field, int low_delay)
58 {
59  const int field_pic = picture_structure != PICT_FRAME;
60  const AVPixFmtDescriptor *desc;
61  const AVFrame *src;
62  int offset[AV_NUM_DATA_POINTERS];
63 
64  if (!avctx->draw_horiz_band)
65  return;
66 
67  if (field_pic) {
68  h <<= 1;
69  y <<= 1;
70  }
71 
72  h = FFMIN(h, avctx->height - y);
73 
74  if (field_pic && first_field &&
75  !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))
76  return;
77 
78  if (cur->pict_type == AV_PICTURE_TYPE_B || low_delay ||
79  (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
80  src = cur;
81  else if (last)
82  src = last;
83  else
84  return;
85 
86  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
87 
88  offset[0] = y * src->linesize[0];
89  offset[1] =
90  offset[2] = (y >> desc->log2_chroma_h) * src->linesize[1];
91  for (int i = 3; i < AV_NUM_DATA_POINTERS; i++)
92  offset[i] = 0;
93 
94  emms_c();
95 
96  avctx->draw_horiz_band(avctx, src, offset,
97  y, picture_structure, h);
98 }
99 
100 #define HAS_MV_EXT(mb_type, flags, dir) ((mb_type) & flags[(dir)])
101 
102 static char get_type_mv_char(int mb_type, const int mb_type_mv_flags[2])
103 {
104  // Type & MV direction
105  if (IS_PCM(mb_type))
106  return 'P';
107  else if (IS_ACPRED(mb_type))
108  return 'A';
109  else if (IS_INTRA4x4(mb_type))
110  return 'i';
111  else if (IS_INTRA16x16(mb_type))
112  return 'I';
113  else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
114  return 'd';
115  else if (IS_DIRECT(mb_type))
116  return 'D';
117  else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
118  return 'g';
119  else if (IS_GMC(mb_type))
120  return 'G';
121  else if (IS_SKIP(mb_type))
122  return 'S';
123  else if (!HAS_MV_EXT(mb_type, 1, mb_type_mv_flags))
124  return '>';
125  else if (!HAS_MV_EXT(mb_type, 0, mb_type_mv_flags))
126  return '<';
127  else {
128  av_assert2(HAS_MV_EXT(mb_type, 0, mb_type_mv_flags) && HAS_MV_EXT(mb_type, 1, mb_type_mv_flags));
129  return 'X';
130  }
131 }
132 
133 static char get_segmentation_char(int mb_type)
134 {
135  if (IS_8X8(mb_type))
136  return '+';
137  else if (IS_16X8(mb_type))
138  return '-';
139  else if (IS_8X16(mb_type))
140  return '|';
141  else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
142  return ' ';
143 
144  return '?';
145 }
146 
147 static char get_interlacement_char(int mb_type)
148 {
149  if (IS_INTERLACED(mb_type))
150  return '=';
151  else
152  return ' ';
153 }
154 
155 void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict,
156  const uint32_t *mbtype_table,
157  const int8_t *qscale_table, int16_t (*const motion_val[2])[2],
158  int mb_width, int mb_height, int mb_stride, int quarter_sample)
159 {
160  const int is_h264 = avctx->codec_id == AV_CODEC_ID_H264;
161  const int mb_type_mv_flags[2] = { is_h264 ? MB_TYPE_L0 : MB_TYPE_FORWARD_MV,
162  is_h264 ? MB_TYPE_L1 : MB_TYPE_BACKWARD_MV };
163 
164  if ((avctx->export_side_data & AV_CODEC_EXPORT_DATA_MVS) && mbtype_table && motion_val[0]) {
165  const int shift = 1 + quarter_sample;
166  const int scale = 1 << shift;
167  const int mv_sample_log2 = is_h264 ? 2 : 1;
168  const int mv_stride = (mb_width << mv_sample_log2) + !is_h264;
169  int mb_x, mb_y, mbcount = 0;
170 
171  /* size is width * height * 2 * 4 where 2 is for directions and 4 is
172  * for the maximum number of MB (4 MB in case of IS_8x8) */
173  AVMotionVector *mvs = av_malloc_array(mb_width * mb_height, 2 * 4 * sizeof(AVMotionVector));
174  if (!mvs)
175  return;
176 
177  for (mb_y = 0; mb_y < mb_height; mb_y++) {
178  for (mb_x = 0; mb_x < mb_width; mb_x++) {
179  int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];
180  for (direction = 0; direction < 2; direction++) {
181  if (!HAS_MV_EXT(mb_type, direction, mb_type_mv_flags))
182  continue;
183  if (IS_8X8(mb_type)) {
184  for (i = 0; i < 4; i++) {
185  int sx = mb_x * 16 + 4 + 8 * (i & 1);
186  int sy = mb_y * 16 + 4 + 8 * (i >> 1);
187  int xy = (mb_x * 2 + (i & 1) +
188  (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
189  int mx = motion_val[direction][xy][0];
190  int my = motion_val[direction][xy][1];
191  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
192  }
193  } else if (IS_16X8(mb_type)) {
194  for (i = 0; i < 2; i++) {
195  int sx = mb_x * 16 + 8;
196  int sy = mb_y * 16 + 4 + 8 * i;
197  int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
198  int mx = motion_val[direction][xy][0];
199  int my = motion_val[direction][xy][1];
200 
201  if (IS_INTERLACED(mb_type))
202  my *= 2;
203 
204  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
205  }
206  } else if (IS_8X16(mb_type)) {
207  for (i = 0; i < 2; i++) {
208  int sx = mb_x * 16 + 4 + 8 * i;
209  int sy = mb_y * 16 + 8;
210  int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
211  int mx = motion_val[direction][xy][0];
212  int my = motion_val[direction][xy][1];
213 
214  if (IS_INTERLACED(mb_type))
215  my *= 2;
216 
217  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
218  }
219  } else {
220  int sx = mb_x * 16 + 8;
221  int sy = mb_y * 16 + 8;
222  int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
223  int mx = motion_val[direction][xy][0];
224  int my = motion_val[direction][xy][1];
225  mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, scale, direction);
226  }
227  }
228  }
229  }
230 
231  if (mbcount) {
232  AVFrameSideData *sd;
233 
234  av_log(avctx, AV_LOG_DEBUG, "Adding %d MVs info to frame %"PRId64"\n", mbcount, avctx->frame_num);
235  sd = av_frame_new_side_data(pict, AV_FRAME_DATA_MOTION_VECTORS, mbcount * sizeof(AVMotionVector));
236  if (!sd) {
237  av_freep(&mvs);
238  return;
239  }
240  memcpy(sd->data, mvs, mbcount * sizeof(AVMotionVector));
241  }
242 
243  av_freep(&mvs);
244  }
245 
246  /* TODO: export all the following to make them accessible for users (and filters) */
247  if (avctx->hwaccel || !mbtype_table)
248  return;
249 
250 
251  if (avctx->debug & (FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
252  int x,y;
253  AVBPrint buf;
254  int n;
255  int margin_left;
256  int x_step;
257 
258  av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
259  av_get_picture_type_char(pict->pict_type));
260 
261  margin_left = 2;
262  n = mb_width << 4;
263  while ((n /= 10))
264  margin_left++;
265 
266  av_bprint_init(&buf, 1, AV_BPRINT_SIZE_UNLIMITED);
267  av_bprint_chars(&buf, ' ', margin_left);
268 
269  n = 0;
270  if (avctx->debug & FF_DEBUG_QP)
271  n += 2;
272  if (avctx->debug & FF_DEBUG_MB_TYPE)
273  n += 3;
274  x_step = (mb_width * 16 > 999) ? 8 : 4;
275  for (x = 0; x < mb_width; x += x_step)
276  av_bprintf(&buf, "%-*d", n * x_step, x << 4);
277 
278  av_log(avctx, AV_LOG_DEBUG, "%s\n", buf.str);
279 
280  for (y = 0; y < mb_height; y++) {
281  av_bprint_clear(&buf);
282  for (x = 0; x < mb_width; x++) {
283  if (x == 0)
284  av_bprintf(&buf, "%*d ", margin_left - 1, y << 4);
285  if (avctx->debug & FF_DEBUG_QP) {
286  av_bprintf(&buf, "%2d", qscale_table[x + y * mb_stride]);
287  }
288  if (avctx->debug & FF_DEBUG_MB_TYPE) {
289  int mb_type = mbtype_table[x + y * mb_stride];
290 
291  av_bprintf(&buf, "%c%c%c",
292  get_type_mv_char(mb_type, mb_type_mv_flags),
293  get_segmentation_char(mb_type),
294  get_interlacement_char(mb_type));
295  }
296  }
297 
298  av_log(avctx, AV_LOG_DEBUG, "%s\n", buf.str);
299  }
300  av_bprint_finalize(&buf, NULL);
301  }
302 }
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
IS_INTRA4x4
#define IS_INTRA4x4(a)
Definition: mpegutils.h:70
ff_draw_horiz_band
void ff_draw_horiz_band(AVCodecContext *avctx, const AVFrame *cur, const AVFrame *last, int y, int h, int picture_structure, int first_field, int low_delay)
Draw a horizontal band if supported.
Definition: mpegutils.c:54
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1437
IS_8X8
#define IS_8X8(a)
Definition: mpegutils.h:84
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:58
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
IS_GMC
#define IS_GMC(a)
Definition: mpegutils.h:80
IS_ACPRED
#define IS_ACPRED(a)
Definition: mpegutils.h:85
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
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:811
SLICE_FLAG_CODED_ORDER
#define SLICE_FLAG_CODED_ORDER
draw_horiz_band() is called in coded order instead of display
Definition: avcodec.h:737
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:3170
SLICE_FLAG_ALLOW_FIELD
#define SLICE_FLAG_ALLOW_FIELD
allow draw_horiz_band() with field slices (MPEG-2 field pics)
Definition: avcodec.h:738
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
pixdesc.h
get_type_mv_char
static char get_type_mv_char(int mb_type, const int mb_type_mv_flags[2])
Definition: mpegutils.c:102
MB_TYPE_L1
#define MB_TYPE_L1
Definition: mpegutils.h:59
mpegutils.h
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition: dsp.h:53
HAS_MV_EXT
#define HAS_MV_EXT(mb_type, flags, dir)
Definition: mpegutils.c:100
avassert.h
emms_c
#define emms_c()
Definition: emms.h:63
motion_vector.h
IS_16X8
#define IS_16X8(a)
Definition: mpegutils.h:82
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
IS_SKIP
#define IS_SKIP(a)
Definition: mpegutils.h:76
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition: dsp.h:53
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::slice_flags
int slice_flags
slice flags
Definition: avcodec.h:736
FF_DEBUG_MB_TYPE
#define FF_DEBUG_MB_TYPE
Definition: avcodec.h:1410
IS_INTERLACED
#define IS_INTERLACED(a)
Definition: mpegutils.h:78
IS_INTRA
#define IS_INTRA(x, y)
ff_print_debug_info2
void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, const uint32_t *mbtype_table, const int8_t *qscale_table, int16_t(*const 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:155
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:491
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
shift
static int shift(int a, int b)
Definition: bonk.c:261
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:390
get_interlacement_char
static char get_interlacement_char(int mb_type)
Definition: mpegutils.c:147
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
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:71
mb
#define mb
Definition: vf_colormatrix.c:99
IS_DIRECT
#define IS_DIRECT(a)
Definition: mpegutils.h:79
IS_16X16
#define IS_16X16(a)
Definition: mpegutils.h:81
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:40
emms.h
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
bprint.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
common.h
MB_TYPE_BACKWARD_MV
#define MB_TYPE_BACKWARD_MV
Definition: mpegutils.h:51
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodecContext::height
int height
Definition: avcodec.h:624
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
avcodec.h
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2041
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
FF_DEBUG_QP
#define FF_DEBUG_QP
Definition: avcodec.h:1411
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:764
AVCodecContext
main external API structure.
Definition: avcodec.h:451
IS_PCM
#define IS_PCM(a)
Definition: mpegutils.h:72
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:281
av_bprint_clear
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
Definition: bprint.c:232
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:1937
IS_8X16
#define IS_8X16(a)
Definition: mpegutils.h:83
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1406
desc
const char * desc
Definition: libsvtav1.c:79
mem.h
AV_CODEC_EXPORT_DATA_MVS
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:406
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:35
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
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:97
h
h
Definition: vp9dsp_template.c:2070
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:145
get_segmentation_char
static char get_segmentation_char(int mb_type)
Definition: mpegutils.c:133
first_field
static int first_field(const struct video_data *s)
Definition: v4l2.c:256
MB_TYPE_FORWARD_MV
#define MB_TYPE_FORWARD_MV
Definition: mpegutils.h:50
src
#define src
Definition: vp8dsp.c:248
Generated on Mon Dec 2 2024 19:22:00 for FFmpeg by   doxygen 1.8.17