FFmpeg
mpegvideo.c
Go to the documentation of this file.
1 /*
2  * The simplest mpeg encoder (well, it was the simplest!)
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 /**
26  * @file
27  * The simplest mpeg encoder (well, it was the simplest!).
28  */
29 
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/intreadwrite.h"
35 #include "libavutil/mem.h"
36 
37 #include "avcodec.h"
38 #include "blockdsp.h"
39 #include "idctdsp.h"
40 #include "mathops.h"
41 #include "mpeg_er.h"
42 #include "mpegutils.h"
43 #include "mpegvideo.h"
44 #include "mpegvideodata.h"
45 #include "mpegvideo_unquantize.h"
46 #include "libavutil/refstruct.h"
47 
48 
49 static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
50 {
51  while(h--)
52  memset(dst + h*linesize, 128, 16);
53 }
54 
55 static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
56 {
57  while(h--)
58  memset(dst + h*linesize, 128, 8);
59 }
60 
61 /* init common dct for both encoder and decoder */
63 {
64  ff_blockdsp_init(&s->bdsp);
65  ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
66  ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
67 
68  if (s->avctx->debug & FF_DEBUG_NOMC) {
69  int i;
70  for (i=0; i<4; i++) {
71  s->hdsp.avg_pixels_tab[0][i] = gray16;
72  s->hdsp.put_pixels_tab[0][i] = gray16;
73  s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16;
74 
75  s->hdsp.avg_pixels_tab[1][i] = gray8;
76  s->hdsp.put_pixels_tab[1][i] = gray8;
77  s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8;
78  }
79  }
80 }
81 
82 av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st,
83  const uint8_t *src_scantable)
84 {
85  st->scantable = src_scantable;
86 
87  for (int i = 0, end = -1; i < 64; i++) {
88  int j = src_scantable[i];
89  st->permutated[i] = permutation[j];
90  if (permutation[j] > end)
91  end = permutation[j];
92  st->raster_end[i] = end;
93  }
94 }
95 
97 {
98  if (s->codec_id == AV_CODEC_ID_MPEG4)
99  s->idsp.mpeg4_studio_profile = s->studio_profile;
100  ff_idctdsp_init(&s->idsp, s->avctx);
101 
102  /* load & permutate scantables
103  * note: only wmv uses different ones
104  */
105  if (s->alternate_scan) {
106  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
107  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
108  } else {
109  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
110  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
111  }
112  ff_permute_scantable(s->permutated_intra_h_scantable, ff_alternate_horizontal_scan,
113  s->idsp.idct_permutation);
114  ff_permute_scantable(s->permutated_intra_v_scantable, ff_alternate_vertical_scan,
115  s->idsp.idct_permutation);
116 }
117 
119 {
120  const int nb_slices = s->slice_context_count;
121  const size_t slice_size = s->slice_ctx_size;
122 
123  for (int i = 1; i < nb_slices; i++) {
124  s->thread_context[i] = av_memdup(s, slice_size);
125  if (!s->thread_context[i])
126  return AVERROR(ENOMEM);
127  s->thread_context[i]->start_mb_y =
128  (s->mb_height * (i ) + nb_slices / 2) / nb_slices;
129  s->thread_context[i]->end_mb_y =
130  (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
131  }
132  s->start_mb_y = 0;
133  s->end_mb_y = nb_slices > 1 ? (s->mb_height + nb_slices / 2) / nb_slices
134  : s->mb_height;
135  return 0;
136 }
137 
139 {
140  if (!s)
141  return;
142 
143  av_freep(&s->sc.edge_emu_buffer);
144  av_freep(&s->sc.scratchpad_buf);
145  s->sc.obmc_scratchpad = NULL;
146  s->sc.linesize = 0;
147 }
148 
150 {
151  for (int i = 1; i < s->slice_context_count; i++) {
152  free_duplicate_context(s->thread_context[i]);
153  av_freep(&s->thread_context[i]);
154  }
156 }
157 
159 {
160 #define COPY(M) \
161  M(ScratchpadContext, sc) \
162  M(int, start_mb_y) \
163  M(int, end_mb_y) \
164  M(int16_t*, dc_val) \
165  M(void*, ac_val)
166 
167  int ret;
168  // FIXME copy only needed parts
169 #define BACKUP(T, member) T member = dst->member;
170  COPY(BACKUP)
171  memcpy(dst, src, sizeof(MpegEncContext));
172 #define RESTORE(T, member) dst->member = member;
173  COPY(RESTORE)
174 
175  ret = ff_mpv_framesize_alloc(dst->avctx, &dst->sc, dst->linesize);
176  if (ret < 0) {
177  av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
178  "scratch buffers.\n");
179  return ret;
180  }
181  return 0;
182 }
183 
184 /**
185  * Set the given MpegEncContext to common defaults
186  * (same for encoding and decoding).
187  * The changed fields will not depend upon the
188  * prior state of the MpegEncContext.
189  */
191 {
192  s->chroma_qscale_table = ff_default_chroma_qscale_table;
193  s->progressive_frame = 1;
194  s->progressive_sequence = 1;
195  s->picture_structure = PICT_FRAME;
196 
197  s->slice_context_count = 1;
198 }
199 
201 {
207  pools->alloc_mb_height = pools->alloc_mb_width = pools->alloc_mb_stride = 0;
208 }
209 
211 {
212  int nb_slices = (HAVE_THREADS &&
213  s->avctx->active_thread_type & FF_THREAD_SLICE) ?
214  s->avctx->thread_count : 1;
215  BufferPoolContext *const pools = &s->buffer_pools;
216  int y_size, c_size, yc_size, mb_array_size, mv_table_size, x, y;
217  int mb_height;
218 
219  if (s->encoding && s->avctx->slices)
220  nb_slices = s->avctx->slices;
221 
222  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
223  s->mb_height = (s->height + 31) / 32 * 2;
224  else
225  s->mb_height = (s->height + 15) / 16;
226 
227  if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
228  int max_slices;
229  if (s->mb_height)
230  max_slices = FFMIN(MAX_THREADS, s->mb_height);
231  else
232  max_slices = MAX_THREADS;
233  av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
234  " reducing to %d\n", nb_slices, max_slices);
235  nb_slices = max_slices;
236  }
237 
238  s->slice_context_count = nb_slices;
239 
240  /* VC-1 can change from being progressive to interlaced on a per-frame
241  * basis. We therefore allocate certain buffers so big that they work
242  * in both instances. */
243  mb_height = s->msmpeg4_version == MSMP4_VC1 ?
244  FFALIGN(s->mb_height, 2) : s->mb_height;
245 
246  s->mb_width = (s->width + 15) / 16;
247  s->mb_stride = s->mb_width + 1;
248  s->b8_stride = s->mb_width * 2 + 1;
249  mb_array_size = mb_height * s->mb_stride;
250  mv_table_size = (mb_height + 2) * s->mb_stride + 1;
251 
252  /* set default edge pos, will be overridden
253  * in decode_header if needed */
254  s->h_edge_pos = s->mb_width * 16;
255  s->v_edge_pos = s->mb_height * 16;
256 
257  s->mb_num = s->mb_width * s->mb_height;
258 
259  s->block_wrap[0] =
260  s->block_wrap[1] =
261  s->block_wrap[2] =
262  s->block_wrap[3] = s->b8_stride;
263  s->block_wrap[4] =
264  s->block_wrap[5] = s->mb_stride;
265 
266  y_size = s->b8_stride * (2 * mb_height + 1);
267  c_size = s->mb_stride * (mb_height + 1);
268  yc_size = y_size + 2 * c_size;
269 
270  if (!FF_ALLOCZ_TYPED_ARRAY(s->mb_index2xy, s->mb_num + 1))
271  return AVERROR(ENOMEM);
272  for (y = 0; y < s->mb_height; y++)
273  for (x = 0; x < s->mb_width; x++)
274  s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
275 
276  s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
277 
278 #define ALLOC_POOL(name, size, flags) do { \
279  pools->name ##_pool = av_refstruct_pool_alloc((size), (flags)); \
280  if (!pools->name ##_pool) \
281  return AVERROR(ENOMEM); \
282 } while (0)
283 
284  if (s->codec_id == AV_CODEC_ID_MPEG4 ||
285  (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
286  /* interlaced direct mode decoding tables */
287  int16_t (*tmp)[2] = av_calloc(mv_table_size, 4 * sizeof(*tmp));
288  if (!tmp)
289  return AVERROR(ENOMEM);
290  s->p_field_mv_table_base = tmp;
291  tmp += s->mb_stride + 1;
292  for (int i = 0; i < 2; i++) {
293  for (int j = 0; j < 2; j++) {
294  s->p_field_mv_table[i][j] = tmp;
295  tmp += mv_table_size;
296  }
297  }
298  if (s->codec_id == AV_CODEC_ID_MPEG4) {
299  ALLOC_POOL(mbskip_table, mb_array_size + 2,
300  !s->encoding ? AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME : 0);
301  if (!s->encoding) {
302  /* cbp, pred_dir */
303  if (!(s->cbp_table = av_mallocz(mb_array_size)) ||
304  !(s->pred_dir_table = av_mallocz(mb_array_size)))
305  return AVERROR(ENOMEM);
306  }
307  }
308  }
309 
310  if (s->msmpeg4_version >= MSMP4_V3) {
311  s->coded_block_base = av_mallocz(y_size);
312  if (!s->coded_block_base)
313  return AVERROR(ENOMEM);
314  s->coded_block = s->coded_block_base + s->b8_stride + 1;
315  }
316 
317  if (s->h263_pred || s->h263_aic || !s->encoding) {
318  // When encoding, each slice (and therefore each thread)
319  // gets its own ac_val and dc_val buffers in order to avoid
320  // races.
321  size_t allslice_yc_size = yc_size * (s->encoding ? nb_slices : 1);
322  if (s->out_format == FMT_H263) {
323  /* ac values */
324  if (!FF_ALLOCZ_TYPED_ARRAY(s->ac_val_base, allslice_yc_size))
325  return AVERROR(ENOMEM);
326  s->ac_val = s->ac_val_base + s->b8_stride + 1;
327  }
328 
329  /* dc values */
330  // MN: we need these for error resilience of intra-frames
331  // Allocating them unconditionally for decoders also means
332  // that we don't need to reinitialize when e.g. h263_aic changes.
333 
334  // y_size and therefore yc_size is always odd; allocate one element
335  // more for each encoder slice in order to be able to align each slice's
336  // dc_val to four in order to use aligned stores when cleaning dc_val.
337  allslice_yc_size += s->encoding * nb_slices;
338  if (!FF_ALLOC_TYPED_ARRAY(s->dc_val_base, allslice_yc_size))
339  return AVERROR(ENOMEM);
340  s->dc_val = s->dc_val_base + s->b8_stride + 1;
341  for (size_t i = 0; i < allslice_yc_size; ++i)
342  s->dc_val_base[i] = 1024;
343  }
344 
345  // Note the + 1 is for a quicker MPEG-4 slice_end detection
346  if (!(s->mbskip_table = av_mallocz(mb_array_size + 2)) ||
347  /* which mb is an intra block, init macroblock skip table */
348  !(s->mbintra_table = av_mallocz(mb_array_size)))
349  return AVERROR(ENOMEM);
350 
351  ALLOC_POOL(qscale_table, mv_table_size, 0);
352  ALLOC_POOL(mb_type, mv_table_size * sizeof(uint32_t), 0);
353 
354  if (s->out_format == FMT_H263 || s->encoding ||
355  (s->avctx->export_side_data & AV_CODEC_EXPORT_DATA_MVS)) {
356  const int b8_array_size = s->b8_stride * mb_height * 2;
357  int mv_size = 2 * (b8_array_size + 4) * sizeof(int16_t);
358  int ref_index_size = 4 * mb_array_size;
359 
360  /* FIXME: The output of H.263 with OBMC depends upon
361  * the earlier content of the buffer; therefore we set
362  * the flags to always reset returned buffers here. */
364  ALLOC_POOL(ref_index, ref_index_size, 0);
365  }
366 #undef ALLOC_POOL
367  pools->alloc_mb_width = s->mb_width;
368  pools->alloc_mb_height = mb_height;
369  pools->alloc_mb_stride = s->mb_stride;
370 
371  return !CONFIG_MPEGVIDEODEC || s->encoding ? 0 : ff_mpeg_er_init(s);
372 }
373 
374 /**
375  * init common structure for both encoder and decoder.
376  * this assumes that some variables like width/height are already set
377  */
379 {
380  int ret;
381 
382  if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
383  av_log(s->avctx, AV_LOG_ERROR,
384  "decoding to AV_PIX_FMT_NONE is not supported.\n");
385  return AVERROR(EINVAL);
386  }
387 
388  if ((s->width || s->height) &&
389  av_image_check_size(s->width, s->height, 0, s->avctx))
390  return AVERROR(EINVAL);
391 
392  dsp_init(s);
393 
394  /* set chroma shifts */
395  ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
396  &s->chroma_x_shift,
397  &s->chroma_y_shift);
398  if (ret)
399  return ret;
400 
402  goto fail;
403 
404  s->context_initialized = 1;
405  s->thread_context[0] = s;
406 
407 // if (s->width && s->height) {
408  if (!s->encoding) {
410  if (ret < 0)
411  goto fail;
412  }
413 // }
414 
415  return 0;
416  fail:
418  return ret;
419 }
420 
422 {
424 
425  free_buffer_pools(&s->buffer_pools);
426  av_freep(&s->p_field_mv_table_base);
427  for (int i = 0; i < 2; i++)
428  for (int j = 0; j < 2; j++)
429  s->p_field_mv_table[i][j] = NULL;
430 
431  av_freep(&s->ac_val_base);
432  av_freep(&s->dc_val_base);
433  av_freep(&s->coded_block_base);
434  av_freep(&s->mbintra_table);
435  av_freep(&s->cbp_table);
436  av_freep(&s->pred_dir_table);
437 
438  av_freep(&s->mbskip_table);
439 
440  av_freep(&s->er.error_status_table);
441  av_freep(&s->er.er_temp_buffer);
442  av_freep(&s->mb_index2xy);
443 
444  s->linesize = s->uvlinesize = 0;
445 }
446 
448 {
450  if (s->slice_context_count > 1)
451  s->slice_context_count = 1;
452 
453  ff_mpv_unref_picture(&s->last_pic);
454  ff_mpv_unref_picture(&s->cur_pic);
455  ff_mpv_unref_picture(&s->next_pic);
456 
457  s->context_initialized = 0;
458  s->context_reinit = 0;
459  s->linesize = s->uvlinesize = 0;
460 }
461 
462 
463 /**
464  * Clean dc, ac for the current non-intra MB.
465  */
467 {
468  int wrap = s->b8_stride;
469  int xy = s->block_index[0];
470  /* chroma */
471  unsigned uxy = s->block_index[4];
472  unsigned vxy = s->block_index[5];
473  int16_t *dc_val = s->dc_val;
474 
475  AV_WN32A(dc_val + xy, 1024 << 16 | 1024);
476  AV_WN32 (dc_val + xy + wrap, 1024 << 16 | 1024);
477  dc_val[uxy] =
478  dc_val[vxy] = 1024;
479  /* ac pred */
480  int16_t (*ac_val)[16] = s->ac_val;
481  av_assume(!((uintptr_t)ac_val & 0xF));
482  // Don't reset the upper-left luma block, as it will only ever be
483  // referenced by blocks from the same macroblock.
484  memset(ac_val[xy + 1], 0, sizeof(*ac_val));
485  memset(ac_val[xy + wrap], 0, 2 * sizeof(*ac_val));
486  /* ac pred */
487  memset(ac_val[uxy], 0, sizeof(*ac_val));
488  memset(ac_val[vxy], 0, sizeof(*ac_val));
489 }
490 
491 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
492  const int linesize = s->cur_pic.linesize[0]; //not s->linesize as this would be wrong for field pics
493  const int uvlinesize = s->cur_pic.linesize[1];
494  const int width_of_mb = (4 + (s->avctx->bits_per_raw_sample > 8)) - s->avctx->lowres;
495  const int height_of_mb = 4 - s->avctx->lowres;
496 
497  s->block_index[0]= s->b8_stride*(s->mb_y*2 ) - 2 + s->mb_x*2;
498  s->block_index[1]= s->b8_stride*(s->mb_y*2 ) - 1 + s->mb_x*2;
499  s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
500  s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
501  s->block_index[4]= s->mb_stride*(s->mb_y + 1) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
502  s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
503  //block_index is not used by mpeg2, so it is not affected by chroma_format
504 
505  s->dest[0] = s->cur_pic.data[0] + (int)((s->mb_x - 1U) << width_of_mb);
506  s->dest[1] = s->cur_pic.data[1] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
507  s->dest[2] = s->cur_pic.data[2] + (int)((s->mb_x - 1U) << (width_of_mb - s->chroma_x_shift));
508 
509  if (s->picture_structure == PICT_FRAME) {
510  s->dest[0] += s->mb_y * linesize << height_of_mb;
511  s->dest[1] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
512  s->dest[2] += s->mb_y * uvlinesize << (height_of_mb - s->chroma_y_shift);
513  } else {
514  s->dest[0] += (s->mb_y>>1) * linesize << height_of_mb;
515  s->dest[1] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
516  s->dest[2] += (s->mb_y>>1) * uvlinesize << (height_of_mb - s->chroma_y_shift);
517  av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
518  }
519 }
520 
521 /**
522  * set qscale and update qscale dependent variables.
523  */
524 void ff_set_qscale(MpegEncContext * s, int qscale)
525 {
526  if (qscale < 1)
527  qscale = 1;
528  else if (qscale > 31)
529  qscale = 31;
530 
531  s->qscale = qscale;
532  s->chroma_qscale= s->chroma_qscale_table[qscale];
533 
534  s->y_dc_scale= s->y_dc_scale_table[ qscale ];
535  s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
536 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:78
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:378
mpegvideo_unquantize.h
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
BufferPoolContext::ref_index_pool
struct AVRefStructPool * ref_index_pool
Definition: mpegpicture.h:49
blockdsp.h
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
BufferPoolContext::mbskip_table_pool
struct AVRefStructPool * mbskip_table_pool
Definition: mpegpicture.h:45
ff_mpv_init_duplicate_contexts
av_cold int ff_mpv_init_duplicate_contexts(MpegEncContext *s)
Initialize an MpegEncContext's thread contexts.
Definition: mpegvideo.c:118
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
ff_update_duplicate_context
int ff_update_duplicate_context(MpegEncContext *dst, const MpegEncContext *src)
Definition: mpegvideo.c:158
BACKUP
#define BACKUP(T, member)
ff_clean_intra_table_entries
void ff_clean_intra_table_entries(MpegEncContext *s)
Clean dc, ac for the current non-intra MB.
Definition: mpegvideo.c:466
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:32
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:534
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:491
mpegvideo.h
AV_CODEC_FLAG_INTERLACED_ME
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:331
mpegutils.h
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:228
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
ff_permute_scantable
av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])
Definition: idctdsp.c:30
fail
#define fail()
Definition: checkasm.h:196
AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME
#define AV_REFSTRUCT_POOL_FLAG_ZERO_EVERY_TIME
If this flag is set, the entries will be zeroed before being returned to the user (after the init or ...
Definition: refstruct.h:221
wrap
#define wrap(func)
Definition: neontest.h:65
MAX_THREADS
#define MAX_THREADS
Definition: frame_thread_encoder.c:37
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:3465
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:39
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:77
COPY
#define COPY(M)
refstruct.h
BufferPoolContext::alloc_mb_stride
int alloc_mb_stride
mb_stride used to allocate tables
Definition: mpegpicture.h:52
ff_mpv_init_context_frame
av_cold int ff_mpv_init_context_frame(MpegEncContext *s)
Initialize and allocates MpegEncContext fields dependent on the resolution.
Definition: mpegvideo.c:210
avassert.h
gray16
static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:49
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:90
free_buffer_pools
static av_cold void free_buffer_pools(BufferPoolContext *pools)
Definition: mpegvideo.c:200
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_mpv_framesize_alloc
int ff_mpv_framesize_alloc(AVCodecContext *avctx, ScratchpadContext *sc, int linesize)
Definition: mpegpicture.c:138
BufferPoolContext::mb_type_pool
struct AVRefStructPool * mb_type_pool
Definition: mpegpicture.h:47
ALLOC_POOL
#define ALLOC_POOL(name, size, flags)
ScanTable::scantable
const uint8_t * scantable
Definition: mpegvideo.h:47
free_duplicate_contexts
static av_cold void free_duplicate_contexts(MpegEncContext *s)
Definition: mpegvideo.c:149
BufferPoolContext::alloc_mb_height
int alloc_mb_height
mb_height used to allocate tables
Definition: mpegpicture.h:51
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:337
FMT_H263
@ FMT_H263
Definition: mpegvideo.h:55
ff_mpv_common_end
av_cold void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:447
if
if(ret)
Definition: filter_design.txt:179
ff_mpv_unref_picture
void ff_mpv_unref_picture(MPVWorkPicture *pic)
Definition: mpegpicture.c:98
av_assume
#define av_assume(cond)
Definition: avassert.h:113
NULL
#define NULL
Definition: coverity.c:32
tmp
static uint8_t tmp[20]
Definition: aes_ctr.c:47
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:96
ff_mpv_common_defaults
av_cold void ff_mpv_common_defaults(MpegEncContext *s)
Set the given MpegEncContext to common defaults (same for encoding and decoding).
Definition: mpegvideo.c:190
ff_set_qscale
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:524
mathops.h
ff_alternate_horizontal_scan
const uint8_t ff_alternate_horizontal_scan[64]
Definition: mpegvideodata.c:52
RESTORE
#define RESTORE(T, member)
free_duplicate_context
static av_cold void free_duplicate_context(MpegEncContext *s)
Definition: mpegvideo.c:138
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:372
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1573
BufferPoolContext::qscale_table_pool
struct AVRefStructPool * qscale_table_pool
Definition: mpegpicture.h:46
mpegvideodata.h
attributes.h
ff_mpeg_er_init
av_cold int ff_mpeg_er_init(MpegEncContext *s)
Definition: mpeg_er.c:96
ff_init_scantable
av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: mpegvideo.c:82
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
ff_alternate_vertical_scan
const uint8_t ff_alternate_vertical_scan[64]
Definition: mpegvideodata.c:63
dsp_init
static av_cold void dsp_init(MpegEncContext *s)
Definition: mpegvideo.c:62
internal.h
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
FF_DEBUG_NOMC
#define FF_DEBUG_NOMC
Definition: avcodec.h:1389
idctdsp.h
avcodec.h
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:137
ret
ret
Definition: filter_design.txt:187
U
#define U(x)
Definition: vpx_arith.h:37
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
BufferPoolContext::motion_val_pool
struct AVRefStructPool * motion_val_pool
Definition: mpegpicture.h:48
ff_default_chroma_qscale_table
const uint8_t ff_default_chroma_qscale_table[32]
Definition: mpegvideodata.c:21
mem.h
AV_CODEC_EXPORT_DATA_MVS
#define AV_CODEC_EXPORT_DATA_MVS
Export motion vectors through frame side data.
Definition: avcodec.h:386
ScanTable
Scantable.
Definition: mpegvideo.h:46
av_refstruct_pool_uninit
static void av_refstruct_pool_uninit(AVRefStructPool **poolp)
Mark the pool as being available for freeing.
Definition: refstruct.h:292
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
ScanTable::permutated
uint8_t permutated[64]
Definition: mpegvideo.h:48
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
mpeg_er.h
imgutils.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
BufferPoolContext
Definition: mpegpicture.h:44
ff_mpv_free_context_frame
av_cold void ff_mpv_free_context_frame(MpegEncContext *s)
Frees and resets MpegEncContext fields depending on the resolution as well as the slice thread contex...
Definition: mpegvideo.c:421
h
h
Definition: vp9dsp_template.c:2070
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
BufferPoolContext::alloc_mb_width
int alloc_mb_width
mb_width used to allocate tables
Definition: mpegpicture.h:50
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:63
gray8
static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
Definition: mpegvideo.c:55
src
#define src
Definition: vp8dsp.c:248
ScanTable::raster_end
uint8_t raster_end[64]
Definition: mpegvideo.h:49