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