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 "encode.h"
30 #include "motion_est.h"
31 #include "mpegpicture.h"
32 #include "mpegutils.h"
33 #include "threadframe.h"
34 
36 {
37  pic->alloc_mb_width =
38  pic->alloc_mb_height = 0;
39 
46 
47  for (int i = 0; i < 2; i++) {
50  }
51 }
52 
53 static int make_tables_writable(Picture *pic)
54 {
55  int ret, i;
56 #define MAKE_WRITABLE(table) \
57 do {\
58  if (pic->table &&\
59  (ret = av_buffer_make_writable(&pic->table)) < 0)\
60  return ret;\
61 } while (0)
62 
63  MAKE_WRITABLE(mb_var_buf);
64  MAKE_WRITABLE(mc_mb_var_buf);
65  MAKE_WRITABLE(mb_mean_buf);
66  MAKE_WRITABLE(mbskip_table_buf);
67  MAKE_WRITABLE(qscale_table_buf);
68  MAKE_WRITABLE(mb_type_buf);
69 
70  for (i = 0; i < 2; i++) {
71  MAKE_WRITABLE(motion_val_buf[i]);
72  MAKE_WRITABLE(ref_index_buf[i]);
73  }
74 
75  return 0;
76 }
77 
79  ScratchpadContext *sc, int linesize)
80 {
81 # define EMU_EDGE_HEIGHT (4 * 70)
82  int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
83 
84  if (avctx->hwaccel)
85  return 0;
86 
87  if (linesize < 24) {
88  av_log(avctx, AV_LOG_ERROR, "Image too small, temporary buffers cannot function\n");
89  return AVERROR_PATCHWELCOME;
90  }
91 
92  if (av_image_check_size2(alloc_size, EMU_EDGE_HEIGHT, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)
93  return AVERROR(ENOMEM);
94 
95  // edge emu needs blocksize + filter length - 1
96  // (= 17x17 for halfpel / 21x21 for H.264)
97  // VC-1 computes luma and chroma simultaneously and needs 19X19 + 9x9
98  // at uvlinesize. It supports only YUV420 so 24x24 is enough
99  // linesize * interlaced * MBsize
100  // we also use this buffer for encoding in encode_mb_internal() needig an additional 32 lines
101  if (!FF_ALLOCZ_TYPED_ARRAY(sc->edge_emu_buffer, alloc_size * EMU_EDGE_HEIGHT) ||
102  !FF_ALLOCZ_TYPED_ARRAY(me->scratchpad, alloc_size * 4 * 16 * 2)) {
104  return AVERROR(ENOMEM);
105  }
106 
107  me->temp = me->scratchpad;
108  sc->rd_scratchpad = me->scratchpad;
109  sc->b_scratchpad = me->scratchpad;
110  sc->obmc_scratchpad = me->scratchpad + 16;
111 
112  return 0;
113 }
114 
115 /**
116  * Allocate a frame buffer
117  */
118 static int alloc_frame_buffer(AVCodecContext *avctx, Picture *pic,
120  int chroma_x_shift, int chroma_y_shift,
121  int linesize, int uvlinesize)
122 {
123  int edges_needed = av_codec_is_encoder(avctx->codec);
124  int r, ret;
125 
126  pic->tf.f = pic->f;
127 
128  if (edges_needed) {
129  pic->f->width = avctx->width + 2 * EDGE_WIDTH;
130  pic->f->height = avctx->height + 2 * EDGE_WIDTH;
131 
132  r = ff_encode_alloc_frame(avctx, pic->f);
133  } else if (avctx->codec_id != AV_CODEC_ID_WMV3IMAGE &&
134  avctx->codec_id != AV_CODEC_ID_VC1IMAGE &&
135  avctx->codec_id != AV_CODEC_ID_MSS2) {
136  r = ff_thread_get_ext_buffer(avctx, &pic->tf,
137  pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
138  } else {
139  pic->f->width = avctx->width;
140  pic->f->height = avctx->height;
141  pic->f->format = avctx->pix_fmt;
142  r = avcodec_default_get_buffer2(avctx, pic->f, 0);
143  }
144 
145  if (r < 0 || !pic->f->buf[0]) {
146  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n",
147  r, pic->f->data[0]);
148  return -1;
149  }
150 
151  if (edges_needed) {
152  int i;
153  for (i = 0; pic->f->data[i]; i++) {
154  int offset = (EDGE_WIDTH >> (i ? chroma_y_shift : 0)) *
155  pic->f->linesize[i] +
156  (EDGE_WIDTH >> (i ? chroma_x_shift : 0));
157  pic->f->data[i] += offset;
158  }
159  pic->f->width = avctx->width;
160  pic->f->height = avctx->height;
161  }
162 
163  if (avctx->hwaccel) {
164  assert(!pic->hwaccel_picture_private);
165  if (avctx->hwaccel->frame_priv_data_size) {
167  if (!pic->hwaccel_priv_buf) {
168  av_log(avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
169  return -1;
170  }
172  }
173  }
174 
175  if ((linesize && linesize != pic->f->linesize[0]) ||
176  (uvlinesize && uvlinesize != pic->f->linesize[1])) {
177  av_log(avctx, AV_LOG_ERROR,
178  "get_buffer() failed (stride changed: linesize=%d/%d uvlinesize=%d/%d)\n",
179  linesize, pic->f->linesize[0],
180  uvlinesize, pic->f->linesize[1]);
181  ff_mpeg_unref_picture(avctx, pic);
182  return -1;
183  }
184 
185  if (av_pix_fmt_count_planes(pic->f->format) > 2 &&
186  pic->f->linesize[1] != pic->f->linesize[2]) {
187  av_log(avctx, AV_LOG_ERROR,
188  "get_buffer() failed (uv stride mismatch)\n");
189  ff_mpeg_unref_picture(avctx, pic);
190  return -1;
191  }
192 
193  if (!sc->edge_emu_buffer &&
194  (ret = ff_mpeg_framesize_alloc(avctx, me, sc,
195  pic->f->linesize[0])) < 0) {
196  av_log(avctx, AV_LOG_ERROR,
197  "get_buffer() failed to allocate context scratch buffers.\n");
198  ff_mpeg_unref_picture(avctx, pic);
199  return ret;
200  }
201 
202  return 0;
203 }
204 
205 static int alloc_picture_tables(AVCodecContext *avctx, Picture *pic, int encoding, int out_format,
206  int mb_stride, int mb_width, int mb_height, int b8_stride)
207 {
208  const int big_mb_num = mb_stride * (mb_height + 1) + 1;
209  const int mb_array_size = mb_stride * mb_height;
210  const int b8_array_size = b8_stride * mb_height * 2;
211  int i;
212 
213 
214  pic->mbskip_table_buf = av_buffer_allocz(mb_array_size + 2);
215  pic->qscale_table_buf = av_buffer_allocz(big_mb_num + mb_stride);
216  pic->mb_type_buf = av_buffer_allocz((big_mb_num + mb_stride) *
217  sizeof(uint32_t));
218  if (!pic->mbskip_table_buf || !pic->qscale_table_buf || !pic->mb_type_buf)
219  return AVERROR(ENOMEM);
220 
221  if (encoding) {
222  pic->mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
223  pic->mc_mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
224  pic->mb_mean_buf = av_buffer_allocz(mb_array_size);
225  if (!pic->mb_var_buf || !pic->mc_mb_var_buf || !pic->mb_mean_buf)
226  return AVERROR(ENOMEM);
227  }
228 
229  if (out_format == FMT_H263 || encoding ||
231  int mv_size = 2 * (b8_array_size + 4) * sizeof(int16_t);
232  int ref_index_size = 4 * mb_array_size;
233 
234  for (i = 0; mv_size && i < 2; i++) {
235  pic->motion_val_buf[i] = av_buffer_allocz(mv_size);
236  pic->ref_index_buf[i] = av_buffer_allocz(ref_index_size);
237  if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
238  return AVERROR(ENOMEM);
239  }
240  }
241 
242  pic->alloc_mb_width = mb_width;
243  pic->alloc_mb_height = mb_height;
244  pic->alloc_mb_stride = mb_stride;
245 
246  return 0;
247 }
248 
249 /**
250  * Allocate a Picture.
251  * The pixels are allocated/set by calling get_buffer() if shared = 0
252  */
254  ScratchpadContext *sc, int shared, int encoding,
255  int chroma_x_shift, int chroma_y_shift, int out_format,
256  int mb_stride, int mb_width, int mb_height, int b8_stride,
257  ptrdiff_t *linesize, ptrdiff_t *uvlinesize)
258 {
259  int i, ret;
260 
261  if (pic->qscale_table_buf)
262  if ( pic->alloc_mb_width != mb_width
263  || pic->alloc_mb_height != mb_height)
264  free_picture_tables(pic);
265 
266  if (shared) {
267  av_assert0(pic->f->data[0]);
268  pic->shared = 1;
269  } else {
270  av_assert0(!pic->f->buf[0]);
271  if (alloc_frame_buffer(avctx, pic, me, sc,
272  chroma_x_shift, chroma_y_shift,
273  *linesize, *uvlinesize) < 0)
274  return -1;
275 
276  *linesize = pic->f->linesize[0];
277  *uvlinesize = pic->f->linesize[1];
278  }
279 
280  if (!pic->qscale_table_buf)
281  ret = alloc_picture_tables(avctx, pic, encoding, out_format,
282  mb_stride, mb_width, mb_height, b8_stride);
283  else
284  ret = make_tables_writable(pic);
285  if (ret < 0)
286  goto fail;
287 
288  if (encoding) {
289  pic->mb_var = (uint16_t*)pic->mb_var_buf->data;
290  pic->mc_mb_var = (uint16_t*)pic->mc_mb_var_buf->data;
291  pic->mb_mean = pic->mb_mean_buf->data;
292  }
293 
294  pic->mbskip_table = pic->mbskip_table_buf->data;
295  pic->qscale_table = pic->qscale_table_buf->data + 2 * mb_stride + 1;
296  pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * mb_stride + 1;
297 
298  if (pic->motion_val_buf[0]) {
299  for (i = 0; i < 2; i++) {
300  pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
301  pic->ref_index[i] = pic->ref_index_buf[i]->data;
302  }
303  }
304 
305  return 0;
306 fail:
307  av_log(avctx, AV_LOG_ERROR, "Error allocating a picture.\n");
308  ff_mpeg_unref_picture(avctx, pic);
309  free_picture_tables(pic);
310  return AVERROR(ENOMEM);
311 }
312 
313 /**
314  * Deallocate a picture; frees the picture tables in case they
315  * need to be reallocated anyway.
316  */
318 {
319  int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean);
320 
321  pic->tf.f = pic->f;
322  /* WM Image / Screen codecs allocate internal buffers with different
323  * dimensions / colorspaces; ignore user-defined callbacks for these. */
324  if (avctx->codec_id != AV_CODEC_ID_WMV3IMAGE &&
325  avctx->codec_id != AV_CODEC_ID_VC1IMAGE &&
326  avctx->codec_id != AV_CODEC_ID_MSS2)
327  ff_thread_release_ext_buffer(avctx, &pic->tf);
328  else if (pic->f)
329  av_frame_unref(pic->f);
330 
332 
333  if (pic->needs_realloc)
334  free_picture_tables(pic);
335 
336  memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
337 }
338 
340 {
341  int i, ret;
342 
343  ret = av_buffer_replace(&dst->mb_var_buf, src->mb_var_buf);
344  ret |= av_buffer_replace(&dst->mc_mb_var_buf, src->mc_mb_var_buf);
345  ret |= av_buffer_replace(&dst->mb_mean_buf, src->mb_mean_buf);
346  ret |= av_buffer_replace(&dst->mbskip_table_buf, src->mbskip_table_buf);
347  ret |= av_buffer_replace(&dst->qscale_table_buf, src->qscale_table_buf);
348  ret |= av_buffer_replace(&dst->mb_type_buf, src->mb_type_buf);
349  for (i = 0; i < 2; i++) {
350  ret |= av_buffer_replace(&dst->motion_val_buf[i], src->motion_val_buf[i]);
351  ret |= av_buffer_replace(&dst->ref_index_buf[i], src->ref_index_buf[i]);
352  }
353 
354  if (ret < 0) {
355  free_picture_tables(dst);
356  return ret;
357  }
358 
359  dst->mb_var = src->mb_var;
360  dst->mc_mb_var = src->mc_mb_var;
361  dst->mb_mean = src->mb_mean;
362  dst->mbskip_table = src->mbskip_table;
363  dst->qscale_table = src->qscale_table;
364  dst->mb_type = src->mb_type;
365  for (i = 0; i < 2; i++) {
366  dst->motion_val[i] = src->motion_val[i];
367  dst->ref_index[i] = src->ref_index[i];
368  }
369 
370  dst->alloc_mb_width = src->alloc_mb_width;
371  dst->alloc_mb_height = src->alloc_mb_height;
372  dst->alloc_mb_stride = src->alloc_mb_stride;
373 
374  return 0;
375 }
376 
378 {
379  int ret;
380 
381  av_assert0(!dst->f->buf[0]);
382  av_assert0(src->f->buf[0]);
383 
384  src->tf.f = src->f;
385  dst->tf.f = dst->f;
386  ret = ff_thread_ref_frame(&dst->tf, &src->tf);
387  if (ret < 0)
388  goto fail;
389 
391  if (ret < 0)
392  goto fail;
393 
394  if (src->hwaccel_picture_private) {
395  dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
396  if (!dst->hwaccel_priv_buf) {
397  ret = AVERROR(ENOMEM);
398  goto fail;
399  }
401  }
402 
403  dst->field_picture = src->field_picture;
404  dst->mb_var_sum = src->mb_var_sum;
405  dst->mc_mb_var_sum = src->mc_mb_var_sum;
406  dst->b_frame_score = src->b_frame_score;
407  dst->needs_realloc = src->needs_realloc;
408  dst->reference = src->reference;
409  dst->shared = src->shared;
410 
411  memcpy(dst->encoding_error, src->encoding_error,
412  sizeof(dst->encoding_error));
413 
414  return 0;
415 fail:
416  ff_mpeg_unref_picture(avctx, dst);
417  return ret;
418 }
419 
420 static inline int pic_is_unused(Picture *pic)
421 {
422  if (!pic->f->buf[0])
423  return 1;
424  if (pic->needs_realloc)
425  return 1;
426  return 0;
427 }
428 
429 static int find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
430 {
431  int i;
432 
433  if (shared) {
434  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
435  if (!picture[i].f->buf[0])
436  return i;
437  }
438  } else {
439  for (i = 0; i < MAX_PICTURE_COUNT; i++) {
440  if (pic_is_unused(&picture[i]))
441  return i;
442  }
443  }
444 
445  av_log(avctx, AV_LOG_FATAL,
446  "Internal error, picture buffer overflow\n");
447  /* We could return -1, but the codec would crash trying to draw into a
448  * non-existing frame anyway. This is safer than waiting for a random crash.
449  * Also the return of this is never useful, an encoder must only allocate
450  * as much as allowed in the specification. This has no relationship to how
451  * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
452  * enough for such valid streams).
453  * Plus, a decoder has to check stream validity and remove frames if too
454  * many reference frames are around. Waiting for "OOM" is not correct at
455  * all. Similarly, missing reference frames have to be replaced by
456  * interpolated/MC frames, anything else is a bug in the codec ...
457  */
458  abort();
459  return -1;
460 }
461 
462 int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
463 {
464  int ret = find_unused_picture(avctx, picture, shared);
465 
466  if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
467  if (picture[ret].needs_realloc) {
468  ff_mpeg_unref_picture(avctx, &picture[ret]);
469  }
470  }
471  return ret;
472 }
473 
475 {
476  free_picture_tables(pic);
477  ff_mpeg_unref_picture(avctx, pic);
478  av_frame_free(&pic->f);
479 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:97
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1379
Picture::mb_var_buf
AVBufferRef * mb_var_buf
Definition: mpegpicture.h:65
Picture::ref_index_buf
AVBufferRef * ref_index_buf[2]
Definition: mpegpicture.h:62
EMU_EDGE_HEIGHT
#define EMU_EDGE_HEIGHT
ScratchpadContext::obmc_scratchpad
uint8_t * obmc_scratchpad
Definition: mpegpicture.h:39
ff_mpeg_framesize_alloc
int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, ScratchpadContext *sc, int linesize)
Definition: mpegpicture.c:78
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
free_picture_tables
static void av_noinline free_picture_tables(Picture *pic)
Definition: mpegpicture.c:35
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:1148
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:38
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:71
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
Picture::field_picture
int field_picture
whether or not the picture was encoded in separate fields
Definition: mpegpicture.h:81
pixdesc.h
AVFrame::width
int width
Definition: frame.h:397
encode.h
Picture::ref_index
int8_t * ref_index[2]
Definition: mpegpicture.h:63
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:46
Picture::mb_mean
uint8_t * mb_mean
Table for MB luminance.
Definition: mpegpicture.h:76
mpegutils.h
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:525
make_tables_writable
static int make_tables_writable(Picture *pic)
Definition: mpegpicture.c:53
ThreadFrame::f
AVFrame * f
Definition: threadframe.h:28
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
ScratchpadContext
Definition: mpegpicture.h:36
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2702
Picture::needs_realloc
int needs_realloc
Picture needs to be reallocated (eg due to a frame size change)
Definition: mpegpicture.h:87
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:205
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:398
fail
#define fail()
Definition: checkasm.h:130
Picture::mbskip_table
uint8_t * mbskip_table
Definition: mpegpicture.h:60
av_noinline
#define av_noinline
Definition: attributes.h:72
motion_est.h
MAX_PICTURE_COUNT
#define MAX_PICTURE_COUNT
Definition: mpegpicture.h:33
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
av_cold
#define av_cold
Definition: attributes.h:90
Picture::b_frame_score
int b_frame_score
Definition: mpegpicture.h:86
ff_mpeg_unref_picture
void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
Deallocate a picture; frees the picture tables in case they need to be reallocated anyway.
Definition: mpegpicture.c:317
Picture::hwaccel_priv_buf
AVBufferRef * hwaccel_priv_buf
Definition: mpegpicture.h:78
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:367
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:1909
AV_CODEC_ID_VC1IMAGE
@ AV_CODEC_ID_VC1IMAGE
Definition: codec_id.h:202
Picture::hwaccel_picture_private
void * hwaccel_picture_private
Hardware accelerator private data.
Definition: mpegpicture.h:79
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:399
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:889
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
if
if(ret)
Definition: filter_design.txt:179
Picture::reference
int reference
Definition: mpegpicture.h:89
Picture::mb_type_buf
AVBufferRef * mb_type_buf
Definition: mpegpicture.h:56
ff_find_unused_picture
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:462
threadframe.h
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:34
Picture::mb_mean_buf
AVBufferRef * mb_mean_buf
Definition: mpegpicture.h:75
ff_update_picture_tables
int ff_update_picture_tables(Picture *dst, const Picture *src)
Definition: mpegpicture.c:339
Picture::motion_val_buf
AVBufferRef * motion_val_buf[2]
Definition: mpegpicture.h:53
Picture::tf
ThreadFrame tf
Definition: mpegpicture.h:48
Picture::mc_mb_var
uint16_t * mc_mb_var
Table for motion compensated MB variances.
Definition: mpegpicture.h:69
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:253
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:118
ff_encode_alloc_frame
int ff_encode_alloc_frame(AVCodecContext *avctx, AVFrame *frame)
Allocate buffers for a frame.
Definition: encode.c:601
f
f
Definition: af_crystalizer.c:122
ff_mpeg_ref_picture
int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
Definition: mpegpicture.c:377
Picture::mc_mb_var_sum
int64_t mc_mb_var_sum
motion compensated MB variance for current frame
Definition: mpegpicture.h:84
Picture::qscale_table_buf
AVBufferRef * qscale_table_buf
Definition: mpegpicture.h:50
Picture::alloc_mb_height
int alloc_mb_height
mb_height used to allocate tables
Definition: mpegpicture.h:72
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:412
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:54
Picture::encoding_error
uint64_t encoding_error[MPEGVIDEO_MAX_PLANES]
Definition: mpegpicture.h:92
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:74
avcodec_default_get_buffer2
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: get_buffer.c:290
FMT_H263
@ FMT_H263
Definition: mpegutils.h:119
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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:477
ff_mpv_picture_free
void av_cold ff_mpv_picture_free(AVCodecContext *avctx, Picture *pic)
Definition: mpegpicture.c:474
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:562
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:599
ff_thread_get_ext_buffer
int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around ff_get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1050
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:51
pic_is_unused
static int pic_is_unused(Picture *pic)
Definition: mpegpicture.c:420
AVCodecContext
main external API structure.
Definition: avcodec.h:389
AVFrame::height
int height
Definition: frame.h:397
Picture::shared
int shared
Definition: mpegpicture.h:90
ScratchpadContext::edge_emu_buffer
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
Definition: mpegpicture.h:37
Picture::mb_type
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:57
Picture::f
struct AVFrame * f
Definition: mpegpicture.h:47
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:2177
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:2007
Picture::mb_var_sum
int64_t mb_var_sum
sum of MB variance for current frame
Definition: mpegpicture.h:83
find_unused_picture
static int find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:429
AV_CODEC_EXPORT_DATA_MVS
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:348
Picture::mc_mb_var_buf
AVBufferRef * mc_mb_var_buf
Definition: mpegpicture.h:68
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:562
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
Picture::mbskip_table_buf
AVBufferRef * mbskip_table_buf
Definition: mpegpicture.h:59
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:40
Picture::mb_var
uint16_t * mb_var
Table for MB variances.
Definition: mpegpicture.h:66
Picture::alloc_mb_stride
int alloc_mb_stride
mb_stride used to allocate tables
Definition: mpegpicture.h:73