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