FFmpeg
•All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
mpeg12dec.c
Go to the documentation of this file.
1 /*
2  * MPEG-1/2 decoder
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2002-2013 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * MPEG-1/2 decoder
26  */
27 
28 #include "config_components.h"
29 
30 #define UNCHECKED_BITSTREAM_READER 1
31 #include <inttypes.h>
32 #include <stdatomic.h>
33 
34 #include "libavutil/attributes.h"
35 #include "libavutil/emms.h"
36 #include "libavutil/imgutils.h"
37 #include "libavutil/internal.h"
38 #include "libavutil/mem_internal.h"
39 #include "libavutil/reverse.h"
40 #include "libavutil/stereo3d.h"
41 #include "libavutil/timecode.h"
42 
43 #include "avcodec.h"
44 #include "codec_internal.h"
45 #include "decode.h"
46 #include "error_resilience.h"
47 #include "hwaccel_internal.h"
48 #include "hwconfig.h"
49 #include "idctdsp.h"
50 #include "mpeg_er.h"
51 #include "mpeg12.h"
52 #include "mpeg12codecs.h"
53 #include "mpeg12data.h"
54 #include "mpeg12dec.h"
55 #include "mpegutils.h"
56 #include "mpegvideo.h"
57 #include "mpegvideodata.h"
58 #include "mpegvideodec.h"
59 #include "profiles.h"
60 #include "startcode.h"
61 
62 #define A53_MAX_CC_COUNT 2000
63 
64 enum Mpeg2ClosedCaptionsFormat {
65  CC_FORMAT_AUTO,
66  CC_FORMAT_A53_PART4,
67  CC_FORMAT_SCTE20,
68  CC_FORMAT_DVD,
69  CC_FORMAT_DISH
70 };
71 
72 typedef struct Mpeg1Context {
73  MpegEncContext mpeg_enc_ctx;
74  AVPanScan pan_scan; /* some temporary storage for the panscan */
75  enum AVStereo3DType stereo3d_type;
76  int has_stereo3d;
77  AVBufferRef *a53_buf_ref;
78  enum Mpeg2ClosedCaptionsFormat cc_format;
79  uint8_t afd;
80  int has_afd;
81  int slice_count;
82  unsigned aspect_ratio_info;
83  int save_progressive_seq, save_chroma_format;
84  AVRational frame_rate_ext; /* MPEG-2 specific framerate modificator */
85  unsigned frame_rate_index;
86  int sync; /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */
87  int closed_gop;
88  int tmpgexs;
89  int first_slice;
90  int extradata_decoded;
91  int vbv_delay;
92  int64_t bit_rate;
93  int64_t timecode_frame_start; /*< GOP timecode frame start number, in non drop frame format */
94 } Mpeg1Context;
95 
96 /* as H.263, but only 17 codes */
97 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
98 {
99  int code, sign, val, shift;
100 
101  code = get_vlc2(&s->gb, ff_mv_vlc, MV_VLC_BITS, 2);
102  if (code == 0)
103  return pred;
104  if (code < 0)
105  return 0xffff;
106 
107  sign = get_bits1(&s->gb);
108  shift = fcode - 1;
109  val = code;
110  if (shift) {
111  val = (val - 1) << shift;
112  val |= get_bits(&s->gb, shift);
113  val++;
114  }
115  if (sign)
116  val = -val;
117  val += pred;
118 
119  /* modulo decoding */
120  return sign_extend(val, 5 + shift);
121 }
122 
123 #define MAX_INDEX (64 - 1)
124 #define check_scantable_index(ctx, x) \
125  do { \
126  if ((x) > MAX_INDEX) { \
127  av_log(ctx->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", \
128  ctx->mb_x, ctx->mb_y); \
129  return AVERROR_INVALIDDATA; \
130  } \
131  } while (0)
132 
133 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
134  int16_t *block, int n)
135 {
136  int level, i, j, run;
137  const uint8_t *const scantable = s->intra_scantable.permutated;
138  const uint16_t *quant_matrix = s->inter_matrix;
139  const int qscale = s->qscale;
140 
141  {
142  OPEN_READER(re, &s->gb);
143  i = -1;
144  // special case for first coefficient, no need to add second VLC table
145  UPDATE_CACHE(re, &s->gb);
146  if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
147  level = (3 * qscale * quant_matrix[0]) >> 5;
148  level = (level - 1) | 1;
149  if (GET_CACHE(re, &s->gb) & 0x40000000)
150  level = -level;
151  block[0] = level;
152  i++;
153  SKIP_BITS(re, &s->gb, 2);
154  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
155  goto end;
156  }
157  /* now quantify & encode AC coefficients */
158  for (;;) {
159  GET_RL_VLC(level, run, re, &s->gb, ff_mpeg1_rl_vlc,
160  TEX_VLC_BITS, 2, 0);
161 
162  if (level != 0) {
163  i += run;
164  if (i > MAX_INDEX)
165  break;
166  j = scantable[i];
167  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
168  level = (level - 1) | 1;
169  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
170  SHOW_SBITS(re, &s->gb, 1);
171  SKIP_BITS(re, &s->gb, 1);
172  } else {
173  /* escape */
174  run = SHOW_UBITS(re, &s->gb, 6) + 1;
175  LAST_SKIP_BITS(re, &s->gb, 6);
176  UPDATE_CACHE(re, &s->gb);
177  level = SHOW_SBITS(re, &s->gb, 8);
178  SKIP_BITS(re, &s->gb, 8);
179  if (level == -128) {
180  level = SHOW_UBITS(re, &s->gb, 8) - 256;
181  SKIP_BITS(re, &s->gb, 8);
182  } else if (level == 0) {
183  level = SHOW_UBITS(re, &s->gb, 8);
184  SKIP_BITS(re, &s->gb, 8);
185  }
186  i += run;
187  if (i > MAX_INDEX)
188  break;
189  j = scantable[i];
190  if (level < 0) {
191  level = -level;
192  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
193  level = (level - 1) | 1;
194  level = -level;
195  } else {
196  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
197  level = (level - 1) | 1;
198  }
199  }
200 
201  block[j] = level;
202  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
203  break;
204  UPDATE_CACHE(re, &s->gb);
205  }
206 end:
207  LAST_SKIP_BITS(re, &s->gb, 2);
208  CLOSE_READER(re, &s->gb);
209  }
210 
211  check_scantable_index(s, i);
212 
213  s->block_last_index[n] = i;
214  return 0;
215 }
216 
217 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
218  int16_t *block, int n)
219 {
220  int level, i, j, run;
221  const uint8_t *const scantable = s->intra_scantable.permutated;
222  const uint16_t *quant_matrix;
223  const int qscale = s->qscale;
224  int mismatch;
225 
226  mismatch = 1;
227 
228  {
229  OPEN_READER(re, &s->gb);
230  i = -1;
231  if (n < 4)
232  quant_matrix = s->inter_matrix;
233  else
234  quant_matrix = s->chroma_inter_matrix;
235 
236  // Special case for first coefficient, no need to add second VLC table.
237  UPDATE_CACHE(re, &s->gb);
238  if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
239  level = (3 * qscale * quant_matrix[0]) >> 5;
240  if (GET_CACHE(re, &s->gb) & 0x40000000)
241  level = -level;
242  block[0] = level;
243  mismatch ^= level;
244  i++;
245  SKIP_BITS(re, &s->gb, 2);
246  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
247  goto end;
248  }
249 
250  /* now quantify & encode AC coefficients */
251  for (;;) {
252  GET_RL_VLC(level, run, re, &s->gb, ff_mpeg1_rl_vlc,
253  TEX_VLC_BITS, 2, 0);
254 
255  if (level != 0) {
256  i += run;
257  if (i > MAX_INDEX)
258  break;
259  j = scantable[i];
260  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
261  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
262  SHOW_SBITS(re, &s->gb, 1);
263  SKIP_BITS(re, &s->gb, 1);
264  } else {
265  /* escape */
266  run = SHOW_UBITS(re, &s->gb, 6) + 1;
267  LAST_SKIP_BITS(re, &s->gb, 6);
268  UPDATE_CACHE(re, &s->gb);
269  level = SHOW_SBITS(re, &s->gb, 12);
270  SKIP_BITS(re, &s->gb, 12);
271 
272  i += run;
273  if (i > MAX_INDEX)
274  break;
275  j = scantable[i];
276  if (level < 0) {
277  level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
278  level = -level;
279  } else {
280  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
281  }
282  }
283 
284  mismatch ^= level;
285  block[j] = level;
286  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
287  break;
288  UPDATE_CACHE(re, &s->gb);
289  }
290 end:
291  LAST_SKIP_BITS(re, &s->gb, 2);
292  CLOSE_READER(re, &s->gb);
293  }
294  block[63] ^= (mismatch & 1);
295 
296  check_scantable_index(s, i);
297 
298  s->block_last_index[n] = i;
299  return 0;
300 }
301 
302 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
303  int16_t *block, int n)
304 {
305  int level, dc, diff, i, j, run;
306  int component;
307  const RL_VLC_ELEM *rl_vlc;
308  const uint8_t *const scantable = s->intra_scantable.permutated;
309  const uint16_t *quant_matrix;
310  const int qscale = s->qscale;
311  int mismatch;
312 
313  /* DC coefficient */
314  if (n < 4) {
315  quant_matrix = s->intra_matrix;
316  component = 0;
317  } else {
318  quant_matrix = s->chroma_intra_matrix;
319  component = (n & 1) + 1;
320  }
321  diff = decode_dc(&s->gb, component);
322  dc = s->last_dc[component];
323  dc += diff;
324  s->last_dc[component] = dc;
325  block[0] = dc * (1 << (3 - s->intra_dc_precision));
326  ff_tlog(s->avctx, "dc=%d\n", block[0]);
327  mismatch = block[0] ^ 1;
328  i = 0;
329  if (s->intra_vlc_format)
330  rl_vlc = ff_mpeg2_rl_vlc;
331  else
332  rl_vlc = ff_mpeg1_rl_vlc;
333 
334  {
335  OPEN_READER(re, &s->gb);
336  /* now quantify & encode AC coefficients */
337  for (;;) {
338  UPDATE_CACHE(re, &s->gb);
339  GET_RL_VLC(level, run, re, &s->gb, rl_vlc,
340  TEX_VLC_BITS, 2, 0);
341 
342  if (level == 127) {
343  break;
344  } else if (level != 0) {
345  i += run;
346  if (i > MAX_INDEX)
347  break;
348  j = scantable[i];
349  level = (level * qscale * quant_matrix[j]) >> 4;
350  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
351  SHOW_SBITS(re, &s->gb, 1);
352  LAST_SKIP_BITS(re, &s->gb, 1);
353  } else {
354  /* escape */
355  run = SHOW_UBITS(re, &s->gb, 6) + 1;
356  SKIP_BITS(re, &s->gb, 6);
357  level = SHOW_SBITS(re, &s->gb, 12);
358  LAST_SKIP_BITS(re, &s->gb, 12);
359  i += run;
360  if (i > MAX_INDEX)
361  break;
362  j = scantable[i];
363  if (level < 0) {
364  level = (-level * qscale * quant_matrix[j]) >> 4;
365  level = -level;
366  } else {
367  level = (level * qscale * quant_matrix[j]) >> 4;
368  }
369  }
370 
371  mismatch ^= level;
372  block[j] = level;
373  }
374  CLOSE_READER(re, &s->gb);
375  }
376  block[63] ^= mismatch & 1;
377 
378  check_scantable_index(s, i);
379 
380  return 0;
381 }
382 
383 static inline int get_dmv(MpegEncContext *s)
384 {
385  if (get_bits1(&s->gb))
386  return 1 - (get_bits1(&s->gb) << 1);
387  else
388  return 0;
389 }
390 
391 /* motion type (for MPEG-2) */
392 #define MT_FIELD 1
393 #define MT_FRAME 2
394 #define MT_16X8 2
395 #define MT_DMV 3
396 
397 static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
398 {
399  int i, j, k, cbp, val, mb_type, motion_type;
400  const int mb_block_count = 4 + (1 << s->chroma_format);
401  int ret;
402 
403  ff_tlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
404 
405  av_assert2(s->mb_skipped == 0);
406 
407  if (s->mb_skip_run-- != 0) {
408  if (s->pict_type == AV_PICTURE_TYPE_P) {
409  s->mb_skipped = 1;
410  s->cur_pic.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
411  MB_TYPE_SKIP | MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
412  } else {
413  int mb_type;
414 
415  if (s->mb_x)
416  mb_type = s->cur_pic.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];
417  else
418  // FIXME not sure if this is allowed in MPEG at all
419  mb_type = s->cur_pic.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1];
420  if (IS_INTRA(mb_type)) {
421  av_log(s->avctx, AV_LOG_ERROR, "skip with previntra\n");
422  return AVERROR_INVALIDDATA;
423  }
424  s->cur_pic.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
425  mb_type | MB_TYPE_SKIP;
426 
427  if ((s->mv[0][0][0] | s->mv[0][0][1] | s->mv[1][0][0] | s->mv[1][0][1]) == 0)
428  s->mb_skipped = 1;
429  }
430 
431  return 0;
432  }
433 
434  switch (s->pict_type) {
435  default:
436  case AV_PICTURE_TYPE_I:
437  if (get_bits1(&s->gb) == 0) {
438  if (get_bits1(&s->gb) == 0) {
439  av_log(s->avctx, AV_LOG_ERROR,
440  "Invalid mb type in I-frame at %d %d\n",
441  s->mb_x, s->mb_y);
442  return AVERROR_INVALIDDATA;
443  }
444  mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
445  } else {
446  mb_type = MB_TYPE_INTRA;
447  }
448  break;
449  case AV_PICTURE_TYPE_P:
450  mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc, MB_PTYPE_VLC_BITS, 1);
451  if (mb_type < 0) {
452  av_log(s->avctx, AV_LOG_ERROR,
453  "Invalid mb type in P-frame at %d %d\n", s->mb_x, s->mb_y);
454  return AVERROR_INVALIDDATA;
455  }
456  break;
457  case AV_PICTURE_TYPE_B:
458  mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc, MB_BTYPE_VLC_BITS, 1);
459  if (mb_type < 0) {
460  av_log(s->avctx, AV_LOG_ERROR,
461  "Invalid mb type in B-frame at %d %d\n", s->mb_x, s->mb_y);
462  return AVERROR_INVALIDDATA;
463  }
464  break;
465  }
466  ff_tlog(s->avctx, "mb_type=%x\n", mb_type);
467 // motion_type = 0; /* avoid warning */
468  if (IS_INTRA(mb_type)) {
469  s->bdsp.clear_blocks(s->block[0]);
470 
471  if (!s->chroma_y_shift)
472  s->bdsp.clear_blocks(s->block[6]);
473 
474  /* compute DCT type */
475  // FIXME: add an interlaced_dct coded var?
476  if (s->picture_structure == PICT_FRAME &&
477  !s->frame_pred_frame_dct)
478  s->interlaced_dct = get_bits1(&s->gb);
479 
480  if (IS_QUANT(mb_type))
481  s->qscale = mpeg_get_qscale(s);
482 
483  if (s->concealment_motion_vectors) {
484  /* just parse them */
485  if (s->picture_structure != PICT_FRAME)
486  skip_bits1(&s->gb); /* field select */
487 
488  s->mv[0][0][0] =
489  s->last_mv[0][0][0] =
490  s->last_mv[0][1][0] = mpeg_decode_motion(s, s->mpeg_f_code[0][0],
491  s->last_mv[0][0][0]);
492  s->mv[0][0][1] =
493  s->last_mv[0][0][1] =
494  s->last_mv[0][1][1] = mpeg_decode_motion(s, s->mpeg_f_code[0][1],
495  s->last_mv[0][0][1]);
496 
497  check_marker(s->avctx, &s->gb, "after concealment_motion_vectors");
498  } else {
499  /* reset mv prediction */
500  memset(s->last_mv, 0, sizeof(s->last_mv));
501  }
502  s->mb_intra = 1;
503 
504  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
505  for (i = 0; i < mb_block_count; i++)
506  if ((ret = mpeg2_decode_block_intra(s, s->block[i], i)) < 0)
507  return ret;
508  } else {
509  for (i = 0; i < 6; i++) {
510  ret = ff_mpeg1_decode_block_intra(&s->gb,
511  s->intra_matrix,
512  s->intra_scantable.permutated,
513  s->last_dc, s->block[i],
514  i, s->qscale);
515  if (ret < 0) {
516  av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n",
517  s->mb_x, s->mb_y);
518  return ret;
519  }
520  }
521  }
522  } else {
523  if (mb_type & MB_TYPE_ZERO_MV) {
524  av_assert2(mb_type & MB_TYPE_CBP);
525 
526  s->mv_dir = MV_DIR_FORWARD;
527  if (s->picture_structure == PICT_FRAME) {
528  if (s->picture_structure == PICT_FRAME
529  && !s->frame_pred_frame_dct)
530  s->interlaced_dct = get_bits1(&s->gb);
531  s->mv_type = MV_TYPE_16X16;
532  } else {
533  s->mv_type = MV_TYPE_FIELD;
534  mb_type |= MB_TYPE_INTERLACED;
535  s->field_select[0][0] = s->picture_structure - 1;
536  }
537 
538  if (IS_QUANT(mb_type))
539  s->qscale = mpeg_get_qscale(s);
540 
541  s->last_mv[0][0][0] = 0;
542  s->last_mv[0][0][1] = 0;
543  s->last_mv[0][1][0] = 0;
544  s->last_mv[0][1][1] = 0;
545  s->mv[0][0][0] = 0;
546  s->mv[0][0][1] = 0;
547  } else {
548  av_assert2(mb_type & MB_TYPE_BIDIR_MV);
549  // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
550  /* get additional motion vector type */
551  if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) {
552  motion_type = MT_FRAME;
553  } else {
554  motion_type = get_bits(&s->gb, 2);
555  if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
556  s->interlaced_dct = get_bits1(&s->gb);
557  }
558 
559  if (IS_QUANT(mb_type))
560  s->qscale = mpeg_get_qscale(s);
561 
562  /* motion vectors */
563  s->mv_dir = MB_TYPE_MV_2_MV_DIR(mb_type);
564  ff_tlog(s->avctx, "motion_type=%d\n", motion_type);
565  switch (motion_type) {
566  case MT_FRAME: /* or MT_16X8 */
567  if (s->picture_structure == PICT_FRAME) {
568  mb_type |= MB_TYPE_16x16;
569  s->mv_type = MV_TYPE_16X16;
570  for (i = 0; i < 2; i++) {
571  if (HAS_MV(mb_type, i)) {
572  /* MT_FRAME */
573  s->mv[i][0][0] =
574  s->last_mv[i][0][0] =
575  s->last_mv[i][1][0] =
576  mpeg_decode_motion(s, s->mpeg_f_code[i][0],
577  s->last_mv[i][0][0]);
578  s->mv[i][0][1] =
579  s->last_mv[i][0][1] =
580  s->last_mv[i][1][1] =
581  mpeg_decode_motion(s, s->mpeg_f_code[i][1],
582  s->last_mv[i][0][1]);
583  /* full_pel: only for MPEG-1 */
584  if (s->full_pel[i]) {
585  s->mv[i][0][0] *= 2;
586  s->mv[i][0][1] *= 2;
587  }
588  }
589  }
590  } else {
591  mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
592  s->mv_type = MV_TYPE_16X8;
593  for (i = 0; i < 2; i++) {
594  if (HAS_MV(mb_type, i)) {
595  /* MT_16X8 */
596  for (j = 0; j < 2; j++) {
597  s->field_select[i][j] = get_bits1(&s->gb);
598  for (k = 0; k < 2; k++) {
599  val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
600  s->last_mv[i][j][k]);
601  s->last_mv[i][j][k] = val;
602  s->mv[i][j][k] = val;
603  }
604  }
605  }
606  }
607  }
608  break;
609  case MT_FIELD:
610  s->mv_type = MV_TYPE_FIELD;
611  if (s->picture_structure == PICT_FRAME) {
612  mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
613  for (i = 0; i < 2; i++) {
614  if (HAS_MV(mb_type, i)) {
615  for (j = 0; j < 2; j++) {
616  s->field_select[i][j] = get_bits1(&s->gb);
617  val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
618  s->last_mv[i][j][0]);
619  s->last_mv[i][j][0] = val;
620  s->mv[i][j][0] = val;
621  ff_tlog(s->avctx, "fmx=%d\n", val);
622  val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
623  s->last_mv[i][j][1] >> 1);
624  s->last_mv[i][j][1] = 2 * val;
625  s->mv[i][j][1] = val;
626  ff_tlog(s->avctx, "fmy=%d\n", val);
627  }
628  }
629  }
630  } else {
631  av_assert0(!s->progressive_sequence);
632  mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
633  for (i = 0; i < 2; i++) {
634  if (HAS_MV(mb_type, i)) {
635  s->field_select[i][0] = get_bits1(&s->gb);
636  for (k = 0; k < 2; k++) {
637  val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
638  s->last_mv[i][0][k]);
639  s->last_mv[i][0][k] = val;
640  s->last_mv[i][1][k] = val;
641  s->mv[i][0][k] = val;
642  }
643  }
644  }
645  }
646  break;
647  case MT_DMV:
648  if (s->progressive_sequence){
649  av_log(s->avctx, AV_LOG_ERROR, "MT_DMV in progressive_sequence\n");
650  return AVERROR_INVALIDDATA;
651  }
652  s->mv_type = MV_TYPE_DMV;
653  for (i = 0; i < 2; i++) {
654  if (HAS_MV(mb_type, i)) {
655  int dmx, dmy, mx, my, m;
656  const int my_shift = s->picture_structure == PICT_FRAME;
657 
658  mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
659  s->last_mv[i][0][0]);
660  s->last_mv[i][0][0] = mx;
661  s->last_mv[i][1][0] = mx;
662  dmx = get_dmv(s);
663  my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
664  s->last_mv[i][0][1] >> my_shift);
665  dmy = get_dmv(s);
666 
667 
668  s->last_mv[i][0][1] = my * (1 << my_shift);
669  s->last_mv[i][1][1] = my * (1 << my_shift);
670 
671  s->mv[i][0][0] = mx;
672  s->mv[i][0][1] = my;
673  s->mv[i][1][0] = mx; // not used
674  s->mv[i][1][1] = my; // not used
675 
676  if (s->picture_structure == PICT_FRAME) {
677  mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
678 
679  // m = 1 + 2 * s->top_field_first;
680  m = s->top_field_first ? 1 : 3;
681 
682  /* top -> top pred */
683  s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
684  s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
685  m = 4 - m;
686  s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
687  s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
688  } else {
689  mb_type |= MB_TYPE_16x16;
690 
691  s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
692  s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
693  if (s->picture_structure == PICT_TOP_FIELD)
694  s->mv[i][2][1]--;
695  else
696  s->mv[i][2][1]++;
697  }
698  }
699  }
700  break;
701  default:
702  av_log(s->avctx, AV_LOG_ERROR,
703  "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
704  return AVERROR_INVALIDDATA;
705  }
706  }
707 
708  s->mb_intra = 0;
709  s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 128 << s->intra_dc_precision;
710  if (HAS_CBP(mb_type)) {
711  s->bdsp.clear_blocks(s->block[0]);
712 
713  cbp = get_vlc2(&s->gb, ff_mb_pat_vlc, MB_PAT_VLC_BITS, 1);
714  if (mb_block_count > 6) {
715  cbp *= 1 << mb_block_count - 6;
716  cbp |= get_bits(&s->gb, mb_block_count - 6);
717  s->bdsp.clear_blocks(s->block[6]);
718  }
719  if (cbp <= 0) {
720  av_log(s->avctx, AV_LOG_ERROR,
721  "invalid cbp %d at %d %d\n", cbp, s->mb_x, s->mb_y);
722  return AVERROR_INVALIDDATA;
723  }
724 
725  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
726  cbp <<= 12 - mb_block_count;
727 
728  for (i = 0; i < mb_block_count; i++) {
729  if (cbp & (1 << 11)) {
730  if ((ret = mpeg2_decode_block_non_intra(s, s->block[i], i)) < 0)
731  return ret;
732  } else {
733  s->block_last_index[i] = -1;
734  }
735  cbp += cbp;
736  }
737  } else {
738  for (i = 0; i < 6; i++) {
739  if (cbp & 32) {
740  if ((ret = mpeg1_decode_block_inter(s, s->block[i], i)) < 0)
741  return ret;
742  } else {
743  s->block_last_index[i] = -1;
744  }
745  cbp += cbp;
746  }
747  }
748  } else {
749  for (i = 0; i < 12; i++)
750  s->block_last_index[i] = -1;
751  }
752  }
753 
754  s->cur_pic.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;
755 
756  return 0;
757 }
758 
759 static av_cold int mpeg_decode_init(AVCodecContext *avctx)
760 {
761  Mpeg1Context *s = avctx->priv_data;
762  MpegEncContext *s2 = &s->mpeg_enc_ctx;
763  int ret;
764 
765  s2->out_format = FMT_MPEG1;
766 
767  if ( avctx->codec_tag != AV_RL32("VCR2")
768  && avctx->codec_tag != AV_RL32("BW10"))
769  avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
770  ret = ff_mpv_decode_init(s2, avctx);
771  if (ret < 0)
772  return ret;
773 
774  ff_mpeg12_init_vlcs();
775 
776  s2->chroma_format = CHROMA_420;
777  avctx->color_range = AVCOL_RANGE_MPEG;
778  return 0;
779 }
780 
781 static const enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[] = {
782 #if CONFIG_MPEG1_NVDEC_HWACCEL
783  AV_PIX_FMT_CUDA,
784 #endif
785 #if CONFIG_MPEG1_VDPAU_HWACCEL
786  AV_PIX_FMT_VDPAU,
787 #endif
788  AV_PIX_FMT_YUV420P,
789  AV_PIX_FMT_NONE
790 };
791 
792 static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = {
793 #if CONFIG_MPEG2_NVDEC_HWACCEL
794  AV_PIX_FMT_CUDA,
795 #endif
796 #if CONFIG_MPEG2_VDPAU_HWACCEL
797  AV_PIX_FMT_VDPAU,
798 #endif
799 #if CONFIG_MPEG2_DXVA2_HWACCEL
800  AV_PIX_FMT_DXVA2_VLD,
801 #endif
802 #if CONFIG_MPEG2_D3D11VA_HWACCEL
803  AV_PIX_FMT_D3D11VA_VLD,
804  AV_PIX_FMT_D3D11,
805 #endif
806 #if CONFIG_MPEG2_D3D12VA_HWACCEL
807  AV_PIX_FMT_D3D12,
808 #endif
809 #if CONFIG_MPEG2_VAAPI_HWACCEL
810  AV_PIX_FMT_VAAPI,
811 #endif
812 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
813  AV_PIX_FMT_VIDEOTOOLBOX,
814 #endif
815  AV_PIX_FMT_YUV420P,
816  AV_PIX_FMT_NONE
817 };
818 
819 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
820  AV_PIX_FMT_YUV422P,
821  AV_PIX_FMT_NONE
822 };
823 
824 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
825  AV_PIX_FMT_YUV444P,
826  AV_PIX_FMT_NONE
827 };
828 
829 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
830 {
831  Mpeg1Context *s1 = avctx->priv_data;
832  MpegEncContext *s = &s1->mpeg_enc_ctx;
833  const enum AVPixelFormat *pix_fmts;
834 
835  if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
836  return AV_PIX_FMT_GRAY8;
837 
838  if (s->chroma_format < CHROMA_422)
839  pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
840  mpeg1_hwaccel_pixfmt_list_420 :
841  mpeg2_hwaccel_pixfmt_list_420;
842  else if (s->chroma_format == CHROMA_422)
843  pix_fmts = mpeg12_pixfmt_list_422;
844  else
845  pix_fmts = mpeg12_pixfmt_list_444;
846 
847  return ff_get_format(avctx, pix_fmts);
848 }
849 
850 /* Call this function when we know all parameters.
851  * It may be called in different places for MPEG-1 and MPEG-2. */
852 static int mpeg_decode_postinit(AVCodecContext *avctx)
853 {
854  Mpeg1Context *s1 = avctx->priv_data;
855  MpegEncContext *s = &s1->mpeg_enc_ctx;
856  int ret;
857 
858  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
859  // MPEG-1 aspect
860  AVRational aspect_inv = av_d2q(ff_mpeg1_aspect[s1->aspect_ratio_info], 255);
861  avctx->sample_aspect_ratio = (AVRational) { aspect_inv.den, aspect_inv.num };
862  } else { // MPEG-2
863  // MPEG-2 aspect
864  if (s1->aspect_ratio_info > 1) {
865  AVRational dar =
866  av_mul_q(av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info],
867  (AVRational) { s1->pan_scan.width,
868  s1->pan_scan.height }),
869  (AVRational) { s->width, s->height });
870 
871  /* We ignore the spec here and guess a bit as reality does not
872  * match the spec, see for example res_change_ffmpeg_aspect.ts
873  * and sequence-display-aspect.mpg.
874  * issue1613, 621, 562 */
875  if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
876  (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
877  av_cmp_q(dar, (AVRational) { 16, 9 }))) {
878  s->avctx->sample_aspect_ratio =
879  av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info],
880  (AVRational) { s->width, s->height });
881  } else {
882  s->avctx->sample_aspect_ratio =
883  av_div_q(ff_mpeg2_aspect[s1->aspect_ratio_info],
884  (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
885 // issue1613 4/3 16/9 -> 16/9
886 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
887 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
888 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
889  ff_dlog(avctx, "aspect A %d/%d\n",
890  ff_mpeg2_aspect[s1->aspect_ratio_info].num,
891  ff_mpeg2_aspect[s1->aspect_ratio_info].den);
892  ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
893  s->avctx->sample_aspect_ratio.den);
894  }
895  } else {
896  s->avctx->sample_aspect_ratio =
897  ff_mpeg2_aspect[s1->aspect_ratio_info];
898  }
899  } // MPEG-2
900 
901  if (av_image_check_sar(s->width, s->height,
902  avctx->sample_aspect_ratio) < 0) {
903  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
904  avctx->sample_aspect_ratio.num,
905  avctx->sample_aspect_ratio.den);
906  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
907  }
908 
909  if (!s->context_initialized ||
910  avctx->coded_width != s->width ||
911  avctx->coded_height != s->height ||
912  s1->save_chroma_format != s->chroma_format ||
913  (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
914  0) {
915  if (s->context_initialized)
916  ff_mpv_common_end(s);
917 
918  ret = ff_set_dimensions(avctx, s->width, s->height);
919  if (ret < 0)
920  return ret;
921 
922  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s1->bit_rate &&
923  (s1->bit_rate != 0x3FFFF*400)) {
924  avctx->rc_max_rate = s1->bit_rate;
925  } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s1->bit_rate &&
926  (s1->bit_rate != 0x3FFFF*400 || s1->vbv_delay != 0xFFFF)) {
927  avctx->bit_rate = s1->bit_rate;
928  }
929  s1->save_progressive_seq = s->progressive_sequence;
930  s1->save_chroma_format = s->chroma_format;
931 
932  /* low_delay may be forced, in this case we will have B-frames
933  * that behave like P-frames. */
934  avctx->has_b_frames = !s->low_delay;
935 
936  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
937  // MPEG-1 fps
938  avctx->framerate = ff_mpeg12_frame_rate_tab[s1->frame_rate_index];
939  avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
940  } else { // MPEG-2
941  // MPEG-2 fps
942  av_reduce(&s->avctx->framerate.num,
943  &s->avctx->framerate.den,
944  ff_mpeg12_frame_rate_tab[s1->frame_rate_index].num * s1->frame_rate_ext.num,
945  ff_mpeg12_frame_rate_tab[s1->frame_rate_index].den * s1->frame_rate_ext.den,
946  1 << 30);
947 
948  switch (s->chroma_format) {
949  case CHROMA_420: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
950  case CHROMA_422:
951  case CHROMA_444: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
952  default: av_assert0(0);
953  }
954  } // MPEG-2
955 
956  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
957 
958  if ((ret = ff_mpv_common_init(s)) < 0)
959  return ret;
960  if (!s->avctx->lowres)
961  for (int i = 0; i < s->slice_context_count; i++)
962  ff_mpv_framesize_disable(&s->thread_context[i]->sc);
963  }
964  return 0;
965 }
966 
967 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
968  int buf_size)
969 {
970  Mpeg1Context *s1 = avctx->priv_data;
971  MpegEncContext *s = &s1->mpeg_enc_ctx;
972  int ref, f_code, vbv_delay, ret;
973 
974  ret = init_get_bits8(&s->gb, buf, buf_size);
975  if (ret < 0)
976  return ret;
977 
978  ref = get_bits(&s->gb, 10); /* temporal ref */
979  s->pict_type = get_bits(&s->gb, 3);
980  if (s->pict_type == 0 || s->pict_type > 3)
981  return AVERROR_INVALIDDATA;
982 
983  vbv_delay = get_bits(&s->gb, 16);
984  s1->vbv_delay = vbv_delay;
985  if (s->pict_type == AV_PICTURE_TYPE_P ||
986  s->pict_type == AV_PICTURE_TYPE_B) {
987  s->full_pel[0] = get_bits1(&s->gb);
988  f_code = get_bits(&s->gb, 3);
989  if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
990  return AVERROR_INVALIDDATA;
991  f_code += !f_code;
992  s->mpeg_f_code[0][0] = f_code;
993  s->mpeg_f_code[0][1] = f_code;
994  }
995  if (s->pict_type == AV_PICTURE_TYPE_B) {
996  s->full_pel[1] = get_bits1(&s->gb);
997  f_code = get_bits(&s->gb, 3);
998  if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
999  return AVERROR_INVALIDDATA;
1000  f_code += !f_code;
1001  s->mpeg_f_code[1][0] = f_code;
1002  s->mpeg_f_code[1][1] = f_code;
1003  }
1004 
1005  if (avctx->debug & FF_DEBUG_PICT_INFO)
1006  av_log(avctx, AV_LOG_DEBUG,
1007  "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1008 
1009  return 0;
1010 }
1011 
1012 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1013 {
1014  MpegEncContext *s = &s1->mpeg_enc_ctx;
1015  int horiz_size_ext, vert_size_ext;
1016  int bit_rate_ext;
1017 
1018  skip_bits(&s->gb, 1); /* profile and level esc*/
1019  s->avctx->profile = get_bits(&s->gb, 3);
1020  s->avctx->level = get_bits(&s->gb, 4);
1021  s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1022  s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1023 
1024  if (!s->chroma_format) {
1025  s->chroma_format = CHROMA_420;
1026  av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1027  }
1028 
1029  horiz_size_ext = get_bits(&s->gb, 2);
1030  vert_size_ext = get_bits(&s->gb, 2);
1031  s->width |= (horiz_size_ext << 12);
1032  s->height |= (vert_size_ext << 12);
1033  bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1034  s1->bit_rate += (bit_rate_ext << 18) * 400LL;
1035  check_marker(s->avctx, &s->gb, "after bit rate extension");
1036  s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1037 
1038  s->low_delay = get_bits1(&s->gb);
1039  if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1040  s->low_delay = 1;
1041 
1042  s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1043  s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1044 
1045  ff_dlog(s->avctx, "sequence extension\n");
1046  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1047 
1048  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1049  av_log(s->avctx, AV_LOG_DEBUG,
1050  "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n",
1051  s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1052  s->avctx->rc_buffer_size, s1->bit_rate);
1053 }
1054 
1055 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1056 {
1057  MpegEncContext *s = &s1->mpeg_enc_ctx;
1058  int color_description, w, h;
1059 
1060  skip_bits(&s->gb, 3); /* video format */
1061  color_description = get_bits1(&s->gb);
1062  if (color_description) {
1063  s->avctx->color_primaries = get_bits(&s->gb, 8);
1064  s->avctx->color_trc = get_bits(&s->gb, 8);
1065  s->avctx->colorspace = get_bits(&s->gb, 8);
1066  }
1067  w = get_bits(&s->gb, 14);
1068  skip_bits(&s->gb, 1); // marker
1069  h = get_bits(&s->gb, 14);
1070  // remaining 3 bits are zero padding
1071 
1072  s1->pan_scan.width = 16 * w;
1073  s1->pan_scan.height = 16 * h;
1074 
1075  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1076  av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1077 }
1078 
1079 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1080 {
1081  MpegEncContext *s = &s1->mpeg_enc_ctx;
1082  int i, nofco;
1083 
1084  nofco = 1;
1085  if (s->progressive_sequence) {
1086  if (s->repeat_first_field) {
1087  nofco++;
1088  if (s->top_field_first)
1089  nofco++;
1090  }
1091  } else {
1092  if (s->picture_structure == PICT_FRAME) {
1093  nofco++;
1094  if (s->repeat_first_field)
1095  nofco++;
1096  }
1097  }
1098  for (i = 0; i < nofco; i++) {
1099  s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1100  skip_bits(&s->gb, 1); // marker
1101  s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1102  skip_bits(&s->gb, 1); // marker
1103  }
1104 
1105  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1106  av_log(s->avctx, AV_LOG_DEBUG,
1107  "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1108  s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1109  s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1110  s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1111 }
1112 
1113 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1114  uint16_t matrix1[64], int intra)
1115 {
1116  int i;
1117 
1118  for (i = 0; i < 64; i++) {
1119  int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1120  int v = get_bits(&s->gb, 8);
1121  if (v == 0) {
1122  av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1123  return AVERROR_INVALIDDATA;
1124  }
1125  if (intra && i == 0 && v != 8) {
1126  av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1127  v = 8; // needed by pink.mpg / issue1046
1128  }
1129  matrix0[j] = v;
1130  if (matrix1)
1131  matrix1[j] = v;
1132  }
1133  return 0;
1134 }
1135 
1136 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1137 {
1138  ff_dlog(s->avctx, "matrix extension\n");
1139 
1140  if (get_bits1(&s->gb))
1141  load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1142  if (get_bits1(&s->gb))
1143  load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1144  if (get_bits1(&s->gb))
1145  load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1146  if (get_bits1(&s->gb))
1147  load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1148 }
1149 
1150 static int mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1151 {
1152  MpegEncContext *s = &s1->mpeg_enc_ctx;
1153 
1154  s->full_pel[0] = s->full_pel[1] = 0;
1155  s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1156  s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1157  s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1158  s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1159  s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1160  s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1161  s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1162  s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1163  if (!s->pict_type && s->context_initialized) {
1164  av_log(s->avctx, AV_LOG_ERROR, "Missing picture start code\n");
1165  if (s->avctx->err_recognition & AV_EF_EXPLODE)
1166  return AVERROR_INVALIDDATA;
1167  av_log(s->avctx, AV_LOG_WARNING, "Guessing pict_type from mpeg_f_code\n");
1168  if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1169  if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1170  s->pict_type = AV_PICTURE_TYPE_I;
1171  else
1172  s->pict_type = AV_PICTURE_TYPE_P;
1173  } else
1174  s->pict_type = AV_PICTURE_TYPE_B;
1175  }
1176 
1177  s->intra_dc_precision = get_bits(&s->gb, 2);
1178  s->picture_structure = get_bits(&s->gb, 2);
1179  s->top_field_first = get_bits1(&s->gb);
1180  s->frame_pred_frame_dct = get_bits1(&s->gb);
1181  s->concealment_motion_vectors = get_bits1(&s->gb);
1182  s->q_scale_type = get_bits1(&s->gb);
1183  s->intra_vlc_format = get_bits1(&s->gb);
1184  s->alternate_scan = get_bits1(&s->gb);
1185  s->repeat_first_field = get_bits1(&s->gb);
1186  s->chroma_420_type = get_bits1(&s->gb);
1187  s->progressive_frame = get_bits1(&s->gb);
1188 
1189  // We only initialize intra_scantable.permutated, as this is all we use.
1190  ff_permute_scantable(s->intra_scantable.permutated,
1191  s->alternate_scan ? ff_alternate_vertical_scan : ff_zigzag_direct,
1192  s->idsp.idct_permutation);
1193 
1194  /* composite display not parsed */
1195  ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1196  ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1197  ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1198  ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1199  ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1200  ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1201  ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1202  ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1203  ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1204 
1205  return 0;
1206 }
1207 
1208 static int mpeg_field_start(Mpeg1Context *s1, const uint8_t *buf, int buf_size)
1209 {
1210  MpegEncContext *s = &s1->mpeg_enc_ctx;
1211  AVCodecContext *avctx = s->avctx;
1212  int second_field = 0;
1213  int ret;
1214 
1215  if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
1216  if (s->mb_width * s->mb_height * 11LL / (33 * 2 * 8) > buf_size)
1217  return AVERROR_INVALIDDATA;
1218  }
1219 
1220  /* start frame decoding */
1221  if (s->first_field || s->picture_structure == PICT_FRAME) {
1222  AVFrameSideData *pan_scan;
1223 
1224  if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1225  return ret;
1226 
1227  if (s->picture_structure != PICT_FRAME) {
1228  s->cur_pic.ptr->f->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST *
1229  (s->picture_structure == PICT_TOP_FIELD);
1230 
1231  for (int i = 0; i < 3; i++) {
1232  if (s->picture_structure == PICT_BOTTOM_FIELD) {
1233  s->cur_pic.data[i] = FF_PTR_ADD(s->cur_pic.data[i],
1234  s->cur_pic.linesize[i]);
1235  }
1236  s->cur_pic.linesize[i] *= 2;
1237  }
1238  }
1239 
1240  ff_mpeg_er_frame_start(s);
1241 
1242  /* first check if we must repeat the frame */
1243  s->cur_pic.ptr->f->repeat_pict = 0;
1244  if (s->repeat_first_field) {
1245  if (s->progressive_sequence) {
1246  if (s->top_field_first)
1247  s->cur_pic.ptr->f->repeat_pict = 4;
1248  else
1249  s->cur_pic.ptr->f->repeat_pict = 2;
1250  } else if (s->progressive_frame) {
1251  s->cur_pic.ptr->f->repeat_pict = 1;
1252  }
1253  }
1254 
1255  ret = ff_frame_new_side_data(s->avctx, s->cur_pic.ptr->f,
1256  AV_FRAME_DATA_PANSCAN, sizeof(s1->pan_scan),
1257  &pan_scan);
1258  if (ret < 0)
1259  return ret;
1260  if (pan_scan)
1261  memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1262 
1263  if (s1->a53_buf_ref) {
1264  ret = ff_frame_new_side_data_from_buf(
1265  s->avctx, s->cur_pic.ptr->f, AV_FRAME_DATA_A53_CC,
1266  &s1->a53_buf_ref);
1267  if (ret < 0)
1268  return ret;
1269  }
1270 
1271  if (s1->has_stereo3d) {
1272  AVStereo3D *stereo = av_stereo3d_create_side_data(s->cur_pic.ptr->f);
1273  if (!stereo)
1274  return AVERROR(ENOMEM);
1275 
1276  stereo->type = s1->stereo3d_type;
1277  s1->has_stereo3d = 0;
1278  }
1279 
1280  if (s1->has_afd) {
1281  AVFrameSideData *sd;
1282  ret = ff_frame_new_side_data(s->avctx, s->cur_pic.ptr->f,
1283  AV_FRAME_DATA_AFD, 1, &sd);
1284  if (ret < 0)
1285  return ret;
1286  if (sd)
1287  *sd->data = s1->afd;
1288  s1->has_afd = 0;
1289  }
1290  } else { // second field
1291  second_field = 1;
1292  if (!s->cur_pic.ptr) {
1293  av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1294  return AVERROR_INVALIDDATA;
1295  }
1296 
1297  if (s->avctx->hwaccel) {
1298  if ((ret = FF_HW_SIMPLE_CALL(s->avctx, end_frame)) < 0) {
1299  av_log(avctx, AV_LOG_ERROR,
1300  "hardware accelerator failed to decode first field\n");
1301  return ret;
1302  }
1303  }
1304  ret = ff_mpv_alloc_dummy_frames(s);
1305  if (ret < 0)
1306  return ret;
1307 
1308  for (int i = 0; i < 3; i++) {
1309  s->cur_pic.data[i] = s->cur_pic.ptr->f->data[i];
1310  if (s->picture_structure == PICT_BOTTOM_FIELD)
1311  s->cur_pic.data[i] +=
1312  s->cur_pic.ptr->f->linesize[i];
1313  }
1314  }
1315 
1316  if (avctx->hwaccel) {
1317  if ((ret = FF_HW_CALL(avctx, start_frame, NULL, buf, buf_size)) < 0)
1318  return ret;
1319  } else if (s->codec_tag == MKTAG('V', 'C', 'R', '2')) {
1320  // Exchange UV
1321  FFSWAP(uint8_t*, s->cur_pic.data[1], s->cur_pic.data[2]);
1322  FFSWAP(ptrdiff_t, s->cur_pic.linesize[1], s->cur_pic.linesize[2]);
1323  if (!second_field) {
1324  FFSWAP(uint8_t*, s->next_pic.data[1], s->next_pic.data[2]);
1325  FFSWAP(ptrdiff_t, s->next_pic.linesize[1], s->next_pic.linesize[2]);
1326  FFSWAP(uint8_t*, s->last_pic.data[1], s->last_pic.data[2]);
1327  FFSWAP(ptrdiff_t, s->last_pic.linesize[1], s->last_pic.linesize[2]);
1328  }
1329  }
1330 
1331  return 0;
1332 }
1333 
1334 #define DECODE_SLICE_ERROR -1
1335 #define DECODE_SLICE_OK 0
1336 
1337 /**
1338  * Decode a slice.
1339  * MpegEncContext.mb_y must be set to the MB row from the startcode.
1340  * @return DECODE_SLICE_ERROR if the slice is damaged,
1341  * DECODE_SLICE_OK if this slice is OK
1342  */
1343 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1344  const uint8_t **buf, int buf_size)
1345 {
1346  AVCodecContext *avctx = s->avctx;
1347  const int lowres = s->avctx->lowres;
1348  const int field_pic = s->picture_structure != PICT_FRAME;
1349  int ret;
1350 
1351  s->resync_mb_x =
1352  s->resync_mb_y = -1;
1353 
1354  av_assert0(mb_y < s->mb_height);
1355 
1356  ret = init_get_bits8(&s->gb, *buf, buf_size);
1357  if (ret < 0)
1358  return ret;
1359 
1360  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1361  skip_bits(&s->gb, 3);
1362 
1363  ff_mpeg1_clean_buffers(s);
1364  s->interlaced_dct = 0;
1365 
1366  s->qscale = mpeg_get_qscale(s);
1367 
1368  if (s->qscale == 0) {
1369  av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1370  return AVERROR_INVALIDDATA;
1371  }
1372 
1373  /* extra slice info */
1374  if (skip_1stop_8data_bits(&s->gb) < 0)
1375  return AVERROR_INVALIDDATA;
1376 
1377  s->mb_x = 0;
1378 
1379  if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1380  skip_bits1(&s->gb);
1381  } else {
1382  while (get_bits_left(&s->gb) > 0) {
1383  int code = get_vlc2(&s->gb, ff_mbincr_vlc,
1384  MBINCR_VLC_BITS, 2);
1385  if (code < 0) {
1386  av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1387  return AVERROR_INVALIDDATA;
1388  }
1389  if (code >= 33) {
1390  if (code == 33)
1391  s->mb_x += 33;
1392  /* otherwise, stuffing, nothing to do */
1393  } else {
1394  s->mb_x += code;
1395  break;
1396  }
1397  }
1398  }
1399 
1400  if (s->mb_x >= (unsigned) s->mb_width) {
1401  av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1402  return AVERROR_INVALIDDATA;
1403  }
1404 
1405  if (avctx->hwaccel) {
1406  const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1407  int start_code = -1;
1408  buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1409  if (buf_end < *buf + buf_size)
1410  buf_end -= 4;
1411  s->mb_y = mb_y;
1412  if (FF_HW_CALL(avctx, decode_slice, buf_start, buf_end - buf_start) < 0)
1413  return DECODE_SLICE_ERROR;
1414  *buf = buf_end;
1415  return DECODE_SLICE_OK;
1416  }
1417 
1418  s->resync_mb_x = s->mb_x;
1419  s->resync_mb_y = s->mb_y = mb_y;
1420  s->mb_skip_run = 0;
1421  ff_init_block_index(s);
1422 
1423  if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1424  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1425  av_log(s->avctx, AV_LOG_DEBUG,
1426  "qp:%d fc:%2d%2d%2d%2d %c %s %s %s %s dc:%d pstruct:%d fdct:%d cmv:%d qtype:%d ivlc:%d rff:%d %s\n",
1427  s->qscale,
1428  s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1429  s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1430  s->pict_type == AV_PICTURE_TYPE_I ? 'I' :
1431  (s->pict_type == AV_PICTURE_TYPE_P ? 'P' :
1432  (s->pict_type == AV_PICTURE_TYPE_B ? 'B' : 'S')),
1433  s->progressive_sequence ? "ps" : "",
1434  s->progressive_frame ? "pf" : "",
1435  s->alternate_scan ? "alt" : "",
1436  s->top_field_first ? "top" : "",
1437  s->intra_dc_precision, s->picture_structure,
1438  s->frame_pred_frame_dct, s->concealment_motion_vectors,
1439  s->q_scale_type, s->intra_vlc_format,
1440  s->repeat_first_field, s->chroma_420_type ? "420" : "");
1441  }
1442  }
1443 
1444  for (;;) {
1445  if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1446  return ret;
1447 
1448  // Note motion_val is normally NULL unless we want to extract the MVs.
1449  if (s->cur_pic.motion_val[0]) {
1450  const int wrap = s->b8_stride;
1451  int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1452  int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1453  int motion_x, motion_y, dir, i;
1454 
1455  for (i = 0; i < 2; i++) {
1456  for (dir = 0; dir < 2; dir++) {
1457  if (s->mb_intra ||
1458  (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1459  motion_x = motion_y = 0;
1460  } else if (s->mv_type == MV_TYPE_16X16 ||
1461  (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1462  motion_x = s->mv[dir][0][0];
1463  motion_y = s->mv[dir][0][1];
1464  } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1465  motion_x = s->mv[dir][i][0];
1466  motion_y = s->mv[dir][i][1];
1467  }
1468 
1469  s->cur_pic.motion_val[dir][xy][0] = motion_x;
1470  s->cur_pic.motion_val[dir][xy][1] = motion_y;
1471  s->cur_pic.motion_val[dir][xy + 1][0] = motion_x;
1472  s->cur_pic.motion_val[dir][xy + 1][1] = motion_y;
1473  s->cur_pic.ref_index [dir][b8_xy] =
1474  s->cur_pic.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1475  av_assert2(s->field_select[dir][i] == 0 ||
1476  s->field_select[dir][i] == 1);
1477  }
1478  xy += wrap;
1479  b8_xy += 2;
1480  }
1481  }
1482 
1483  s->dest[0] += 16 >> lowres;
1484  s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1485  s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1486 
1487  ff_mpv_reconstruct_mb(s, s->block);
1488 
1489  if (++s->mb_x >= s->mb_width) {
1490  const int mb_size = 16 >> s->avctx->lowres;
1491  int left;
1492 
1493  ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1494 
1495  s->mb_x = 0;
1496  s->mb_y += 1 << field_pic;
1497 
1498  if (s->mb_y >= s->mb_height) {
1499  int left = get_bits_left(&s->gb);
1500  int is_d10 = s->chroma_format == CHROMA_422 &&
1501  s->pict_type == AV_PICTURE_TYPE_I &&
1502  avctx->profile == 0 && avctx->level == 5 &&
1503  s->intra_dc_precision == 2 &&
1504  s->q_scale_type == 1 && s->alternate_scan == 0 &&
1505  s->progressive_frame == 0
1506  /* vbv_delay == 0xBBB || 0xE10 */;
1507 
1508  if (left >= 32 && !is_d10) {
1509  GetBitContext gb = s->gb;
1510  align_get_bits(&gb);
1511  if (show_bits(&gb, 24) == 0x060E2B) {
1512  av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1513  is_d10 = 1;
1514  }
1515  if (left > 32 && show_bits_long(&gb, 32) == 0x201) {
1516  av_log(avctx, AV_LOG_DEBUG, "skipping m704 alpha (unsupported)\n");
1517  goto eos;
1518  }
1519  }
1520 
1521  if (left < 0 ||
1522  (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1523  ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1524  av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X at %d %d\n",
1525  left, left>0 ? show_bits(&s->gb, FFMIN(left, 23)) : 0, s->mb_x, s->mb_y);
1526  return AVERROR_INVALIDDATA;
1527  } else
1528  goto eos;
1529  }
1530  // There are some files out there which are missing the last slice
1531  // in cases where the slice is completely outside the visible
1532  // area, we detect this here instead of running into the end expecting
1533  // more data
1534  left = get_bits_left(&s->gb);
1535  if (s->mb_y >= ((s->height + 15) >> 4) &&
1536  !s->progressive_sequence &&
1537  left <= 25 &&
1538  left >= 0 &&
1539  s->mb_skip_run == -1 &&
1540  (!left || show_bits(&s->gb, left) == 0))
1541  goto eos;
1542 
1543  ff_init_block_index(s);
1544  }
1545 
1546  /* skip mb handling */
1547  if (s->mb_skip_run == -1) {
1548  /* read increment again */
1549  s->mb_skip_run = 0;
1550  for (;;) {
1551  int code = get_vlc2(&s->gb, ff_mbincr_vlc,
1552  MBINCR_VLC_BITS, 2);
1553  if (code < 0) {
1554  av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1555  return AVERROR_INVALIDDATA;
1556  }
1557  if (code >= 33) {
1558  if (code == 33) {
1559  s->mb_skip_run += 33;
1560  } else if (code == 35) {
1561  if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1562  av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1563  return AVERROR_INVALIDDATA;
1564  }
1565  goto eos; /* end of slice */
1566  }
1567  /* otherwise, stuffing, nothing to do */
1568  } else {
1569  s->mb_skip_run += code;
1570  break;
1571  }
1572  }
1573  if (s->mb_skip_run) {
1574  int i;
1575  if (s->pict_type == AV_PICTURE_TYPE_I) {
1576  av_log(s->avctx, AV_LOG_ERROR,
1577  "skipped MB in I-frame at %d %d\n", s->mb_x, s->mb_y);
1578  return AVERROR_INVALIDDATA;
1579  }
1580 
1581  /* skip mb */
1582  s->mb_intra = 0;
1583  for (i = 0; i < 12; i++)
1584  s->block_last_index[i] = -1;
1585  s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 128 << s->intra_dc_precision;
1586  if (s->picture_structure == PICT_FRAME)
1587  s->mv_type = MV_TYPE_16X16;
1588  else
1589  s->mv_type = MV_TYPE_FIELD;
1590  if (s->pict_type == AV_PICTURE_TYPE_P) {
1591  /* if P type, zero motion vector is implied */
1592  s->mv_dir = MV_DIR_FORWARD;
1593  s->mv[0][0][0] = s->mv[0][0][1] = 0;
1594  s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1595  s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1596  s->field_select[0][0] = (s->picture_structure - 1) & 1;
1597  } else {
1598  /* if B type, reuse previous vectors and directions */
1599  s->mv[0][0][0] = s->last_mv[0][0][0];
1600  s->mv[0][0][1] = s->last_mv[0][0][1];
1601  s->mv[1][0][0] = s->last_mv[1][0][0];
1602  s->mv[1][0][1] = s->last_mv[1][0][1];
1603  s->field_select[0][0] = (s->picture_structure - 1) & 1;
1604  s->field_select[1][0] = (s->picture_structure - 1) & 1;
1605  }
1606  }
1607  }
1608  }
1609 eos: // end of slice
1610  if (get_bits_left(&s->gb) < 0) {
1611  av_log(s->avctx, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
1612  return AVERROR_INVALIDDATA;
1613  }
1614  *buf += (get_bits_count(&s->gb) - 1) / 8;
1615  ff_dlog(s->avctx, "Slice start:%d %d end:%d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1616  return 0;
1617 }
1618 
1619 static int slice_decode_thread(AVCodecContext *c, void *arg)
1620 {
1621  MpegEncContext *s = *(void **) arg;
1622  const uint8_t *buf = s->gb.buffer;
1623  int mb_y = s->start_mb_y;
1624  const int field_pic = s->picture_structure != PICT_FRAME;
1625 
1626  s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
1627 
1628  for (;;) {
1629  uint32_t start_code;
1630  int ret;
1631 
1632  ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
1633  emms_c();
1634  ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
1635  ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
1636  s->start_mb_y, s->end_mb_y, s->er.error_count);
1637  if (ret < 0) {
1638  if (c->err_recognition & AV_EF_EXPLODE)
1639  return ret;
1640  if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
1641  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
1642  s->mb_x, s->mb_y,
1643  ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
1644  } else {
1645  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
1646  s->mb_x - 1, s->mb_y,
1647  ER_AC_END | ER_DC_END | ER_MV_END);
1648  }
1649 
1650  if (s->mb_y == s->end_mb_y)
1651  return 0;
1652 
1653  start_code = -1;
1654  buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
1655  if (start_code < SLICE_MIN_START_CODE || start_code > SLICE_MAX_START_CODE)
1656  return AVERROR_INVALIDDATA;
1657  mb_y = start_code - SLICE_MIN_START_CODE;
1658  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1659  mb_y += (*buf&0xE0)<<2;
1660  mb_y <<= field_pic;
1661  if (s->picture_structure == PICT_BOTTOM_FIELD)
1662  mb_y++;
1663  if (mb_y >= s->end_mb_y)
1664  return AVERROR_INVALIDDATA;
1665  }
1666 }
1667 
1668 /**
1669  * Handle slice ends.
1670  * @return 1 if it seems to be the last slice
1671  */
1672 static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)
1673 {
1674  Mpeg1Context *s1 = avctx->priv_data;
1675  MpegEncContext *s = &s1->mpeg_enc_ctx;
1676 
1677  if (!s->context_initialized || !s->cur_pic.ptr)
1678  return 0;
1679 
1680  if (s->avctx->hwaccel) {
1681  int ret = FF_HW_SIMPLE_CALL(s->avctx, end_frame);
1682  if (ret < 0) {
1683  av_log(avctx, AV_LOG_ERROR,
1684  "hardware accelerator failed to decode picture\n");
1685  return ret;
1686  }
1687  }
1688 
1689  /* end of slice reached */
1690  if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
1691  /* end of image */
1692 
1693  ff_er_frame_end(&s->er, NULL);
1694 
1695  ff_mpv_frame_end(s);
1696 
1697  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1698  int ret = av_frame_ref(pict, s->cur_pic.ptr->f);
1699  if (ret < 0)
1700  return ret;
1701  ff_print_debug_info(s, s->cur_pic.ptr, pict);
1702  ff_mpv_export_qp_table(s, pict, s->cur_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG2);
1703  *got_output = 1;
1704  } else {
1705  /* latency of 1 frame for I- and P-frames */
1706  if (s->last_pic.ptr && !s->last_pic.ptr->dummy) {
1707  int ret = av_frame_ref(pict, s->last_pic.ptr->f);
1708  if (ret < 0)
1709  return ret;
1710  ff_print_debug_info(s, s->last_pic.ptr, pict);
1711  ff_mpv_export_qp_table(s, pict, s->last_pic.ptr, FF_MPV_QSCALE_TYPE_MPEG2);
1712  *got_output = 1;
1713  }
1714  }
1715 
1716  return 1;
1717  } else {
1718  return 0;
1719  }
1720 }
1721 
1722 static int mpeg1_decode_sequence(AVCodecContext *avctx,
1723  const uint8_t *buf, int buf_size)
1724 {
1725  Mpeg1Context *s1 = avctx->priv_data;
1726  MpegEncContext *s = &s1->mpeg_enc_ctx;
1727  int width, height;
1728  int i, v, j;
1729 
1730  int ret = init_get_bits8(&s->gb, buf, buf_size);
1731  if (ret < 0)
1732  return ret;
1733 
1734  width = get_bits(&s->gb, 12);
1735  height = get_bits(&s->gb, 12);
1736  if (width == 0 || height == 0) {
1737  av_log(avctx, AV_LOG_WARNING,
1738  "Invalid horizontal or vertical size value.\n");
1739  if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
1740  return AVERROR_INVALIDDATA;
1741  }
1742  s1->aspect_ratio_info = get_bits(&s->gb, 4);
1743  if (s1->aspect_ratio_info == 0) {
1744  av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
1745  if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
1746  return AVERROR_INVALIDDATA;
1747  }
1748  s1->frame_rate_index = get_bits(&s->gb, 4);
1749  if (s1->frame_rate_index == 0 || s1->frame_rate_index > 13) {
1750  av_log(avctx, AV_LOG_WARNING,
1751  "frame_rate_index %d is invalid\n", s1->frame_rate_index);
1752  s1->frame_rate_index = 1;
1753  }
1754  s1->bit_rate = get_bits(&s->gb, 18) * 400;
1755  if (check_marker(s->avctx, &s->gb, "in sequence header") == 0) {
1756  return AVERROR_INVALIDDATA;
1757  }
1758 
1759  s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
1760  skip_bits(&s->gb, 1);
1761 
1762  /* get matrix */
1763  if (get_bits1(&s->gb)) {
1764  load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1765  } else {
1766  for (i = 0; i < 64; i++) {
1767  j = s->idsp.idct_permutation[i];
1768  v = ff_mpeg1_default_intra_matrix[i];
1769  s->intra_matrix[j] = v;
1770  s->chroma_intra_matrix[j] = v;
1771  }
1772  }
1773  if (get_bits1(&s->gb)) {
1774  load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1775  } else {
1776  for (i = 0; i < 64; i++) {
1777  int j = s->idsp.idct_permutation[i];
1778  v = ff_mpeg1_default_non_intra_matrix[i];
1779  s->inter_matrix[j] = v;
1780  s->chroma_inter_matrix[j] = v;
1781  }
1782  }
1783 
1784  if (show_bits(&s->gb, 23) != 0) {
1785  av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
1786  return AVERROR_INVALIDDATA;
1787  }
1788 
1789  s->width = width;
1790  s->height = height;
1791 
1792  /* We set MPEG-2 parameters so that it emulates MPEG-1. */
1793  s->progressive_sequence = 1;
1794  s->progressive_frame = 1;
1795  s->picture_structure = PICT_FRAME;
1796  s->first_field = 0;
1797  s->frame_pred_frame_dct = 1;
1798  s->chroma_format = CHROMA_420;
1799  s->codec_id =
1800  s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
1801  if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1802  s->low_delay = 1;
1803 
1804  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1805  av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
1806  s->avctx->rc_buffer_size, s1->bit_rate, s1->aspect_ratio_info);
1807 
1808  return 0;
1809 }
1810 
1811 static int vcr2_init_sequence(AVCodecContext *avctx)
1812 {
1813  Mpeg1Context *s1 = avctx->priv_data;
1814  MpegEncContext *s = &s1->mpeg_enc_ctx;
1815  int i, v, ret;
1816 
1817  /* start new MPEG-1 context decoding */
1818  if (s->context_initialized)
1819  ff_mpv_common_end(s);
1820 
1821  s->width = avctx->coded_width;
1822  s->height = avctx->coded_height;
1823  avctx->has_b_frames = 0; // true?
1824  s->low_delay = 1;
1825 
1826  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1827 
1828  if ((ret = ff_mpv_common_init(s)) < 0)
1829  return ret;
1830  if (!s->avctx->lowres)
1831  for (int i = 0; i < s->slice_context_count; i++)
1832  ff_mpv_framesize_disable(&s->thread_context[i]->sc);
1833 
1834  for (i = 0; i < 64; i++) {
1835  int j = s->idsp.idct_permutation[i];
1836  v = ff_mpeg1_default_intra_matrix[i];
1837  s->intra_matrix[j] = v;
1838  s->chroma_intra_matrix[j] = v;
1839 
1840  v = ff_mpeg1_default_non_intra_matrix[i];
1841  s->inter_matrix[j] = v;
1842  s->chroma_inter_matrix[j] = v;
1843  }
1844 
1845  s->progressive_sequence = 1;
1846  s->progressive_frame = 1;
1847  s->picture_structure = PICT_FRAME;
1848  s->first_field = 0;
1849  s->frame_pred_frame_dct = 1;
1850  s->chroma_format = CHROMA_420;
1851  if (s->codec_tag == AV_RL32("BW10")) {
1852  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
1853  } else {
1854  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1855  }
1856  s1->save_progressive_seq = s->progressive_sequence;
1857  s1->save_chroma_format = s->chroma_format;
1858  return 0;
1859 }
1860 
1861 static void mpeg_set_cc_format(AVCodecContext *avctx, enum Mpeg2ClosedCaptionsFormat format,
1862  const char *label)
1863 {
1864  Mpeg1Context *s1 = avctx->priv_data;
1865 
1866  av_assert2(format != CC_FORMAT_AUTO);
1867 
1868  if (!s1->cc_format) {
1869  s1->cc_format = format;
1870 
1871  av_log(avctx, AV_LOG_DEBUG, "CC: first seen substream is %s format\n", label);
1872  }
1873 
1874 #if FF_API_CODEC_PROPS
1875 FF_DISABLE_DEPRECATION_WARNINGS
1876  avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
1877 FF_ENABLE_DEPRECATION_WARNINGS
1878 #endif
1879 }
1880 
1881 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
1882  const uint8_t *p, int buf_size)
1883 {
1884  Mpeg1Context *s1 = avctx->priv_data;
1885 
1886  if ((!s1->cc_format || s1->cc_format == CC_FORMAT_A53_PART4) &&
1887  buf_size >= 6 &&
1888  p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
1889  p[4] == 3 && (p[5] & 0x40)) {
1890  /* extract A53 Part 4 CC data */
1891  int cc_count = p[5] & 0x1f;
1892  if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
1893  int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
1894  const uint64_t new_size = (old_size + cc_count
1895  * UINT64_C(3));
1896  int ret;
1897 
1898  if (new_size > 3*A53_MAX_CC_COUNT)
1899  return AVERROR(EINVAL);
1900 
1901  ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
1902  if (ret >= 0)
1903  memcpy(s1->a53_buf_ref->data + old_size, p + 7, cc_count * UINT64_C(3));
1904 
1905  mpeg_set_cc_format(avctx, CC_FORMAT_A53_PART4, "A/53 Part 4");
1906  }
1907  return 1;
1908  } else if ((!s1->cc_format || s1->cc_format == CC_FORMAT_SCTE20) &&
1909  buf_size >= 2 &&
1910  p[0] == 0x03 && (p[1]&0x7f) == 0x01) {
1911  /* extract SCTE-20 CC data */
1912  GetBitContext gb;
1913  int cc_count = 0;
1914  int i, ret;
1915 
1916  ret = init_get_bits8(&gb, p + 2, buf_size - 2);
1917  if (ret < 0)
1918  return ret;
1919  cc_count = get_bits(&gb, 5);
1920  if (cc_count > 0) {
1921  int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
1922  const uint64_t new_size = (old_size + cc_count
1923  * UINT64_C(3));
1924  if (new_size > 3*A53_MAX_CC_COUNT)
1925  return AVERROR(EINVAL);
1926 
1927  ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
1928  if (ret >= 0) {
1929  uint8_t field, cc1, cc2;
1930  uint8_t *cap = s1->a53_buf_ref->data + old_size;
1931 
1932  memset(cap, 0, cc_count * 3);
1933  for (i = 0; i < cc_count && get_bits_left(&gb) >= 26; i++) {
1934  skip_bits(&gb, 2); // priority
1935  field = get_bits(&gb, 2);
1936  skip_bits(&gb, 5); // line_offset
1937  cc1 = get_bits(&gb, 8);
1938  cc2 = get_bits(&gb, 8);
1939  skip_bits(&gb, 1); // marker
1940 
1941  if (!field) { // forbidden
1942  cap[0] = cap[1] = cap[2] = 0x00;
1943  } else {
1944  field = (field == 2 ? 1 : 0);
1945  if (!s1->mpeg_enc_ctx.top_field_first) field = !field;
1946  cap[0] = 0x04 | field;
1947  cap[1] = ff_reverse[cc1];
1948  cap[2] = ff_reverse[cc2];
1949  }
1950  cap += 3;
1951  }
1952  }
1953 
1954  mpeg_set_cc_format(avctx, CC_FORMAT_SCTE20, "SCTE-20");
1955  }
1956  return 1;
1957  } else if ((!s1->cc_format || s1->cc_format == CC_FORMAT_DVD) &&
1958  buf_size >= 11 &&
1959  p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
1960  /* extract DVD CC data
1961  *
1962  * uint32_t user_data_start_code 0x000001B2 (big endian)
1963  * uint16_t user_identifier 0x4343 "CC"
1964  * uint8_t user_data_type_code 0x01
1965  * uint8_t caption_block_size 0xF8
1966  * uint8_t
1967  * bit 7 caption_odd_field_first 1=odd field (CC1/CC2) first 0=even field (CC3/CC4) first
1968  * bit 6 caption_filler 0
1969  * bit 5:1 caption_block_count number of caption blocks (pairs of caption words = frames). Most DVDs use 15 per start of GOP.
1970  * bit 0 caption_extra_field_added 1=one additional caption word
1971  *
1972  * struct caption_field_block {
1973  * uint8_t
1974  * bit 7:1 caption_filler 0x7F (all 1s)
1975  * bit 0 caption_field_odd 1=odd field (this is CC1/CC2) 0=even field (this is CC3/CC4)
1976  * uint8_t caption_first_byte
1977  * uint8_t caption_second_byte
1978  * } caption_block[(caption_block_count * 2) + caption_extra_field_added];
1979  *
1980  * Some DVDs encode caption data for both fields with caption_field_odd=1. The only way to decode the fields
1981  * correctly is to start on the field indicated by caption_odd_field_first and count between odd/even fields.
1982  * Don't assume that the first caption word is the odd field. There do exist MPEG files in the wild that start
1983  * on the even field. There also exist DVDs in the wild that encode an odd field count and the
1984  * caption_extra_field_added/caption_odd_field_first bits change per packet to allow that. */
1985  int cc_count = 0;
1986  int i, ret;
1987  // There is a caption count field in the data, but it is often
1988  // incorrect. So count the number of captions present.
1989  for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
1990  cc_count++;
1991  // Transform the DVD format into A53 Part 4 format
1992  if (cc_count > 0) {
1993  int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
1994  const uint64_t new_size = (old_size + cc_count
1995  * UINT64_C(6));
1996  if (new_size > 3*A53_MAX_CC_COUNT)
1997  return AVERROR(EINVAL);
1998 
1999  ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
2000  if (ret >= 0) {
2001  uint8_t field1 = !!(p[4] & 0x80);
2002  uint8_t *cap = s1->a53_buf_ref->data + old_size;
2003  p += 5;
2004  for (i = 0; i < cc_count; i++) {
2005  cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2006  cap[1] = p[1];
2007  cap[2] = p[2];
2008  cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2009  cap[4] = p[4];
2010  cap[5] = p[5];
2011  cap += 6;
2012  p += 6;
2013  }
2014  }
2015 
2016  mpeg_set_cc_format(avctx, CC_FORMAT_DVD, "DVD");
2017  }
2018  return 1;
2019  } else if ((!s1->cc_format || s1->cc_format == CC_FORMAT_DISH) &&
2020  buf_size >= 12 &&
2021  p[0] == 0x05 && p[1] == 0x02) {
2022  /* extract Dish Network CC data */
2023  const uint8_t cc_header = 0xf8 | 0x04 /* valid */ | 0x00 /* line 21 field 1 */;
2024  uint8_t cc_data[4] = {0};
2025  int cc_count = 0;
2026  uint8_t cc_type = p[7];
2027  p += 8;
2028  buf_size -= 8;
2029 
2030  if (cc_type == 0x05 && buf_size >= 7) {
2031  cc_type = p[6];
2032  p += 7;
2033  buf_size -= 7;
2034  }
2035 
2036  if (cc_type == 0x02 && buf_size >= 4) { /* 2-byte caption, can be repeated */
2037  cc_count = 1;
2038  cc_data[0] = p[1];
2039  cc_data[1] = p[2];
2040  cc_type = p[3];
2041 
2042  /* Only repeat characters when the next type flag
2043  * is 0x04 and the characters are repeatable (i.e., less than
2044  * 32 with the parity stripped).
2045  */
2046  if (cc_type == 0x04 && (cc_data[0] & 0x7f) < 32) {
2047  cc_count = 2;
2048  cc_data[2] = cc_data[0];
2049  cc_data[3] = cc_data[1];
2050  }
2051  } else if (cc_type == 0x04 && buf_size >= 5) { /* 4-byte caption, not repeated */
2052  cc_count = 2;
2053  cc_data[0] = p[1];
2054  cc_data[1] = p[2];
2055  cc_data[2] = p[3];
2056  cc_data[3] = p[4];
2057  }
2058 
2059  if (cc_count > 0) {
2060  int ret;
2061  int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
2062  const uint64_t new_size = (old_size + cc_count * UINT64_C(3));
2063  if (new_size > 3 * A53_MAX_CC_COUNT)
2064  return AVERROR(EINVAL);
2065 
2066  ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
2067  if (ret >= 0) {
2068  uint8_t *cap = s1->a53_buf_ref->data + old_size;
2069  cap[0] = cc_header;
2070  cap[1] = cc_data[0];
2071  cap[2] = cc_data[1];
2072  if (cc_count == 2) {
2073  cap[3] = cc_header;
2074  cap[4] = cc_data[2];
2075  cap[5] = cc_data[3];
2076  }
2077  }
2078 
2079  mpeg_set_cc_format(avctx, CC_FORMAT_DISH, "Dish Network");
2080  }
2081  return 1;
2082  }
2083  return 0;
2084 }
2085 
2086 static void mpeg_decode_user_data(AVCodecContext *avctx,
2087  const uint8_t *p, int buf_size)
2088 {
2089  Mpeg1Context *s = avctx->priv_data;
2090  const uint8_t *buf_end = p + buf_size;
2091  Mpeg1Context *s1 = avctx->priv_data;
2092 
2093 #if 0
2094  int i;
2095  for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2096  av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2097  }
2098  av_log(avctx, AV_LOG_ERROR, "\n");
2099 #endif
2100 
2101  if (buf_size > 29){
2102  int i;
2103  for(i=0; i<20; i++)
2104  if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2105  s->tmpgexs= 1;
2106  }
2107  }
2108  /* we parse the DTG active format information */
2109  if (buf_end - p >= 5 &&
2110  p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2111  int flags = p[4];
2112  p += 5;
2113  if (flags & 0x80) {
2114  /* skip event id */
2115  p += 2;
2116  }
2117  if (flags & 0x40) {
2118  if (buf_end - p < 1)
2119  return;
2120  s1->has_afd = 1;
2121  s1->afd = p[0] & 0x0f;
2122  }
2123  } else if (buf_end - p >= 6 &&
2124  p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2125  p[4] == 0x03) { // S3D_video_format_length
2126  // the 0x7F mask ignores the reserved_bit value
2127  const uint8_t S3D_video_format_type = p[5] & 0x7F;
2128 
2129  if (S3D_video_format_type == 0x03 ||
2130  S3D_video_format_type == 0x04 ||
2131  S3D_video_format_type == 0x08 ||
2132  S3D_video_format_type == 0x23) {
2133 
2134  s1->has_stereo3d = 1;
2135 
2136  switch (S3D_video_format_type) {
2137  case 0x03:
2138  s1->stereo3d_type = AV_STEREO3D_SIDEBYSIDE;
2139  break;
2140  case 0x04:
2141  s1->stereo3d_type = AV_STEREO3D_TOPBOTTOM;
2142  break;
2143  case 0x08:
2144  s1->stereo3d_type = AV_STEREO3D_2D;
2145  break;
2146  case 0x23:
2147  s1->stereo3d_type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2148  break;
2149  }
2150  }
2151  } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2152  return;
2153  }
2154 }
2155 
2156 static int mpeg_decode_gop(AVCodecContext *avctx,
2157  const uint8_t *buf, int buf_size)
2158 {
2159  Mpeg1Context *s1 = avctx->priv_data;
2160  MpegEncContext *s = &s1->mpeg_enc_ctx;
2161  int broken_link;
2162  int64_t tc;
2163 
2164  int ret = init_get_bits8(&s->gb, buf, buf_size);
2165  if (ret < 0)
2166  return ret;
2167 
2168  tc = s1->timecode_frame_start = get_bits(&s->gb, 25);
2169 
2170  s1->closed_gop = get_bits1(&s->gb);
2171  /* broken_link indicates that after editing the
2172  * reference frames of the first B-Frames after GOP I-Frame
2173  * are missing (open gop) */
2174  broken_link = get_bits1(&s->gb);
2175 
2176  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2177  char tcbuf[AV_TIMECODE_STR_SIZE];
2178  av_timecode_make_mpeg_tc_string(tcbuf, tc);
2179  av_log(s->avctx, AV_LOG_DEBUG,
2180  "GOP (%s) closed_gop=%d broken_link=%d\n",
2181  tcbuf, s1->closed_gop, broken_link);
2182  }
2183 
2184  return 0;
2185 }
2186 
2187 static void mpeg12_execute_slice_threads(AVCodecContext *avctx,
2188  Mpeg1Context *const s)
2189 {
2190  if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2191  !avctx->hwaccel) {
2192  MpegEncContext *const s2 = &s->mpeg_enc_ctx;
2193  int error_count = 0;
2194 
2195  avctx->execute(avctx, slice_decode_thread,
2196  s2->thread_context, NULL,
2197  s->slice_count, sizeof(void *));
2198 
2199  for (int i = 0; i < s->slice_count; i++) {
2200  MpegEncContext *const slice = s2->thread_context[i];
2201  int slice_err = atomic_load_explicit(&slice->er.error_count,
2202  memory_order_relaxed);
2203  // error_count can get set to INT_MAX on serious errors.
2204  // So use saturated addition.
2205  if ((unsigned)slice_err > INT_MAX - error_count) {
2206  error_count = INT_MAX;
2207  break;
2208  }
2209  error_count += slice_err;
2210  }
2211  atomic_store_explicit(&s2->er.error_count, error_count,
2212  memory_order_relaxed);
2213  }
2214 }
2215 
2216 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2217  int *got_output, const uint8_t *buf, int buf_size)
2218 {
2219  Mpeg1Context *s = avctx->priv_data;
2220  MpegEncContext *s2 = &s->mpeg_enc_ctx;
2221  const uint8_t *buf_ptr = buf;
2222  const uint8_t *buf_end = buf + buf_size;
2223  int ret, input_size;
2224  int last_code = 0, skip_frame = 0;
2225  int picture_start_code_seen = 0;
2226 
2227  for (;;) {
2228  /* find next start code */
2229  uint32_t start_code = -1;
2230  buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2231  if (start_code > 0x1ff) {
2232  if (!skip_frame) {
2233  mpeg12_execute_slice_threads(avctx, s);
2234 
2235  ret = slice_end(avctx, picture, got_output);
2236  if (ret < 0)
2237  return ret;
2238  }
2239  s2->pict_type = 0;
2240 
2241  if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2242  return AVERROR_INVALIDDATA;
2243 
2244  return FFMAX(0, buf_ptr - buf);
2245  }
2246 
2247  input_size = buf_end - buf_ptr;
2248 
2249  if (avctx->debug & FF_DEBUG_STARTCODE)
2250  av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2251  start_code, buf_ptr - buf, input_size);
2252 
2253  /* prepare data for next start code */
2254  switch (start_code) {
2255  case SEQ_START_CODE:
2256  if (last_code == 0) {
2257  mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2258  if (buf != avctx->extradata)
2259  s->sync = 1;
2260  } else {
2261  av_log(avctx, AV_LOG_ERROR,
2262  "ignoring SEQ_START_CODE after %X\n", last_code);
2263  if (avctx->err_recognition & AV_EF_EXPLODE)
2264  return AVERROR_INVALIDDATA;
2265  }
2266  break;
2267 
2268  case PICTURE_START_CODE:
2269  if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2270  /* If it's a frame picture, there can't be more than one picture header.
2271  Yet, it does happen and we need to handle it. */
2272  av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2273  break;
2274  }
2275  picture_start_code_seen = 1;
2276 
2277  if (buf == avctx->extradata && avctx->codec_tag == AV_RL32("AVmp")) {
2278  av_log(avctx, AV_LOG_WARNING, "ignoring picture start code in AVmp extradata\n");
2279  break;
2280  }
2281 
2282  if (s2->width <= 0 || s2->height <= 0) {
2283  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2284  s2->width, s2->height);
2285  return AVERROR_INVALIDDATA;
2286  }
2287 
2288  if (s->tmpgexs){
2289  s2->intra_dc_precision= 3;
2290  s2->intra_matrix[0]= 1;
2291  }
2292  if (s->slice_count) {
2293  mpeg12_execute_slice_threads(avctx, s);
2294  s->slice_count = 0;
2295  }
2296  if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2297  ret = mpeg_decode_postinit(avctx);
2298  if (ret < 0) {
2299  av_log(avctx, AV_LOG_ERROR,
2300  "mpeg_decode_postinit() failure\n");
2301  return ret;
2302  }
2303 
2304  /* We have a complete image: we try to decompress it. */
2305  if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2306  s2->pict_type = 0;
2307  s->first_slice = 1;
2308  last_code = PICTURE_START_CODE;
2309  } else {
2310  av_log(avctx, AV_LOG_ERROR,
2311  "ignoring pic after %X\n", last_code);
2312  if (avctx->err_recognition & AV_EF_EXPLODE)
2313  return AVERROR_INVALIDDATA;
2314  }
2315  break;
2316  case EXT_START_CODE:
2317  ret = init_get_bits8(&s2->gb, buf_ptr, input_size);
2318  if (ret < 0)
2319  return ret;
2320 
2321  switch (get_bits(&s2->gb, 4)) {
2322  case 0x1:
2323  if (last_code == 0) {
2324  mpeg_decode_sequence_extension(s);
2325  } else {
2326  av_log(avctx, AV_LOG_ERROR,
2327  "ignoring seq ext after %X\n", last_code);
2328  if (avctx->err_recognition & AV_EF_EXPLODE)
2329  return AVERROR_INVALIDDATA;
2330  }
2331  break;
2332  case 0x2:
2333  mpeg_decode_sequence_display_extension(s);
2334  break;
2335  case 0x3:
2336  mpeg_decode_quant_matrix_extension(s2);
2337  break;
2338  case 0x7:
2339  mpeg_decode_picture_display_extension(s);
2340  break;
2341  case 0x8:
2342  if (last_code == PICTURE_START_CODE) {
2343  int ret = mpeg_decode_picture_coding_extension(s);
2344  if (ret < 0)
2345  return ret;
2346  } else {
2347  av_log(avctx, AV_LOG_ERROR,
2348  "ignoring pic cod ext after %X\n", last_code);
2349  if (avctx->err_recognition & AV_EF_EXPLODE)
2350  return AVERROR_INVALIDDATA;
2351  }
2352  break;
2353  }
2354  break;
2355  case USER_START_CODE:
2356  mpeg_decode_user_data(avctx, buf_ptr, input_size);
2357  break;
2358  case GOP_START_CODE:
2359  if (last_code == 0) {
2360  s2->first_field = 0;
2361  ret = mpeg_decode_gop(avctx, buf_ptr, input_size);
2362  if (ret < 0)
2363  return ret;
2364  s->sync = 1;
2365  } else {
2366  av_log(avctx, AV_LOG_ERROR,
2367  "ignoring GOP_START_CODE after %X\n", last_code);
2368  if (avctx->err_recognition & AV_EF_EXPLODE)
2369  return AVERROR_INVALIDDATA;
2370  }
2371  break;
2372  default:
2373  if (start_code >= SLICE_MIN_START_CODE &&
2374  start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2375  if (s2->progressive_sequence && !s2->progressive_frame) {
2376  s2->progressive_frame = 1;
2377  av_log(s2->avctx, AV_LOG_ERROR,
2378  "interlaced frame in progressive sequence, ignoring\n");
2379  }
2380 
2381  if (s2->picture_structure == 0 ||
2382  (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2383  av_log(s2->avctx, AV_LOG_ERROR,
2384  "picture_structure %d invalid, ignoring\n",
2385  s2->picture_structure);
2386  s2->picture_structure = PICT_FRAME;
2387  }
2388 
2389  if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2390  av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2391 
2392  if (s2->picture_structure == PICT_FRAME) {
2393  s2->first_field = 0;
2394  s2->v_edge_pos = 16 * s2->mb_height;
2395  } else {
2396  s2->first_field ^= 1;
2397  s2->v_edge_pos = 8 * s2->mb_height;
2398  memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2399  }
2400  }
2401  if (start_code >= SLICE_MIN_START_CODE &&
2402  start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2403  const int field_pic = s2->picture_structure != PICT_FRAME;
2404  int mb_y = start_code - SLICE_MIN_START_CODE;
2405  last_code = SLICE_MIN_START_CODE;
2406  if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2407  mb_y += (*buf_ptr&0xE0)<<2;
2408 
2409  mb_y <<= field_pic;
2410  if (s2->picture_structure == PICT_BOTTOM_FIELD)
2411  mb_y++;
2412 
2413  if (buf_end - buf_ptr < 2) {
2414  av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2415  return AVERROR_INVALIDDATA;
2416  }
2417 
2418  if (mb_y >= s2->mb_height) {
2419  av_log(s2->avctx, AV_LOG_ERROR,
2420  "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2421  return AVERROR_INVALIDDATA;
2422  }
2423 
2424  if (!s2->last_pic.ptr) {
2425  /* Skip B-frames if we do not have reference frames and
2426  * GOP is not closed. */
2427  if (s2->pict_type == AV_PICTURE_TYPE_B) {
2428  if (!s->closed_gop) {
2429  skip_frame = 1;
2430  av_log(s2->avctx, AV_LOG_DEBUG,
2431  "Skipping B slice due to open GOP\n");
2432  break;
2433  }
2434  }
2435  }
2436  if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2437  s->sync = 1;
2438  if (!s2->next_pic.ptr) {
2439  /* Skip P-frames if we do not have a reference frame or
2440  * we have an invalid header. */
2441  if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2442  skip_frame = 1;
2443  av_log(s2->avctx, AV_LOG_DEBUG,
2444  "Skipping P slice due to !sync\n");
2445  break;
2446  }
2447  }
2448  if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2449  s2->pict_type == AV_PICTURE_TYPE_B) ||
2450  (avctx->skip_frame >= AVDISCARD_NONKEY &&
2451  s2->pict_type != AV_PICTURE_TYPE_I) ||
2452  avctx->skip_frame >= AVDISCARD_ALL) {
2453  skip_frame = 1;
2454  break;
2455  }
2456 
2457  if (!s2->context_initialized)
2458  break;
2459 
2460  if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2461  if (mb_y < avctx->skip_top ||
2462  mb_y >= s2->mb_height - avctx->skip_bottom)
2463  break;
2464  }
2465 
2466  if (!s2->pict_type) {
2467  av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2468  if (avctx->err_recognition & AV_EF_EXPLODE)
2469  return AVERROR_INVALIDDATA;
2470  break;
2471  }
2472 
2473  if (s->first_slice) {
2474  skip_frame = 0;
2475  s->first_slice = 0;
2476  if ((ret = mpeg_field_start(s, buf, buf_size)) < 0)
2477  return ret;
2478  }
2479  if (!s2->cur_pic.ptr) {
2480  av_log(avctx, AV_LOG_ERROR,
2481  "current_picture not initialized\n");
2482  return AVERROR_INVALIDDATA;
2483  }
2484 
2485  if (HAVE_THREADS &&
2486  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2487  !avctx->hwaccel) {
2488  int threshold = (s2->mb_height * s->slice_count +
2489  s2->slice_context_count / 2) /
2490  s2->slice_context_count;
2491  if (threshold <= mb_y) {
2492  MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2493 
2494  thread_context->start_mb_y = mb_y;
2495  thread_context->end_mb_y = s2->mb_height;
2496  if (s->slice_count) {
2497  s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2498  ret = ff_update_duplicate_context(thread_context, s2);
2499  if (ret < 0)
2500  return ret;
2501  }
2502  ret = init_get_bits8(&thread_context->gb, buf_ptr, input_size);
2503  if (ret < 0)
2504  return ret;
2505  s->slice_count++;
2506  }
2507  buf_ptr += 2; // FIXME add minimum number of bytes per slice
2508  } else {
2509  ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2510  emms_c();
2511 
2512  if (ret < 0) {
2513  if (avctx->err_recognition & AV_EF_EXPLODE)
2514  return ret;
2515  if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2516  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2517  s2->resync_mb_y, s2->mb_x, s2->mb_y,
2518  ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2519  } else {
2520  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2521  s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2522  ER_AC_END | ER_DC_END | ER_MV_END);
2523  }
2524  }
2525  }
2526  break;
2527  }
2528  }
2529 }
2530 
2531 static int mpeg_decode_frame(AVCodecContext *avctx, AVFrame *picture,
2532  int *got_output, AVPacket *avpkt)
2533 {
2534  const uint8_t *buf = avpkt->data;
2535  int ret;
2536  int buf_size = avpkt->size;
2537  Mpeg1Context *s = avctx->priv_data;
2538  MpegEncContext *s2 = &s->mpeg_enc_ctx;
2539 
2540  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2541  /* special case for last picture */
2542  if (s2->low_delay == 0 && s2->next_pic.ptr) {
2543  int ret = av_frame_ref(picture, s2->next_pic.ptr->f);
2544  if (ret < 0)
2545  return ret;
2546 
2547  ff_mpv_unref_picture(&s2->next_pic);
2548 
2549  *got_output = 1;
2550  }
2551  return buf_size;
2552  }
2553 
2554  if (!s2->context_initialized &&
2555  (s2->codec_tag == AV_RL32("VCR2") || s2->codec_tag == AV_RL32("BW10")))
2556  vcr2_init_sequence(avctx);
2557 
2558  s->slice_count = 0;
2559 
2560  if (avctx->extradata && !s->extradata_decoded) {
2561  ret = decode_chunks(avctx, picture, got_output,
2562  avctx->extradata, avctx->extradata_size);
2563  if (*got_output) {
2564  av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2565  av_frame_unref(picture);
2566  *got_output = 0;
2567  }
2568  s->extradata_decoded = 1;
2569  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2570  ff_mpv_unref_picture(&s2->cur_pic);
2571  return ret;
2572  }
2573  }
2574 
2575  ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2576  if (ret<0 || *got_output) {
2577  ff_mpv_unref_picture(&s2->cur_pic);
2578 
2579  if (s->timecode_frame_start != -1 && *got_output) {
2580  char tcbuf[AV_TIMECODE_STR_SIZE];
2581  AVFrameSideData *tcside = av_frame_new_side_data(picture,
2582  AV_FRAME_DATA_GOP_TIMECODE,
2583  sizeof(int64_t));
2584  if (!tcside)
2585  return AVERROR(ENOMEM);
2586  memcpy(tcside->data, &s->timecode_frame_start, sizeof(int64_t));
2587 
2588  av_timecode_make_mpeg_tc_string(tcbuf, s->timecode_frame_start);
2589  av_dict_set(&picture->metadata, "timecode", tcbuf, 0);
2590 
2591  s->timecode_frame_start = -1;
2592  }
2593  }
2594 
2595  return ret;
2596 }
2597 
2598 static av_cold void flush(AVCodecContext *avctx)
2599 {
2600  Mpeg1Context *s = avctx->priv_data;
2601 
2602  s->sync = 0;
2603  s->closed_gop = 0;
2604 
2605  av_buffer_unref(&s->a53_buf_ref);
2606  ff_mpeg_flush(avctx);
2607 }
2608 
2609 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2610 {
2611  Mpeg1Context *s = avctx->priv_data;
2612 
2613  av_buffer_unref(&s->a53_buf_ref);
2614  return ff_mpv_decode_close(avctx);
2615 }
2616 
2617 const FFCodec ff_mpeg1video_decoder = {
2618  .p.name = "mpeg1video",
2619  CODEC_LONG_NAME("MPEG-1 video"),
2620  .p.type = AVMEDIA_TYPE_VIDEO,
2621  .p.id = AV_CODEC_ID_MPEG1VIDEO,
2622  .priv_data_size = sizeof(Mpeg1Context),
2623  .init = mpeg_decode_init,
2624  .close = mpeg_decode_end,
2625  FF_CODEC_DECODE_CB(mpeg_decode_frame),
2626  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2627  AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2628  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2629  .flush = flush,
2630  .p.max_lowres = 3,
2631  .hw_configs = (const AVCodecHWConfigInternal *const []) {
2632 #if CONFIG_MPEG1_NVDEC_HWACCEL
2633  HWACCEL_NVDEC(mpeg1),
2634 #endif
2635 #if CONFIG_MPEG1_VDPAU_HWACCEL
2636  HWACCEL_VDPAU(mpeg1),
2637 #endif
2638 #if CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL
2639  HWACCEL_VIDEOTOOLBOX(mpeg1),
2640 #endif
2641  NULL
2642  },
2643 };
2644 
2645 #define M2V_OFFSET(x) offsetof(Mpeg1Context, x)
2646 #define M2V_PARAM AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2647 
2648 static const AVOption mpeg2video_options[] = {
2649  { "cc_format", "extract a specific Closed Captions format",
2650  M2V_OFFSET(cc_format), AV_OPT_TYPE_INT, { .i64 = CC_FORMAT_AUTO },
2651  CC_FORMAT_AUTO, CC_FORMAT_DISH, M2V_PARAM, .unit = "cc_format" },
2652 
2653  { "auto", "pick first seen CC substream", 0, AV_OPT_TYPE_CONST,
2654  { .i64 = CC_FORMAT_AUTO }, .flags = M2V_PARAM, .unit = "cc_format" },
2655  { "a53", "pick A/53 Part 4 CC substream", 0, AV_OPT_TYPE_CONST,
2656  { .i64 = CC_FORMAT_A53_PART4 }, .flags = M2V_PARAM, .unit = "cc_format" },
2657  { "scte20", "pick SCTE-20 CC substream", 0, AV_OPT_TYPE_CONST,
2658  { .i64 = CC_FORMAT_SCTE20 }, .flags = M2V_PARAM, .unit = "cc_format" },
2659  { "dvd", "pick DVD CC substream", 0, AV_OPT_TYPE_CONST,
2660  { .i64 = CC_FORMAT_DVD }, .flags = M2V_PARAM, .unit = "cc_format" },
2661  { "dish", "pick Dish Network CC substream", 0, AV_OPT_TYPE_CONST,
2662  { .i64 = CC_FORMAT_DISH }, .flags = M2V_PARAM, .unit = "cc_format" },
2663  { NULL }
2664 };
2665 
2666 static const AVClass mpeg2video_class = {
2667  .class_name = "MPEG-2 video",
2668  .item_name = av_default_item_name,
2669  .option = mpeg2video_options,
2670  .version = LIBAVUTIL_VERSION_INT,
2671  .category = AV_CLASS_CATEGORY_DECODER,
2672 };
2673 
2674 const FFCodec ff_mpeg2video_decoder = {
2675  .p.name = "mpeg2video",
2676  CODEC_LONG_NAME("MPEG-2 video"),
2677  .p.type = AVMEDIA_TYPE_VIDEO,
2678  .p.id = AV_CODEC_ID_MPEG2VIDEO,
2679  .p.priv_class = &mpeg2video_class,
2680  .priv_data_size = sizeof(Mpeg1Context),
2681  .init = mpeg_decode_init,
2682  .close = mpeg_decode_end,
2683  FF_CODEC_DECODE_CB(mpeg_decode_frame),
2684  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2685  AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2686  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2687  .flush = flush,
2688  .p.max_lowres = 3,
2689  .p.profiles = NULL_IF_CONFIG_SMALL(ff_mpeg2_video_profiles),
2690  .hw_configs = (const AVCodecHWConfigInternal *const []) {
2691 #if CONFIG_MPEG2_DXVA2_HWACCEL
2692  HWACCEL_DXVA2(mpeg2),
2693 #endif
2694 #if CONFIG_MPEG2_D3D11VA_HWACCEL
2695  HWACCEL_D3D11VA(mpeg2),
2696 #endif
2697 #if CONFIG_MPEG2_D3D11VA2_HWACCEL
2698  HWACCEL_D3D11VA2(mpeg2),
2699 #endif
2700 #if CONFIG_MPEG2_D3D12VA_HWACCEL
2701  HWACCEL_D3D12VA(mpeg2),
2702 #endif
2703 #if CONFIG_MPEG2_NVDEC_HWACCEL
2704  HWACCEL_NVDEC(mpeg2),
2705 #endif
2706 #if CONFIG_MPEG2_VAAPI_HWACCEL
2707  HWACCEL_VAAPI(mpeg2),
2708 #endif
2709 #if CONFIG_MPEG2_VDPAU_HWACCEL
2710  HWACCEL_VDPAU(mpeg2),
2711 #endif
2712 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
2713  HWACCEL_VIDEOTOOLBOX(mpeg2),
2714 #endif
2715  NULL
2716  },
2717 };
2718 
2719 //legacy decoder
2720 const FFCodec ff_mpegvideo_decoder = {
2721  .p.name = "mpegvideo",
2722  CODEC_LONG_NAME("MPEG-1 video"),
2723  .p.type = AVMEDIA_TYPE_VIDEO,
2724  .p.id = AV_CODEC_ID_MPEG2VIDEO,
2725  .priv_data_size = sizeof(Mpeg1Context),
2726  .init = mpeg_decode_init,
2727  .close = mpeg_decode_end,
2728  FF_CODEC_DECODE_CB(mpeg_decode_frame),
2729  .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2730  AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2731  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2732  .flush = flush,
2733  .p.max_lowres = 3,
2734 };
2735 
2736 typedef struct IPUContext {
2737  MpegEncContext m;
2738 
2739  int flags;
2740  DECLARE_ALIGNED(32, int16_t, block)[6][64];
2741 } IPUContext;
2742 
2743 static int ipu_decode_frame(AVCodecContext *avctx, AVFrame *frame,
2744  int *got_frame, AVPacket *avpkt)
2745 {
2746  IPUContext *s = avctx->priv_data;
2747  MpegEncContext *m = &s->m;
2748  GetBitContext *gb = &m->gb;
2749  int ret;
2750 
2751  // Check for minimal intra MB size (considering mb header, luma & chroma dc VLC, ac EOB VLC)
2752  if (avpkt->size*8LL < (avctx->width+15)/16 * ((avctx->height+15)/16) * (2LL + 3*4 + 2*2 + 2*6))
2753  return AVERROR_INVALIDDATA;
2754 
2755  ret = ff_get_buffer(avctx, frame, 0);
2756  if (ret < 0)
2757  return ret;
2758 
2759  ret = init_get_bits8(gb, avpkt->data, avpkt->size);
2760  if (ret < 0)
2761  return ret;
2762 
2763  s->flags = get_bits(gb, 8);
2764  m->intra_dc_precision = s->flags & 3;
2765  m->q_scale_type = !!(s->flags & 0x40);
2766  m->intra_vlc_format = !!(s->flags & 0x20);
2767  m->alternate_scan = !!(s->flags & 0x10);
2768 
2769  ff_permute_scantable(m->intra_scantable.permutated,
2770  s->flags & 0x10 ? ff_alternate_vertical_scan : ff_zigzag_direct,
2771  m->idsp.idct_permutation);
2772 
2773  m->last_dc[0] = m->last_dc[1] = m->last_dc[2] = 1 << (7 + (s->flags & 3));
2774  m->qscale = 1;
2775 
2776  for (int y = 0; y < avctx->height; y += 16) {
2777  int intraquant;
2778 
2779  for (int x = 0; x < avctx->width; x += 16) {
2780  if (x || y) {
2781  if (!get_bits1(gb))
2782  return AVERROR_INVALIDDATA;
2783  }
2784  if (get_bits1(gb)) {
2785  intraquant = 0;
2786  } else {
2787  if (!get_bits1(gb))
2788  return AVERROR_INVALIDDATA;
2789  intraquant = 1;
2790  }
2791 
2792  if (s->flags & 4)
2793  skip_bits1(gb);
2794 
2795  if (intraquant)
2796  m->qscale = mpeg_get_qscale(m);
2797 
2798  memset(s->block, 0, sizeof(s->block));
2799 
2800  for (int n = 0; n < 6; n++) {
2801  if (s->flags & 0x80) {
2802  ret = ff_mpeg1_decode_block_intra(&m->gb,
2803  m->intra_matrix,
2804  m->intra_scantable.permutated,
2805  m->last_dc, s->block[n],
2806  n, m->qscale);
2807  } else {
2808  ret = mpeg2_decode_block_intra(m, s->block[n], n);
2809  }
2810 
2811  if (ret < 0)
2812  return ret;
2813  }
2814 
2815  m->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
2816  frame->linesize[0], s->block[0]);
2817  m->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
2818  frame->linesize[0], s->block[1]);
2819  m->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
2820  frame->linesize[0], s->block[2]);
2821  m->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
2822  frame->linesize[0], s->block[3]);
2823  m->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
2824  frame->linesize[1], s->block[4]);
2825  m->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
2826  frame->linesize[2], s->block[5]);
2827  }
2828  }
2829 
2830  align_get_bits(gb);
2831  if (get_bits_left(gb) != 32)
2832  return AVERROR_INVALIDDATA;
2833 
2834  *got_frame = 1;
2835 
2836  return avpkt->size;
2837 }
2838 
2839 static av_cold int ipu_decode_init(AVCodecContext *avctx)
2840 {
2841  IPUContext *s = avctx->priv_data;
2842  MpegEncContext *m = &s->m;
2843 
2844  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
2845  m->avctx = avctx;
2846 
2847  ff_idctdsp_init(&m->idsp, avctx);
2848  ff_mpeg12_init_vlcs();
2849 
2850  for (int i = 0; i < 64; i++) {
2851  int j = m->idsp.idct_permutation[i];
2852  int v = ff_mpeg1_default_intra_matrix[i];
2853  m->intra_matrix[j] = v;
2854  m->chroma_intra_matrix[j] = v;
2855  }
2856 
2857  return 0;
2858 }
2859 
2860 const FFCodec ff_ipu_decoder = {
2861  .p.name = "ipu",
2862  CODEC_LONG_NAME("IPU Video"),
2863  .p.type = AVMEDIA_TYPE_VIDEO,
2864  .p.id = AV_CODEC_ID_IPU,
2865  .priv_data_size = sizeof(IPUContext),
2866  .init = ipu_decode_init,
2867  FF_CODEC_DECODE_CB(ipu_decode_frame),
2868  .p.capabilities = AV_CODEC_CAP_DR1,
2869 };
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
vcr2_init_sequence
static int vcr2_init_sequence(AVCodecContext *avctx)
Definition: mpeg12dec.c:1811
flags
const SwsFlags flags[]
Definition: swscale.c:61
HWACCEL_D3D12VA
#define HWACCEL_D3D12VA(codec)
Definition: hwconfig.h:80
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:398
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1405
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:185
Mpeg1Context::has_afd
int has_afd
Definition: mpeg12dec.c:80
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
MpegEncContext::progressive_sequence
int progressive_sequence
Definition: mpegvideo.h:285
M2V_OFFSET
#define M2V_OFFSET(x)
Definition: mpeg12dec.c:2645
ff_mb_pat_vlc
VLCElem ff_mb_pat_vlc[512]
Definition: mpeg12.c:145
level
uint8_t level
Definition: svq3.c:208
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
Mpeg1Context::a53_buf_ref
AVBufferRef * a53_buf_ref
Definition: mpeg12dec.c:77
ff_mpeg2_aspect
const AVRational ff_mpeg2_aspect[16]
Definition: mpeg12data.c:380
AVPanScan::position
int16_t position[3][2]
position of the top left corner in 1/16 pel for up to 3 fields/frames
Definition: defs.h:271
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:478
mpeg_decode_a53_cc
static int mpeg_decode_a53_cc(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition: mpeg12dec.c:1881
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:678
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
decode_slice
static int decode_slice(AVCodecContext *c, void *arg)
Definition: ffv1dec.c:355
ff_mpv_decode_init
av_cold int ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo_dec.c:47
AV_CLASS_CATEGORY_DECODER
@ AV_CLASS_CATEGORY_DECODER
Definition: log.h:35
AV_STEREO3D_SIDEBYSIDE_QUINCUNX
@ AV_STEREO3D_SIDEBYSIDE_QUINCUNX
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:114
FF_MPV_QSCALE_TYPE_MPEG2
#define FF_MPV_QSCALE_TYPE_MPEG2
Definition: mpegvideodec.h:41
mem_internal.h
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1200
mpeg_decode_frame
static int mpeg_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_output, AVPacket *avpkt)
Definition: mpeg12dec.c:2531
MpegEncContext::gb
GetBitContext gb
Definition: mpegvideo.h:282
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: defs.h:55
MpegEncContext::top_field_first
int top_field_first
Definition: mpegvideo.h:293
SEQ_END_CODE
#define SEQ_END_CODE
Definition: mpeg12.h:28
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:645
check_scantable_index
#define check_scantable_index(ctx, x)
Definition: mpeg12dec.c:124
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:59
MT_FIELD
#define MT_FIELD
Definition: mpeg12dec.c:392
EXT_START_CODE
#define EXT_START_CODE
Definition: cavs.h:39
MV_TYPE_16X8
#define MV_TYPE_16X8
2 vectors, one per 16x8 block
Definition: mpegvideo.h:187
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
AVPanScan
Pan Scan area.
Definition: defs.h:250
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1398
SLICE_MAX_START_CODE
#define SLICE_MAX_START_CODE
Definition: cavs.h:38
int64_t
long long int64_t
Definition: coverity.c:34
MB_TYPE_16x8
#define MB_TYPE_16x8
Definition: mpegutils.h:42
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:249
Mpeg1Context::vbv_delay
int vbv_delay
Definition: mpeg12dec.c:91
ipu_decode_init
static av_cold int ipu_decode_init(AVCodecContext *avctx)
Definition: mpeg12dec.c:2839
ff_update_duplicate_context
int ff_update_duplicate_context(MpegEncContext *dst, const MpegEncContext *src)
Definition: mpegvideo.c:174
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
start_code
static const uint8_t start_code[]
Definition: videotoolboxenc.c:230
w
uint8_t w
Definition: llviddspenc.c:38
HWACCEL_DXVA2
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:64
ff_mpegvideo_decoder
const FFCodec ff_mpegvideo_decoder
Definition: mpeg12dec.c:2720
AVPacket::data
uint8_t * data
Definition: packet.h:535
mpeg_decode_mb
static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpeg12dec.c:397
Mpeg1Context::closed_gop
int closed_gop
Definition: mpeg12dec.c:87
mpeg2_decode_block_intra
static int mpeg2_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:302
AVOption
AVOption.
Definition: opt.h:429
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:66
ff_reverse
const uint8_t ff_reverse[256]
Definition: reverse.c:23
MpegEncContext::last_dc
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:142
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:41
AV_PIX_FMT_D3D11VA_VLD
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:254
FFCodec
Definition: codec_internal.h:127
ff_mpv_framesize_disable
static void ff_mpv_framesize_disable(ScratchpadContext *sc)
Disable allocating the ScratchpadContext's buffers in future calls to ff_mpv_framesize_alloc().
Definition: mpegpicture.h:143
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:32
FF_HW_SIMPLE_CALL
#define FF_HW_SIMPLE_CALL(avctx, function)
Definition: hwaccel_internal.h:176
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition: error_resilience.c:826
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:511
reverse.h
mpegvideo.h
MpegEncContext::avctx
struct AVCodecContext * avctx
Definition: mpegvideo.h:82
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:208
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
Mpeg1Context::first_slice
int first_slice
Definition: mpeg12dec.c:89
ER_DC_END
#define ER_DC_END
Definition: error_resilience.h:33
mpeg_decode_postinit
static int mpeg_decode_postinit(AVCodecContext *avctx)
Definition: mpeg12dec.c:852
MpegEncContext::height
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:87
mpegutils.h
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:91
ER_MV_ERROR
#define ER_MV_ERROR
Definition: error_resilience.h:31
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:228
SEQ_START_CODE
#define SEQ_START_CODE
Definition: mpeg12.h:29
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1375
MV_TYPE_DMV
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition: mpegvideo.h:189
CC_FORMAT_DISH
@ CC_FORMAT_DISH
Definition: mpeg12dec.c:69
MpegEncContext::out_format
enum OutputFormat out_format
output format
Definition: mpegvideo.h:88
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:638
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:246
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:364
ff_mpeg2_rl_vlc
RL_VLC_ELEM ff_mpeg2_rl_vlc[674]
Definition: mpeg12.c:148
MpegEncContext::intra_scantable
ScanTable intra_scantable
Definition: mpegvideo.h:78
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:551
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
close
static av_cold void close(AVCodecParserContext *s)
Definition: apv_parser.c:135
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:64
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:318
mx
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx
Definition: dsp.h:57
MT_DMV
#define MT_DMV
Definition: mpeg12dec.c:395
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo_dec.c:1067
MpegEncContext::mb_height
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:104
ff_mbincr_vlc
VLCElem ff_mbincr_vlc[538]
Definition: mpeg12.c:142
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
MpegEncContext::pict_type
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:163
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict, int *got_output)
Handle slice ends.
Definition: mpeg12dec.c:1672
FMT_MPEG1
@ FMT_MPEG1
Definition: mpegvideo.h:54
decode_chunks
static int decode_chunks(AVCodecContext *avctx, AVFrame *picture, int *got_output, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2216
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1662
mpeg_decode_quant_matrix_extension
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
Definition: mpeg12dec.c:1136
AV_STEREO3D_2D
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:52
MpegEncContext::picture_structure
int picture_structure
Definition: mpegvideo.h:289
wrap
#define wrap(func)
Definition: neontest.h:65
timecode.h
GetBitContext
Definition: get_bits.h:108
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: defs.h:49
AVPanScan::width
int width
width and height in 1/16 pel
Definition: defs.h:263
slice_decode_thread
static int slice_decode_thread(AVCodecContext *c, void *arg)
Definition: mpeg12dec.c:1619
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:488
IDCTDSPContext::idct_put
void(* idct_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:62
MB_TYPE_CBP
#define MB_TYPE_CBP
Definition: mpegutils.h:47
val
static double val(void *priv, double ch)
Definition: aeval.c:77
Mpeg1Context::tmpgexs
int tmpgexs
Definition: mpeg12dec.c:88
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:72
AV_CODEC_FLAG_LOW_DELAY
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:314
mpeg12_pixfmt_list_444
static enum AVPixelFormat mpeg12_pixfmt_list_444[]
Definition: mpeg12dec.c:824
MpegEncContext::width
int width
Definition: mpegvideo.h:87
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:607
mpeg1_decode_sequence
static int mpeg1_decode_sequence(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:1722
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
HAS_CBP
#define HAS_CBP(a)
Definition: mpegutils.h:87
AVRational::num
int num
Numerator.
Definition: rational.h:59
GOP_START_CODE
#define GOP_START_CODE
Definition: mpeg12.h:30
MpegEncContext::frame_pred_frame_dct
int frame_pred_frame_dct
Definition: mpegvideo.h:292
ff_frame_new_side_data_from_buf
int ff_frame_new_side_data_from_buf(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef **buf)
Similar to ff_frame_new_side_data, but using an existing buffer ref.
Definition: decode.c:2067
IPUContext
Definition: mpeg12dec.c:2736
mpeg1_hwaccel_pixfmt_list_420
static enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[]
Definition: mpeg12dec.c:781
mpeg12.h
mpegvideodec.h
ff_mpeg2video_decoder
const FFCodec ff_mpeg2video_decoder
Definition: mpeg12dec.c:2674
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
Mpeg1Context::frame_rate_index
unsigned frame_rate_index
Definition: mpeg12dec.c:85
ipu_decode_frame
static int ipu_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: mpeg12dec.c:2743
HAS_MV
#define HAS_MV(a, dir)
Definition: mpegutils.h:91
ER_DC_ERROR
#define ER_DC_ERROR
Definition: error_resilience.h:30
av_cold
#define av_cold
Definition: attributes.h:90
mpeg2_hwaccel_pixfmt_list_420
static enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[]
Definition: mpeg12dec.c:792
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:528
mpeg1_decode_picture
static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:967
Mpeg1Context::save_progressive_seq
int save_progressive_seq
Definition: mpeg12dec.c:83
emms_c
#define emms_c()
Definition: emms.h:63
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:184
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:515
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:697
A53_MAX_CC_COUNT
#define A53_MAX_CC_COUNT
Definition: mpeg12dec.c:62
Mpeg1Context::stereo3d_type
enum AVStereo3DType stereo3d_type
Definition: mpeg12dec.c:75
ff_er_frame_end
void ff_er_frame_end(ERContext *s, int *decode_error_flags)
Indicate that a frame has finished decoding and perform error concealment in case it has been enabled...
Definition: error_resilience.c:896
ff_mpeg_flush
av_cold void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:414
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:341
stereo3d.h
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:134
s
#define s(width, name)
Definition: cbs_vp9.c:198
ff_mv_vlc
VLCElem ff_mv_vlc[266]
Definition: mpeg12.c:137
CHROMA_422
#define CHROMA_422
Definition: mpegvideo.h:302
MPVWorkPicture::ptr
MPVPicture * ptr
RefStruct reference.
Definition: mpegpicture.h:99
ff_mpeg1_aspect
const float ff_mpeg1_aspect[16]
Definition: mpeg12data.c:359
MB_TYPE_ZERO_MV
#define MB_TYPE_ZERO_MV
Definition: mpeg12dec.h:28
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:243
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
flush
static av_cold void flush(AVCodecContext *avctx)
Definition: mpeg12dec.c:2598
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
Mpeg1Context::aspect_ratio_info
unsigned aspect_ratio_info
Definition: mpeg12dec.c:82
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:298
mpeg_decode_sequence_display_extension
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1055
Mpeg1Context::pan_scan
AVPanScan pan_scan
Definition: mpeg12dec.c:74
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:303
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:31
decode.h
mpeg12_pixfmt_list_422
static enum AVPixelFormat mpeg12_pixfmt_list_422[]
Definition: mpeg12dec.c:819
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:224
field
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 field
Definition: writing_filters.txt:78
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1270
MpegEncContext::cur_pic
MPVWorkPicture cur_pic
copy of the current picture structure.
Definition: mpegvideo.h:139
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:441
my
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my
Definition: dsp.h:57
arg
const char * arg
Definition: jacosubdec.c:67
rl_vlc
static const VLCElem * rl_vlc[2]
Definition: mobiclip.c:278
ff_mpv_common_end
av_cold void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:467
MpegEncContext::mb_stride
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11
Definition: mpegvideo.h:105
if
if(ret)
Definition: filter_design.txt:179
ff_mpv_unref_picture
void ff_mpv_unref_picture(MPVWorkPicture *pic)
Definition: mpegpicture.c:98
MpegEncContext::low_delay
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:255
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:229
MB_PTYPE_VLC_BITS
#define MB_PTYPE_VLC_BITS
Definition: mpeg12vlc.h:39
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:128
ff_mpv_export_qp_table
int ff_mpv_export_qp_table(const MpegEncContext *s, AVFrame *f, const MPVPicture *p, int qp_type)
Definition: mpegvideo_dec.c:375
NULL
#define NULL
Definition: coverity.c:32
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
run
uint8_t run
Definition: svq3.c:207
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:669
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
ER_AC_ERROR
#define ER_AC_ERROR
Definition: error_resilience.h:29
MpegEncContext::mb_y
int mb_y
Definition: mpegvideo.h:204
SLICE_MIN_START_CODE
#define SLICE_MIN_START_CODE
Definition: mpeg12.h:32
mpeg12_execute_slice_threads
static void mpeg12_execute_slice_threads(AVCodecContext *avctx, Mpeg1Context *const s)
Definition: mpeg12dec.c:2187
hwaccel_internal.h
Mpeg1Context::sync
int sync
Definition: mpeg12dec.c:86
MpegEncContext::next_pic
MPVWorkPicture next_pic
copy of the next picture structure.
Definition: mpegvideo.h:133
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:771
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_mpv_decode_close
av_cold int ff_mpv_decode_close(AVCodecContext *avctx)
Definition: mpegvideo_dec.c:128
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:773
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:481
mpeg_decode_picture_display_extension
static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1079
M2V_PARAM
#define M2V_PARAM
Definition: mpeg12dec.c:2646
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:240
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:371
profiles.h
CC_FORMAT_A53_PART4
@ CC_FORMAT_A53_PART4
Definition: mpeg12dec.c:66
FF_PTR_ADD
#define FF_PTR_ADD(ptr, off)
Definition: internal.h:80
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:230
MB_TYPE_QUANT
#define MB_TYPE_QUANT
Definition: mpegutils.h:48
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
MB_TYPE_BIDIR_MV
#define MB_TYPE_BIDIR_MV
Definition: mpegutils.h:51
lowres
static int lowres
Definition: ffplay.c:330
ff_mpeg1_rl_vlc
RL_VLC_ELEM ff_mpeg1_rl_vlc[680]
Definition: mpeg12.c:147
MB_BTYPE_VLC_BITS
#define MB_BTYPE_VLC_BITS
Definition: mpeg12vlc.h:40
CC_FORMAT_AUTO
@ CC_FORMAT_AUTO
Definition: mpeg12dec.c:65
AV_PIX_FMT_D3D12
@ AV_PIX_FMT_D3D12
Hardware surfaces for Direct3D 12.
Definition: pixfmt.h:440
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
mpeg12codecs.h
MpegEncContext::slice_context_count
int slice_context_count
number of used thread_contexts
Definition: mpegvideo.h:121
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:635
AV_FRAME_DATA_AFD
@ AV_FRAME_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:90
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1628
atomic_load_explicit
#define atomic_load_explicit(object, order)
Definition: stdatomic.h:96
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:53
MpegEncContext::idsp
IDCTDSPContext idsp
Definition: mpegvideo.h:173
ff_mpv_alloc_dummy_frames
int ff_mpv_alloc_dummy_frames(MpegEncContext *s)
Ensure that the dummy frames are allocated according to pict_type if necessary.
Definition: mpegvideo_dec.c:266
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
Mpeg1Context::save_chroma_format
int save_chroma_format
Definition: mpeg12dec.c:83
startcode.h
CC_FORMAT_DVD
@ CC_FORMAT_DVD
Definition: mpeg12dec.c:68
IS_INTRA
#define IS_INTRA(x, y)
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:228
check_marker
static int check_marker(void *logctx, GetBitContext *s, const char *msg)
Definition: mpegvideodec.h:89
ERContext::error_count
atomic_int error_count
Definition: error_resilience.h:67
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:495
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1635
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
mpeg2video_options
static const AVOption mpeg2video_options[]
Definition: mpeg12dec.c:2648
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:302
AVPacket::size
int size
Definition: packet.h:536
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
MpegEncContext::qscale
int qscale
QP.
Definition: mpegvideo.h:161
AV_CODEC_ID_IPU
@ AV_CODEC_ID_IPU
Definition: codec_id.h:310
AV_FRAME_DATA_PANSCAN
@ AV_FRAME_DATA_PANSCAN
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:53
CC_FORMAT_SCTE20
@ CC_FORMAT_SCTE20
Definition: mpeg12dec.c:67
height
#define height
Definition: dsp.h:89
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:276
MT_FRAME
#define MT_FRAME
Definition: mpeg12dec.c:393
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:104
shift
static int shift(int a, int b)
Definition: bonk.c:261
IPUContext::flags
int flags
Definition: mpeg12dec.c:2739
MpegEncContext::intra_matrix
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
Definition: mpegvideo.h:215
mpeg_field_start
static int mpeg_field_start(Mpeg1Context *s1, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:1208
ff_mpeg1_clean_buffers
void ff_mpeg1_clean_buffers(MpegEncContext *s)
Definition: mpeg12.c:125
MpegEncContext::v_edge_pos
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:107
Mpeg1Context::bit_rate
int64_t bit_rate
Definition: mpeg12dec.c:92
VLCElem
Definition: vlc.h:32
ff_mpeg1video_decoder
const FFCodec ff_mpeg1video_decoder
Definition: mpeg12dec.c:2617
ff_frame_new_side_data
int ff_frame_new_side_data(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, size_t size, AVFrameSideData **psd)
Wrapper around av_frame_new_side_data, which rejects side data overridden by the demuxer.
Definition: decode.c:2029
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: codec_internal.h:54
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:61
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1573
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo_dec.c:406
PICTURE_START_CODE
#define PICTURE_START_CODE
Definition: mpeg12.h:31
USER_START_CODE
#define USER_START_CODE
Definition: cavs.h:40
AVCodecContext::skip_bottom
int skip_bottom
Number of macroblock rows at the bottom which are skipped.
Definition: avcodec.h:1690
AVCodecHWConfigInternal
Definition: hwconfig.h:25
MpegEncContext::mbskip_table
uint8_t * mbskip_table
used to avoid copy if macroblock skipped (for black regions for example) and used for B-frame encodin...
Definition: mpegvideo.h:153
ff_mpeg1_default_intra_matrix
const uint16_t ff_mpeg1_default_intra_matrix[256]
Definition: mpeg12data.c:31
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
MpegEncContext::context_initialized
int context_initialized
Definition: mpegvideo.h:102
ff_mpv_frame_start
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo_dec.c:309
MB_TYPE_INTERLACED
#define MB_TYPE_INTERLACED
Definition: mpegutils.h:45
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:173
Mpeg1Context::has_stereo3d
int has_stereo3d
Definition: mpeg12dec.c:76
mpeg_decode_init
static av_cold int mpeg_decode_init(AVCodecContext *avctx)
Definition: mpeg12dec.c:759
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:99
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:78
mpegvideodata.h
attributes.h
ff_mpeg1_decode_block_intra
int ff_mpeg1_decode_block_intra(GetBitContext *gb, const uint16_t *quant_matrix, const uint8_t *scantable, int last_dc[3], int16_t *block, int index, int qscale)
Definition: mpeg12.c:193
MV_TYPE_FIELD
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:188
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:396
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:336
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:68
mpeg2video_class
static const AVClass mpeg2video_class
Definition: mpeg12dec.c:2666
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
AVBufferRef::size
size_t size
Size of data in bytes.
Definition: buffer.h:94
ff_mpeg2_video_profiles
const AVProfile ff_mpeg2_video_profiles[]
Definition: profiles.c:116
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:194
CHROMA_444
#define CHROMA_444
Definition: mpegvideo.h:303
emms.h
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:305
ff_print_debug_info
void ff_print_debug_info(const MpegEncContext *s, const MPVPicture *p, AVFrame *pict)
Definition: mpegvideo_dec.c:368
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
MpegEncContext::progressive_frame
int progressive_frame
Definition: mpegvideo.h:307
CHROMA_420
#define CHROMA_420
Definition: mpegvideo.h:301
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
AV_CODEC_FLAG2_SHOW_ALL
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition: avcodec.h:360
ff_alternate_vertical_scan
const uint8_t ff_alternate_vertical_scan[64]
Definition: mpegvideodata.c:63
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:514
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:354
internal.h
mpeg_set_cc_format
static void mpeg_set_cc_format(AVCodecContext *avctx, enum Mpeg2ClosedCaptionsFormat format, const char *label)
Definition: mpeg12dec.c:1861
AV_STEREO3D_TOPBOTTOM
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition: stereo3d.h:76
IS_QUANT
#define IS_QUANT(a)
Definition: mpegutils.h:85
MpegEncContext::mb_x
int mb_x
Definition: mpegvideo.h:204
ff_mpeg12_init_vlcs
av_cold void ff_mpeg12_init_vlcs(void)
Definition: mpeg12.c:185
atomic_store_explicit
#define atomic_store_explicit(object, desired, order)
Definition: stdatomic.h:90
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:1382
MpegEncContext::thread_context
struct MpegEncContext * thread_context[MAX_THREADS]
Definition: mpegvideo.h:118
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
MB_TYPE_MV_2_MV_DIR
#define MB_TYPE_MV_2_MV_DIR(a)
Definition: mpegutils.h:93
MB_PAT_VLC_BITS
#define MB_PAT_VLC_BITS
Definition: mpeg12vlc.h:38
mpeg1_decode_block_inter
static int mpeg1_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:133
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:494
IPUContext::m
MpegEncContext m
Definition: mpeg12dec.c:2737
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
MpegEncContext::last_pic
MPVWorkPicture last_pic
copy of the previous picture structure.
Definition: mpegvideo.h:127
MpegEncContext::intra_vlc_format
int intra_vlc_format
Definition: mpegvideo.h:296
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:676
MAX_INDEX
#define MAX_INDEX
Definition: mpeg12dec.c:123
MpegEncContext::er
ERContext er
Definition: mpegvideo.h:333
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:733
HWACCEL_VIDEOTOOLBOX
#define HWACCEL_VIDEOTOOLBOX(codec)
Definition: hwconfig.h:74
idctdsp.h
avcodec.h
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:589
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:137
ff_mpeg12_frame_rate_tab
const AVRational ff_mpeg12_frame_rate_tab[]
Definition: mpeg12framerate.c:24
mpeg_decode_gop
static int mpeg_decode_gop(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2156
ret
ret
Definition: filter_design.txt:187
AV_EF_AGGRESSIVE
#define AV_EF_AGGRESSIVE
consider things that a sane encoder/muxer should not do as an error
Definition: defs.h:56
pred
static const float pred[4]
Definition: siprdata.h:259
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition: frame.h:125
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ff_mpeg1_default_non_intra_matrix
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
Definition: mpeg12data.c:42
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:207
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:544
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: dvdec.c:147
MPVPicture::f
struct AVFrame * f
Definition: mpegpicture.h:59
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
mpeg_get_pixelformat
static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
Definition: mpeg12dec.c:829
AV_CODEC_FLAG2_CHUNKS
#define AV_CODEC_FLAG2_CHUNKS
Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
Definition: avcodec.h:351
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
mpeg12data.h
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:683
AVCodecContext
main external API structure.
Definition: avcodec.h:431
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1580
av_timecode_make_mpeg_tc_string
char * av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)
Get the timecode string from the 25-bit timecode format (MPEG GOP format).
Definition: timecode.c:147
MpegEncContext::intra_dc_precision
int intra_dc_precision
Definition: mpegvideo.h:291
AVCodecContext::execute
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:1591
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:242
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:280
mpeg12dec.h
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:772
AVRational::den
int den
Denominator.
Definition: rational.h:60
error_resilience.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
FF_HW_CALL
#define FF_HW_CALL(avctx, function,...)
Definition: hwaccel_internal.h:173
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1618
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:688
Mpeg1Context::cc_format
enum Mpeg2ClosedCaptionsFormat cc_format
Definition: mpeg12dec.c:78
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:132
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo_dec.c:360
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
Mpeg1Context::slice_count
int slice_count
Definition: mpeg12dec.c:81
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
MpegEncContext::resync_mb_x
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:221
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:1639
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
av_buffer_realloc
int av_buffer_realloc(AVBufferRef **pbuf, size_t size)
Reallocate a given buffer.
Definition: buffer.c:183
ff_mb_ptype_vlc
VLCElem ff_mb_ptype_vlc[64]
Definition: mpeg12.c:143
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1374
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:607
get_dmv
static int get_dmv(MpegEncContext *s)
Definition: mpeg12dec.c:383
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
mpeg_decode_end
static av_cold int mpeg_decode_end(AVCodecContext *avctx)
Definition: mpeg12dec.c:2609
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
IDCTDSPContext::idct_permutation
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:86
ff_ipu_decoder
const FFCodec ff_ipu_decoder
Definition: mpeg12dec.c:2860
av_stereo3d_create_side_data
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition: stereo3d.c:54
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
ER_MV_END
#define ER_MV_END
Definition: error_resilience.h:34
MpegEncContext::first_field
int first_field
is 1 for the first field of a field picture 0 otherwise
Definition: mpegvideo.h:310
MpegEncContext::q_scale_type
int q_scale_type
Definition: mpegvideo.h:295
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:456
Mpeg1Context::mpeg_enc_ctx
MpegEncContext mpeg_enc_ctx
Definition: mpeg12dec.c:73
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:181
ff_tlog
#define ff_tlog(a,...)
Definition: tableprint_vlc.h:29
AVPacket
This structure stores compressed data.
Definition: packet.h:512
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
ScanTable::permutated
uint8_t permutated[64]
Definition: mpegvideo.h:49
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:86
mpeg_get_qscale
static int mpeg_get_qscale(MpegEncContext *s)
Definition: mpegvideodec.h:80
mpeg_decode_sequence_extension
static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1012
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:70
mpeg_er.h
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
int32_t
int32_t
Definition: audioconvert.c:56
imgutils.h
AVCodecContext::properties
attribute_deprecated unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1637
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
AVStereo3DType
AVStereo3DType
List of possible 3D Types.
Definition: stereo3d.h:48
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
Mpeg1Context::frame_rate_ext
AVRational frame_rate_ext
Definition: mpeg12dec.c:84
mpeg_decode_motion
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
Definition: mpeg12dec.c:97
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
IPUContext::block
int16_t block[6][64]
Definition: mpeg12dec.c:2740
AVPanScan::height
int height
Definition: defs.h:264
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
ff_mb_btype_vlc
VLCElem ff_mb_btype_vlc[64]
Definition: mpeg12.c:144
MpegEncContext::resync_mb_y
int resync_mb_y
y position of last resync marker
Definition: mpegvideo.h:222
mpeg_decode_user_data
static void mpeg_decode_user_data(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition: mpeg12dec.c:2086
h
h
Definition: vp9dsp_template.c:2070
MpegEncContext::end_mb_y
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
Definition: mpegvideo.h:116
Mpeg2ClosedCaptionsFormat
Mpeg2ClosedCaptionsFormat
Definition: mpeg12dec.c:64
ER_AC_END
#define ER_AC_END
Definition: error_resilience.h:32
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:203
av_image_check_sar
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
Definition: imgutils.c:323
MV_VLC_BITS
#define MV_VLC_BITS
Definition: mpeg12vlc.h:34
Mpeg1Context::timecode_frame_start
int64_t timecode_frame_start
Definition: mpeg12dec.c:93
width
#define width
Definition: dsp.h:89
MpegEncContext::start_mb_y
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
Definition: mpegvideo.h:115
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:225
MpegEncContext::alternate_scan
int alternate_scan
Definition: mpegvideo.h:297
DECODE_SLICE_OK
#define DECODE_SLICE_OK
Definition: mpeg12dec.c:1335
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:54
DECODE_SLICE_ERROR
#define DECODE_SLICE_ERROR
Definition: mpeg12dec.c:1334
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:64
load_matrix
static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1[64], int intra)
Definition: mpeg12dec.c:1113
MpegEncContext::codec_id
enum AVCodecID codec_id
Definition: mpegvideo.h:95
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:616
MB_TYPE_FORWARD_MV
#define MB_TYPE_FORWARD_MV
Definition: mpegutils.h:49
decode_dc
static int decode_dc(GetBitContext *gb, int component)
Definition: mpeg12dec.h:30
Mpeg1Context::afd
uint8_t afd
Definition: mpeg12dec.c:79
Mpeg1Context
Definition: mpeg12dec.c:72
MpegEncContext::chroma_intra_matrix
uint16_t chroma_intra_matrix[64]
Definition: mpegvideo.h:216
mpeg_decode_picture_coding_extension
static int mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1150
Mpeg1Context::extradata_decoded
int extradata_decoded
Definition: mpeg12dec.c:90
mpeg2_decode_block_non_intra
static int mpeg2_decode_block_non_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:217
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:64
MBINCR_VLC_BITS
#define MBINCR_VLC_BITS
Definition: mpeg12vlc.h:37
mpeg_decode_slice
static int mpeg_decode_slice(MpegEncContext *s, int mb_y, const uint8_t **buf, int buf_size)
Decode a slice.
Definition: mpeg12dec.c:1343
MpegEncContext::chroma_format
int chroma_format
Definition: mpegvideo.h:300
MpegEncContext::codec_tag
int codec_tag
internal codec_tag upper case converted from avctx codec_tag
Definition: mpegvideo.h:98
Generated on Tue Jun 24 2025 19:22:06 for FFmpeg by   doxygen 1.8.17