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