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