FFmpeg  4.4.5
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 
368  ret = ff_update_picture_tables(dst, src);
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 }
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
#define f(width, name)
Definition: cbs_vp9.c:255
#define fail()
Definition: checkasm.h:133
common internal and external API header
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:74
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:514
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:403
@ AV_CODEC_ID_VC1IMAGE
Definition: codec_id.h:201
@ AV_CODEC_ID_WMV3IMAGE
Definition: codec_id.h:200
@ AV_CODEC_ID_MSS2
Definition: codec_id.h:216
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: decode.c:1695
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:125
AVBufferRef * av_buffer_allocz(buffer_size_t size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
int av_buffer_replace(AVBufferRef **pdst, AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:219
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR(e)
Definition: error.h:43
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:188
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:288
misc image utilities
int i
Definition: input.c:407
#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
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:940
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:103
#define FFALIGN(x, a)
Definition: macros.h:48
#define EMU_EDGE_HEIGHT
static int pic_is_unused(Picture *pic)
Definition: mpegpicture.c:398
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
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
void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
Deallocate a picture.
Definition: mpegpicture.c:295
int ff_find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:440
int ff_mpeg_ref_picture(AVCodecContext *avctx, Picture *dst, Picture *src)
Definition: mpegpicture.c:355
static int find_unused_picture(AVCodecContext *avctx, Picture *picture, int shared)
Definition: mpegpicture.c:407
#define MAKE_WRITABLE(table)
int ff_update_picture_tables(Picture *dst, Picture *src)
Definition: mpegpicture.c:317
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
static int make_tables_writable(Picture *pic)
Definition: mpegpicture.c:33
void ff_free_picture_tables(Picture *pic)
Definition: mpegpicture.c:454
int ff_mpeg_framesize_alloc(AVCodecContext *avctx, MotionEstContext *me, ScratchpadContext *sc, int linesize)
Definition: mpegpicture.c:58
#define MAX_PICTURE_COUNT
Definition: mpegpicture.h:32
#define EDGE_WIDTH
Definition: mpegpicture.h:33
@ FMT_H263
Definition: mpegutils.h:126
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2613
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
uint8_t * data
The data buffer.
Definition: buffer.h:92
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:2248
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1680
const struct AVCodec * codec
Definition: avcodec.h:545
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:2346
enum AVCodecID codec_id
Definition: avcodec.h:546
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int width
Definition: frame.h:376
int height
Definition: frame.h:376
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:509
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:391
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:2548
Motion estimation context.
Definition: motion_est.h:47
Picture.
Definition: mpegpicture.h:45
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
int needs_realloc
Picture needs to be reallocated (eg due to a frame size change)
Definition: mpegpicture.h:86
int8_t * ref_index[2]
Definition: mpegpicture.h:62
AVBufferRef * ref_index_buf[2]
Definition: mpegpicture.h:61
AVBufferRef * mbskip_table_buf
Definition: mpegpicture.h:58
AVBufferRef * qscale_table_buf
Definition: mpegpicture.h:49
uint64_t encoding_error[AV_NUM_DATA_POINTERS]
Definition: mpegpicture.h:91
uint8_t * mb_mean
Table for MB luminance.
Definition: mpegpicture.h:75
int reference
Definition: mpegpicture.h:88
int64_t mc_mb_var_sum
motion compensated MB variance for current frame
Definition: mpegpicture.h:83
int shared
Definition: mpegpicture.h:89
uint16_t * mc_mb_var
Table for motion compensated MB variances.
Definition: mpegpicture.h:68
uint16_t * mb_var
Table for MB variances.
Definition: mpegpicture.h:65
AVBufferRef * mb_mean_buf
Definition: mpegpicture.h:74
uint8_t * mbskip_table
Definition: mpegpicture.h:59
AVBufferRef * mc_mb_var_buf
Definition: mpegpicture.h:67
AVBufferRef * hwaccel_priv_buf
Definition: mpegpicture.h:77
int alloc_mb_stride
mb_stride used to allocate tables
Definition: mpegpicture.h:72
AVBufferRef * mb_type_buf
Definition: mpegpicture.h:55
void * hwaccel_picture_private
Hardware accelerator private data.
Definition: mpegpicture.h:78
struct AVFrame * f
Definition: mpegpicture.h:46
AVBufferRef * mb_var_buf
Definition: mpegpicture.h:64
AVBufferRef * motion_val_buf[2]
Definition: mpegpicture.h:52
int alloc_mb_width
mb_width used to allocate tables
Definition: mpegpicture.h:70
int b_frame_score
Definition: mpegpicture.h:85
int8_t * qscale_table
Definition: mpegpicture.h:50
ThreadFrame tf
Definition: mpegpicture.h:47
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
int64_t mb_var_sum
sum of MB variance for current frame
Definition: mpegpicture.h:82
int alloc_mb_height
mb_height used to allocate tables
Definition: mpegpicture.h:71
int field_picture
whether or not the picture was encoded in separate fields
Definition: mpegpicture.h:80
uint8_t * b_scratchpad
scratchpad used for writing into write only buffers
Definition: mpegpicture.h:39
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
Definition: mpegpicture.h:36
uint8_t * obmc_scratchpad
Definition: mpegpicture.h:38
uint8_t * rd_scratchpad
scratchpad for rate distortion mb decision
Definition: mpegpicture.h:37
AVFrame * f
Definition: thread.h:35
#define av_freep(p)
#define av_log(a,...)
#define src
Definition: vp8dsp.c:255
#define me
const char * r
Definition: vf_curves.c:116
if(ret< 0)
Definition: vf_mcdeint.c:282
static const uint8_t offset[127][2]
Definition: vf_spp.c:107