FFmpeg
mpegpicture.c
Go to the documentation of this file.
1 /*
2  * Mpeg video formats-related picture management 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/avassert.h"
24 #include "libavutil/common.h"
25 #include "libavutil/pixdesc.h"
26 #include "libavutil/imgutils.h"
27 
28 #include "avcodec.h"
29 #include "motion_est.h"
30 #include "mpegpicture.h"
31 #include "mpegutils.h"
32 
33 static int make_tables_writable(Picture *pic)
34 {
35  int ret, i;
36 #define MAKE_WRITABLE(table) \
37 do {\
38  if (pic->table &&\
39  (ret = av_buffer_make_writable(&pic->table)) < 0)\
40  return ret;\
41 } while (0)
42 
43  MAKE_WRITABLE(mb_var_buf);
44  MAKE_WRITABLE(mc_mb_var_buf);
45  MAKE_WRITABLE(mb_mean_buf);
46  MAKE_WRITABLE(mbskip_table_buf);
47  MAKE_WRITABLE(qscale_table_buf);
48  MAKE_WRITABLE(mb_type_buf);
49 
50  for (i = 0; i < 2; i++) {
51  MAKE_WRITABLE(motion_val_buf[i]);
52  MAKE_WRITABLE(ref_index_buf[i]);
53  }
54 
55  return 0;
56 }
57 
59  ScratchpadContext *sc, int linesize)
60 {
61 # define EMU_EDGE_HEIGHT (4 * 70)
62  int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
63 
64  if (avctx->hwaccel)
65  return 0;
66 
67  if (linesize < 24) {
68  av_log(avctx, AV_LOG_ERROR, "Image too small, temporary buffers cannot function\n");
69  return AVERROR_PATCHWELCOME;
70  }
71 
72  if (av_image_check_size2(alloc_size, EMU_EDGE_HEIGHT, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)
73  return AVERROR(ENOMEM);
74 
75  // edge emu needs blocksize + filter length - 1
76  // (= 17x17 for halfpel / 21x21 for H.264)
77  // VC-1 computes luma and chroma simultaneously and needs 19X19 + 9x9
78  // at uvlinesize. It supports only YUV420 so 24x24 is enough
79  // linesize * interlaced * MBsize
80  // we also use this buffer for encoding in encode_mb_internal() needig an additional 32 lines
81  if (!FF_ALLOCZ_TYPED_ARRAY(sc->edge_emu_buffer, alloc_size * EMU_EDGE_HEIGHT) ||
82  !FF_ALLOCZ_TYPED_ARRAY(me->scratchpad, alloc_size * 4 * 16 * 2)) {
84  return AVERROR(ENOMEM);
85  }
86 
87  me->temp = me->scratchpad;
88  sc->rd_scratchpad = me->scratchpad;
89  sc->b_scratchpad = me->scratchpad;
90  sc->obmc_scratchpad = me->scratchpad + 16;
91 
92  return 0;
93 }
94 
95 /**
96  * Allocate a frame buffer
97  */
98 static int alloc_frame_buffer(AVCodecContext *avctx, Picture *pic,
100  int chroma_x_shift, int chroma_y_shift,
101  int linesize, int uvlinesize)
102 {
103  int edges_needed = av_codec_is_encoder(avctx->codec);
104  int r, ret;
105 
106  pic->tf.f = pic->f;
107  if (avctx->codec_id != AV_CODEC_ID_WMV3IMAGE &&
108  avctx->codec_id != AV_CODEC_ID_VC1IMAGE &&
109  avctx->codec_id != AV_CODEC_ID_MSS2) {
110  if (edges_needed) {
111  pic->f->width = avctx->width + 2 * EDGE_WIDTH;
112  pic->f->height = avctx->height + 2 * EDGE_WIDTH;
113  }
114 
115  r = ff_thread_get_buffer(avctx, &pic->tf,
116  pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
117  } else {
118  pic->f->width = avctx->width;
119  pic->f->height = avctx->height;
120  pic->f->format = avctx->pix_fmt;
121  r = avcodec_default_get_buffer2(avctx, pic->f, 0);
122  }
123 
124  if (r < 0 || !pic->f->buf[0]) {
125  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n",
126  r, pic->f->data[0]);
127  return -1;
128  }
129 
130  if (edges_needed) {
131  int i;
132  for (i = 0; pic->f->data[i]; i++) {
133  int offset = (EDGE_WIDTH >> (i ? chroma_y_shift : 0)) *
134  pic->f->linesize[i] +
135  (EDGE_WIDTH >> (i ? chroma_x_shift : 0));
136  pic->f->data[i] += offset;
137  }
138  pic->f->width = avctx->width;
139  pic->f->height = avctx->height;
140  }
141 
142  if (avctx->hwaccel) {
143  assert(!pic->hwaccel_picture_private);
144  if (avctx->hwaccel->frame_priv_data_size) {
146  if (!pic->hwaccel_priv_buf) {
147  av_log(avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
148  return -1;
149  }
151  }
152  }
153 
154  if ((linesize && linesize != pic->f->linesize[0]) ||
155  (uvlinesize && uvlinesize != pic->f->linesize[1])) {
156  av_log(avctx, AV_LOG_ERROR,
157  "get_buffer() failed (stride changed: linesize=%d/%d uvlinesize=%d/%d)\n",
158  linesize, pic->f->linesize[0],
159  uvlinesize, pic->f->linesize[1]);
160  ff_mpeg_unref_picture(avctx, pic);
161  return -1;
162  }
163 
164  if (av_pix_fmt_count_planes(pic->f->format) > 2 &&
165  pic->f->linesize[1] != pic->f->linesize[2]) {
166  av_log(avctx, AV_LOG_ERROR,
167  "get_buffer() failed (uv stride mismatch)\n");
168  ff_mpeg_unref_picture(avctx, pic);
169  return -1;
170  }
171 
172  if (!sc->edge_emu_buffer &&
173  (ret = ff_mpeg_framesize_alloc(avctx, me, sc,
174  pic->f->linesize[0])) < 0) {
175  av_log(avctx, AV_LOG_ERROR,
176  "get_buffer() failed to allocate context scratch buffers.\n");
177  ff_mpeg_unref_picture(avctx, pic);
178  return ret;
179  }
180 
181  return 0;
182 }
183 
184 static int alloc_picture_tables(AVCodecContext *avctx, Picture *pic, int encoding, int out_format,
185  int mb_stride, int mb_width, int mb_height, int b8_stride)
186 {
187  const int big_mb_num = mb_stride * (mb_height + 1) + 1;
188  const int mb_array_size = mb_stride * mb_height;
189  const int b8_array_size = b8_stride * mb_height * 2;
190  int i;
191 
192 
193  pic->mbskip_table_buf = av_buffer_allocz(mb_array_size + 2);
194  pic->qscale_table_buf = av_buffer_allocz(big_mb_num + mb_stride);
195  pic->mb_type_buf = av_buffer_allocz((big_mb_num + mb_stride) *
196  sizeof(uint32_t));
197  if (!pic->mbskip_table_buf || !pic->qscale_table_buf || !pic->mb_type_buf)
198  return AVERROR(ENOMEM);
199 
200  if (encoding) {
201  pic->mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
202  pic->mc_mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
203  pic->mb_mean_buf = av_buffer_allocz(mb_array_size);
204  if (!pic->mb_var_buf || !pic->mc_mb_var_buf || !pic->mb_mean_buf)
205  return AVERROR(ENOMEM);
206  }
207 
208  if (out_format == FMT_H263 || encoding ||
210  int mv_size = 2 * (b8_array_size + 4) * sizeof(int16_t);
211  int ref_index_size = 4 * mb_array_size;
212 
213  for (i = 0; mv_size && i < 2; i++) {
214  pic->motion_val_buf[i] = av_buffer_allocz(mv_size);
215  pic->ref_index_buf[i] = av_buffer_allocz(ref_index_size);
216  if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
217  return AVERROR(ENOMEM);
218  }
219  }
220 
221  pic->alloc_mb_width = mb_width;
222  pic->alloc_mb_height = mb_height;
223  pic->alloc_mb_stride = mb_stride;
224 
225  return 0;
226 }
227 
228 /**
229  * Allocate a Picture.
230  * The pixels are allocated/set by calling get_buffer() if shared = 0
231  */
233  ScratchpadContext *sc, int shared, int encoding,
234  int chroma_x_shift, int chroma_y_shift, int out_format,
235  int mb_stride, int mb_width, int mb_height, int b8_stride,
236  ptrdiff_t *linesize, ptrdiff_t *uvlinesize)
237 {
238  int i, ret;
239 
240  if (pic->qscale_table_buf)
241  if ( pic->alloc_mb_width != mb_width
242  || pic->alloc_mb_height != mb_height)
244 
245  if (shared) {
246  av_assert0(pic->f->data[0]);
247  pic->shared = 1;
248  } else {
249  av_assert0(!pic->f->buf[0]);
250  if (alloc_frame_buffer(avctx, pic, me, sc,
251  chroma_x_shift, chroma_y_shift,
252  *linesize, *uvlinesize) < 0)
253  return -1;
254 
255  *linesize = pic->f->linesize[0];
256  *uvlinesize = pic->f->linesize[1];
257  }
258 
259  if (!pic->qscale_table_buf)
260  ret = alloc_picture_tables(avctx, pic, encoding, out_format,
261  mb_stride, mb_width, mb_height, b8_stride);
262  else
263  ret = make_tables_writable(pic);
264  if (ret < 0)
265  goto fail;
266 
267  if (encoding) {
268  pic->mb_var = (uint16_t*)pic->mb_var_buf->data;
269  pic->mc_mb_var = (uint16_t*)pic->mc_mb_var_buf->data;
270  pic->mb_mean = pic->mb_mean_buf->data;
271  }
272 
273  pic->mbskip_table = pic->mbskip_table_buf->data;
274  pic->qscale_table = pic->qscale_table_buf->data + 2 * mb_stride + 1;
275  pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * mb_stride + 1;
276 
277  if (pic->motion_val_buf[0]) {
278  for (i = 0; i < 2; i++) {
279  pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
280  pic->ref_index[i] = pic->ref_index_buf[i]->data;
281  }
282  }
283 
284  return 0;
285 fail:
286  av_log(avctx, AV_LOG_ERROR, "Error allocating a picture.\n");
287  ff_mpeg_unref_picture(avctx, pic);
289  return AVERROR(ENOMEM);
290 }
291 
292 /**
293  * Deallocate a picture.
294  */
296 {
297  int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean);
298 
299  pic->tf.f = pic->f;
300  /* WM Image / Screen codecs allocate internal buffers with different
301  * dimensions / colorspaces; ignore user-defined callbacks for these. */
302  if (avctx->codec_id != AV_CODEC_ID_WMV3IMAGE &&
303  avctx->codec_id != AV_CODEC_ID_VC1IMAGE &&
304  avctx->codec_id != AV_CODEC_ID_MSS2)
305  ff_thread_release_buffer(avctx, &pic->tf);
306  else if (pic->f)
307  av_frame_unref(pic->f);
308 
310 
311  if (pic->needs_realloc)
313 
314  memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
315 }
316 
318 {
319  int i, ret;
320 
321  ret = av_buffer_replace(&dst->mb_var_buf, src->mb_var_buf);
322  ret |= av_buffer_replace(&dst->mc_mb_var_buf, src->mc_mb_var_buf);
323  ret |= av_buffer_replace(&dst->mb_mean_buf, src->mb_mean_buf);
324  ret |= av_buffer_replace(&dst->mbskip_table_buf, src->mbskip_table_buf);
325  ret |= av_buffer_replace(&dst->qscale_table_buf, src->qscale_table_buf);
326  ret |= av_buffer_replace(&dst->mb_type_buf, src->mb_type_buf);
327  for (i = 0; i < 2; i++) {
328  ret |= av_buffer_replace(&dst->motion_val_buf[i], src->motion_val_buf[i]);
329  ret |= av_buffer_replace(&dst->ref_index_buf[i], src->ref_index_buf[i]);
330  }
331 
332  if (ret < 0) {
334  return ret;
335  }
336 
337  dst->mb_var = src->mb_var;
338  dst->mc_mb_var = src->mc_mb_var;
339  dst->mb_mean = src->mb_mean;
340  dst->mbskip_table = src->mbskip_table;
341  dst->qscale_table = src->qscale_table;
342  dst->mb_type = src->mb_type;
343  for (i = 0; i < 2; i++) {
344  dst->motion_val[i] = src->motion_val[i];
345  dst->ref_index[i] = src->ref_index[i];
346  }
347 
348  dst->alloc_mb_width = src->alloc_mb_width;
349  dst->alloc_mb_height = src->alloc_mb_height;
350  dst->alloc_mb_stride = src->alloc_mb_stride;
351 
352  return 0;
353 }
354 
356 {
357  int ret;
358 
359  av_assert0(!dst->f->buf[0]);
360  av_assert0(src->f->buf[0]);
361 
362  src->tf.f = src->f;
363  dst->tf.f = dst->f;
364  ret = ff_thread_ref_frame(&dst->tf, &src->tf);
365  if (ret < 0)
366  goto fail;
367 
369  if (ret < 0)
370  goto fail;
371 
372  if (src->hwaccel_picture_private) {
373  dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
374  if (!dst->hwaccel_priv_buf) {
375  ret = AVERROR(ENOMEM);
376  goto fail;
377  }
379  }
380 
381  dst->field_picture = src->field_picture;
382  dst->mb_var_sum = src->mb_var_sum;
383  dst->mc_mb_var_sum = src->mc_mb_var_sum;
384  dst->b_frame_score = src->b_frame_score;
385  dst->needs_realloc = src->needs_realloc;
386  dst->reference = src->reference;
387  dst->shared = src->shared;
388 
389  memcpy(dst->encoding_error, src->encoding_error,
390  sizeof(dst->encoding_error));
391 
392  return 0;
393 fail:
394  ff_mpeg_unref_picture(avctx, dst);
395  return ret;
396 }
397 
398 static inline int pic_is_unused(Picture *pic)
399 {
400  if (!pic->f->buf[0])
401  return 1;
402  if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
403  return 1;
404  return 0;
405 }
406 
407 static int find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
408 {
409  int i;
410 
411  if (shared) {
412  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
413  if (!picture[i].f->buf[0])
414  return i;
415  }
416  } else {
417  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
418  if (pic_is_unused(&picture[i]))
419  return i;
420  }
421  }
422 
423  av_log(avctx, AV_LOG_FATAL,
424  "Internal error, picture buffer overflow\n");
425  /* We could return -1, but the codec would crash trying to draw into a
426  * non-existing frame anyway. This is safer than waiting for a random crash.
427  * Also the return of this is never useful, an encoder must only allocate
428  * as much as allowed in the specification. This has no relationship to how
429  * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
430  * enough for such valid streams).
431  * Plus, a decoder has to check stream validity and remove frames if too
432  * many reference frames are around. Waiting for "OOM" is not correct at
433  * all. Similarly, missing reference frames have to be replaced by
434  * interpolated/MC frames, anything else is a bug in the codec ...
435  */
436  abort();
437  return -1;
438 }
439 
440 int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
441 {
442  int ret = find_unused_picture(avctx, picture, shared);
443 
444  if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
445  if (picture[ret].needs_realloc) {
446  picture[ret].needs_realloc = 0;
447  ff_free_picture_tables(&picture[ret]);
448  ff_mpeg_unref_picture(avctx, &picture[ret]);
449  }
450  }
451  return ret;
452 }
453 
455 {
456  int i;
457 
458  pic->alloc_mb_width =
459  pic->alloc_mb_height = 0;
460 
467 
468  for (i = 0; i < 2; i++) {
471  }
472 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:98
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1359
Picture::mb_var_buf
AVBufferRef * mb_var_buf
Definition: mpegpicture.h:64
Picture::ref_index_buf
AVBufferRef * ref_index_buf[2]
Definition: mpegpicture.h:61
EMU_EDGE_HEIGHT
#define EMU_EDGE_HEIGHT
ScratchpadContext::obmc_scratchpad
uint8_t * obmc_scratchpad
Definition: mpegpicture.h:38
ff_mpeg_framesize_alloc
int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, ScratchpadContext *sc, int linesize)
Definition: mpegpicture.c:58
r
const char * r
Definition: vf_curves.c:116
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:878
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
ScratchpadContext::rd_scratchpad
uint8_t * rd_scratchpad
scratchpad for rate distortion mb decision
Definition: mpegpicture.h:37
MotionEstContext
Motion estimation context.
Definition: motion_est.h:47
Picture::alloc_mb_width
int alloc_mb_width
mb_width used to allocate tables
Definition: mpegpicture.h:70
Picture::field_picture
int field_picture
whether or not the picture was encoded in separate fields
Definition: mpegpicture.h:80
pixdesc.h
AVFrame::width
int width
Definition: frame.h:361
ff_free_picture_tables
void ff_free_picture_tables(Picture *pic)
Definition: mpegpicture.c:454
Picture::ref_index
int8_t * ref_index[2]
Definition: mpegpicture.h:62
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
Picture
Picture.
Definition: mpegpicture.h:45
Picture::mb_mean
uint8_t * mb_mean
Table for MB luminance.
Definition: mpegpicture.h:75
mpegutils.h
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:477
make_tables_writable
static int make_tables_writable(Picture *pic)
Definition: mpegpicture.c:33
ThreadFrame::f
AVFrame * f
Definition: thread.h:35
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
ScratchpadContext
Definition: mpegpicture.h:35
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2580
Picture::needs_realloc
int needs_realloc
Picture needs to be reallocated (eg due to a frame size change)
Definition: mpegpicture.h:86
alloc_picture_tables
static int alloc_picture_tables(AVCodecContext *avctx, Picture *pic, int encoding, int out_format, int mb_stride, int mb_width, int mb_height, int b8_stride)
Definition: mpegpicture.c:184
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:392
fail
#define fail()
Definition: checkasm.h:127
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
Picture::mbskip_table
uint8_t * mbskip_table
Definition: mpegpicture.h:59
motion_est.h
MAX_PICTURE_COUNT
#define MAX_PICTURE_COUNT
Definition: mpegpicture.h:32
av_image_check_size2
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:289
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
Picture::b_frame_score
int b_frame_score
Definition: mpegpicture.h:85
ff_mpeg_unref_picture
void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
Deallocate a picture.
Definition: mpegpicture.c:295
Picture::hwaccel_priv_buf
AVBufferRef * hwaccel_priv_buf
Definition: mpegpicture.h:77
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:361
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1886
AV_CODEC_ID_VC1IMAGE
@ AV_CODEC_ID_VC1IMAGE
Definition: codec_id.h:202
f
#define f(width, name)
Definition: cbs_vp9.c:255
Picture::encoding_error
uint64_t encoding_error[AV_NUM_DATA_POINTERS]
Definition: mpegpicture.h:91
Picture::hwaccel_picture_private
void * hwaccel_picture_private
Hardware accelerator private data.
Definition: mpegpicture.h:78
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:393
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
if
if(ret)
Definition: filter_design.txt:179
Picture::reference
int reference
Definition: mpegpicture.h:88
Picture::mb_type_buf
AVBufferRef * mb_type_buf
Definition: mpegpicture.h:55
ff_find_unused_picture
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:440
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
me
#define me
Definition: vf_colormatrix.c:104
EDGE_WIDTH
#define EDGE_WIDTH
Definition: mpegpicture.h:33
Picture::mb_mean_buf
AVBufferRef * mb_mean_buf
Definition: mpegpicture.h:74
Picture::motion_val_buf
AVBufferRef * motion_val_buf[2]
Definition: mpegpicture.h:52
Picture::tf
ThreadFrame tf
Definition: mpegpicture.h:47
src
#define src
Definition: vp8dsp.c:255
Picture::mc_mb_var
uint16_t * mc_mb_var
Table for motion compensated MB variances.
Definition: mpegpicture.h:68
ff_alloc_picture
int ff_alloc_picture(AVCodecContext *avctx, Picture *pic, MotionEstContext *me, ScratchpadContext *sc, int shared, int encoding, int chroma_x_shift, int chroma_y_shift, int out_format, int mb_stride, int mb_width, int mb_height, int b8_stride, ptrdiff_t *linesize, ptrdiff_t *uvlinesize)
Allocate a Picture.
Definition: mpegpicture.c:232
alloc_frame_buffer
static int alloc_frame_buffer(AVCodecContext *avctx, Picture *pic, MotionEstContext *me, ScratchpadContext *sc, int chroma_x_shift, int chroma_y_shift, int linesize, int uvlinesize)
Allocate a frame buffer.
Definition: mpegpicture.c:98
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread_frame.c:1057
DELAYED_PIC_REF
#define DELAYED_PIC_REF
Value of Picture.reference when Picture is not a reference picture, but is held for delayed output.
Definition: diracdec.c:68
ff_mpeg_ref_picture
int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
Definition: mpegpicture.c:355
Picture::mc_mb_var_sum
int64_t mc_mb_var_sum
motion compensated MB variance for current frame
Definition: mpegpicture.h:83
Picture::qscale_table_buf
AVBufferRef * qscale_table_buf
Definition: mpegpicture.h:49
Picture::alloc_mb_height
int alloc_mb_height
mb_height used to allocate tables
Definition: mpegpicture.h:71
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:376
mpegpicture.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
Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
AV_CODEC_ID_MSS2
@ AV_CODEC_ID_MSS2
Definition: codec_id.h:217
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:76
avcodec_default_get_buffer2
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: decode.c:1453
FMT_H263
@ FMT_H263
Definition: mpegutils.h:125
i
int i
Definition: input.c:406
MAKE_WRITABLE
#define MAKE_WRITABLE(table)
common.h
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:437
ff_update_picture_tables
int ff_update_picture_tables(Picture *dst, Picture *src)
Definition: mpegpicture.c:317
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
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
av_buffer_allocz
AVBufferRef * av_buffer_allocz(size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:93
ret
ret
Definition: filter_design.txt:187
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:174
Picture::qscale_table
int8_t * qscale_table
Definition: mpegpicture.h:50
pic_is_unused
static int pic_is_unused(Picture *pic)
Definition: mpegpicture.c:398
AVCodecContext
main external API structure.
Definition: avcodec.h:383
AVFrame::height
int height
Definition: frame.h:361
Picture::shared
int shared
Definition: mpegpicture.h:89
ScratchpadContext::edge_emu_buffer
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
Definition: mpegpicture.h:36
Picture::mb_type
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
Picture::f
struct AVFrame * f
Definition: mpegpicture.h:46
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AVHWAccel::frame_priv_data_size
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:2149
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
Picture::mb_var_sum
int64_t mb_var_sum
sum of MB variance for current frame
Definition: mpegpicture.h:82
find_unused_picture
static int find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:407
AV_CODEC_EXPORT_DATA_MVS
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:342
Picture::mc_mb_var_buf
AVBufferRef * mc_mb_var_buf
Definition: mpegpicture.h:67
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
Picture::mbskip_table_buf
AVBufferRef * mbskip_table_buf
Definition: mpegpicture.h:58
AV_CODEC_ID_WMV3IMAGE
@ AV_CODEC_ID_WMV3IMAGE
Definition: codec_id.h:201
ScratchpadContext::b_scratchpad
uint8_t * b_scratchpad
scratchpad used for writing into write only buffers
Definition: mpegpicture.h:39
Picture::mb_var
uint16_t * mb_var
Table for MB variances.
Definition: mpegpicture.h:65
Picture::alloc_mb_stride
int alloc_mb_stride
mb_stride used to allocate tables
Definition: mpegpicture.h:72