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 *low_delay,
106  int mb_width, int mb_height, int mb_stride, int quarter_sample)
107 {
108  if ((avctx->flags2 & AV_CODEC_FLAG2_EXPORT_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 
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 }
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:39
IS_INTRA4x4
#define IS_INTRA4x4(a)
Definition: mpegutils.h:75
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2729
IS_8X8
#define IS_8X8(a)
Definition: mpegutils.h:89
IS_GMC
#define IS_GMC(a)
Definition: mpegutils.h:85
IS_ACPRED
#define IS_ACPRED(a)
Definition: mpegutils.h:94
COLOR
#define COLOR(x)
SLICE_FLAG_CODED_ORDER
#define SLICE_FLAG_CODED_ORDER
draw_horiz_band() is called in coded order instead of display
Definition: avcodec.h:2044
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
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:2522
SLICE_FLAG_ALLOW_FIELD
#define SLICE_FLAG_ALLOW_FIELD
allow draw_horiz_band() with field slices (MPEG-2 field pics)
Definition: avcodec.h:2045
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
Definition: frame.c:722
mv
static const int8_t mv[256][2]
Definition: 4xm.c:77
count
void INT64 INT64 count
Definition: avisynth_c.h:767
AVFrame::opaque
void * opaque
for some private data of the user
Definition: frame.h:423
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
av_frame_make_writable
int av_frame_make_writable(AVFrame *frame)
Ensure that the frame data is writable, avoiding data copy if possible.
Definition: frame.c:611
pixdesc.h
AVCodecContext::debug_mv
int debug_mv
debug motion vectors
Definition: avcodec.h:3193
mpegutils.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:1574
AVFrame::qscale_table
attribute_deprecated int8_t * qscale_table
QP table.
Definition: frame.h:617
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 *low_delay, int mb_width, int mb_height, int mb_stride, int quarter_sample)
Print debugging info for the given picture.
Definition: mpegutils.c:103
USES_LIST
#define USES_LIST(a, list)
Definition: mpegutils.h:99
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2550
src
#define src
Definition: vp8dsp.c:254
avassert.h
motion_vector.h
IS_16X8
#define IS_16X8(a)
Definition: mpegutils.h:87
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
IS_SKIP
#define IS_SKIP(a)
Definition: mpegutils.h:81
IS_INTRA
#define IS_INTRA(x, y)
AV_CODEC_ID_SVQ3
@ AV_CODEC_ID_SVQ3
Definition: avcodec.h:241
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: avcodec.h:245
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:1575
int32_t
int32_t
Definition: audio_convert.c:194
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::slice_flags
int slice_flags
slice flags
Definition: avcodec.h:2043
FF_DEBUG_MB_TYPE
#define FF_DEBUG_MB_TYPE
Definition: avcodec.h:2654
IS_INTERLACED
#define IS_INTERLACED(a)
Definition: mpegutils.h:83
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
desc
const char * desc
Definition: nvenc.c:68
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1652
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
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:296
AVFrameSideData::data
uint8_t * data
Definition: frame.h:203
frame.h
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
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:76
mb
#define mb
Definition: vf_colormatrix.c:101
IS_DIRECT
#define IS_DIRECT(a)
Definition: mpegutils.h:84
IS_16X16
#define IS_16X16(a)
Definition: mpegutils.h:86
AVCodec::id
enum AVCodecID id
Definition: avcodec.h:3495
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:88
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:259
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
FF_DEBUG_SKIP
#define FF_DEBUG_SKIP
Definition: avcodec.h:2663
common.h
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodecContext::height
int height
Definition: avcodec.h:1738
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
avcodec.h
ret
ret
Definition: filter_design.txt:187
FF_DEBUG_QP
#define FF_DEBUG_QP
Definition: avcodec.h:2655
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:1800
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
IS_PCM
#define IS_PCM(a)
Definition: mpegutils.h:77
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
IS_8X16
#define IS_8X16(a)
Definition: mpegutils.h:88
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:2650
shift
static int shift(int a, int b)
Definition: sonic.c:82
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2256
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:201
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
AV_CODEC_FLAG2_EXPORT_MVS
#define AV_CODEC_FLAG2_EXPORT_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:955
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
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
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:234
Generated on Wed Aug 24 2022 21:26:52 for FFmpeg by   doxygen 1.8.17