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 "hwaccel.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 typedef struct Mpeg1Context {
55  int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
56  int repeat_field; /* true if we must repeat the field */
57  AVPanScan pan_scan; /* some temporary storage for the panscan */
63  int has_afd;
68  AVRational frame_rate_ext; /* MPEG-2 specific framerate modificator */
69  int sync; /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */
70  int tmpgexs;
73 } Mpeg1Context;
74 
75 #define MB_TYPE_ZERO_MV 0x20000000
76 
77 static const uint32_t ptype2mb_type[7] = {
80  MB_TYPE_L0,
81  MB_TYPE_L0 | MB_TYPE_CBP,
84  MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
85 };
86 
87 static const uint32_t btype2mb_type[11] = {
89  MB_TYPE_L1,
90  MB_TYPE_L1 | MB_TYPE_CBP,
91  MB_TYPE_L0,
92  MB_TYPE_L0 | MB_TYPE_CBP,
94  MB_TYPE_L0L1 | MB_TYPE_CBP,
96  MB_TYPE_QUANT | MB_TYPE_L1 | MB_TYPE_CBP,
97  MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
98  MB_TYPE_QUANT | MB_TYPE_L0L1 | MB_TYPE_CBP,
99 };
100 
101 /* as H.263, but only 17 codes */
102 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
103 {
104  int code, sign, val, shift;
105 
106  code = get_vlc2(&s->gb, ff_mv_vlc.table, MV_VLC_BITS, 2);
107  if (code == 0)
108  return pred;
109  if (code < 0)
110  return 0xffff;
111 
112  sign = get_bits1(&s->gb);
113  shift = fcode - 1;
114  val = code;
115  if (shift) {
116  val = (val - 1) << shift;
117  val |= get_bits(&s->gb, shift);
118  val++;
119  }
120  if (sign)
121  val = -val;
122  val += pred;
123 
124  /* modulo decoding */
125  return sign_extend(val, 5 + shift);
126 }
127 
128 #define MAX_INDEX (64 - 1)
129 #define check_scantable_index(ctx, x) \
130  do { \
131  if ((x) > MAX_INDEX) { \
132  av_log(ctx->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", \
133  ctx->mb_x, ctx->mb_y); \
134  return AVERROR_INVALIDDATA; \
135  } \
136  } while (0)
137 
139  int16_t *block, int n)
140 {
141  int level, i, j, run;
142  RLTable *rl = &ff_rl_mpeg1;
143  uint8_t *const scantable = s->intra_scantable.permutated;
144  const uint16_t *quant_matrix = s->inter_matrix;
145  const int qscale = s->qscale;
146 
147  {
148  OPEN_READER(re, &s->gb);
149  i = -1;
150  // special case for first coefficient, no need to add second VLC table
151  UPDATE_CACHE(re, &s->gb);
152  if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
153  level = (3 * qscale * quant_matrix[0]) >> 5;
154  level = (level - 1) | 1;
155  if (GET_CACHE(re, &s->gb) & 0x40000000)
156  level = -level;
157  block[0] = level;
158  i++;
159  SKIP_BITS(re, &s->gb, 2);
160  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
161  goto end;
162  }
163  /* now quantify & encode AC coefficients */
164  for (;;) {
165  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
166  TEX_VLC_BITS, 2, 0);
167 
168  if (level != 0) {
169  i += run;
170  if (i > MAX_INDEX)
171  break;
172  j = scantable[i];
173  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
174  level = (level - 1) | 1;
175  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
176  SHOW_SBITS(re, &s->gb, 1);
177  SKIP_BITS(re, &s->gb, 1);
178  } else {
179  /* escape */
180  run = SHOW_UBITS(re, &s->gb, 6) + 1;
181  LAST_SKIP_BITS(re, &s->gb, 6);
182  UPDATE_CACHE(re, &s->gb);
183  level = SHOW_SBITS(re, &s->gb, 8);
184  SKIP_BITS(re, &s->gb, 8);
185  if (level == -128) {
186  level = SHOW_UBITS(re, &s->gb, 8) - 256;
187  SKIP_BITS(re, &s->gb, 8);
188  } else if (level == 0) {
189  level = SHOW_UBITS(re, &s->gb, 8);
190  SKIP_BITS(re, &s->gb, 8);
191  }
192  i += run;
193  if (i > MAX_INDEX)
194  break;
195  j = scantable[i];
196  if (level < 0) {
197  level = -level;
198  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
199  level = (level - 1) | 1;
200  level = -level;
201  } else {
202  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
203  level = (level - 1) | 1;
204  }
205  }
206 
207  block[j] = level;
208  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
209  break;
210  UPDATE_CACHE(re, &s->gb);
211  }
212 end:
213  LAST_SKIP_BITS(re, &s->gb, 2);
214  CLOSE_READER(re, &s->gb);
215  }
216 
217  check_scantable_index(s, i);
218 
219  s->block_last_index[n] = i;
220  return 0;
221 }
222 
223 /**
224  * Note: this function can read out of range and crash for corrupt streams.
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  * Note: this function can read out of range and crash for corrupt streams.
401  * Changing this would eat up any speed benefits it has.
402  * Do not use "fast" flag if you need the code to be robust.
403  */
405  int16_t *block, int n)
406 {
407  int level, i, j, run;
408  RLTable *rl = &ff_rl_mpeg1;
409  uint8_t *const scantable = s->intra_scantable.permutated;
410  const int qscale = s->qscale;
411  OPEN_READER(re, &s->gb);
412  i = -1;
413 
414  // special case for first coefficient, no need to add second VLC table
415  UPDATE_CACHE(re, &s->gb);
416  if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
417  level = (3 * qscale) >> 1;
418  if (GET_CACHE(re, &s->gb) & 0x40000000)
419  level = -level;
420  block[0] = level;
421  i++;
422  SKIP_BITS(re, &s->gb, 2);
423  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
424  goto end;
425  }
426 
427  /* now quantify & encode AC coefficients */
428  for (;;) {
429  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
430 
431  if (level != 0) {
432  i += run;
433  if (i > MAX_INDEX)
434  break;
435  j = scantable[i];
436  level = ((level * 2 + 1) * qscale) >> 1;
437  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
438  SHOW_SBITS(re, &s->gb, 1);
439  SKIP_BITS(re, &s->gb, 1);
440  } else {
441  /* escape */
442  run = SHOW_UBITS(re, &s->gb, 6) + 1;
443  LAST_SKIP_BITS(re, &s->gb, 6);
444  UPDATE_CACHE(re, &s->gb);
445  level = SHOW_SBITS(re, &s->gb, 12);
446  SKIP_BITS(re, &s->gb, 12);
447 
448  i += run;
449  if (i > MAX_INDEX)
450  break;
451  j = scantable[i];
452  if (level < 0) {
453  level = ((-level * 2 + 1) * qscale) >> 1;
454  level = -level;
455  } else {
456  level = ((level * 2 + 1) * qscale) >> 1;
457  }
458  }
459 
460  block[j] = level;
461  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF || i > 63)
462  break;
463 
464  UPDATE_CACHE(re, &s->gb);
465  }
466 end:
467  LAST_SKIP_BITS(re, &s->gb, 2);
468  CLOSE_READER(re, &s->gb);
469 
470  check_scantable_index(s, i);
471 
472  s->block_last_index[n] = i;
473  return 0;
474 }
475 
477  int16_t *block, int n)
478 {
479  int level, dc, diff, i, j, run;
480  int component;
481  RLTable *rl;
482  uint8_t *const scantable = s->intra_scantable.permutated;
483  const uint16_t *quant_matrix;
484  const int qscale = s->qscale;
485  int mismatch;
486 
487  /* DC coefficient */
488  if (n < 4) {
489  quant_matrix = s->intra_matrix;
490  component = 0;
491  } else {
492  quant_matrix = s->chroma_intra_matrix;
493  component = (n & 1) + 1;
494  }
495  diff = decode_dc(&s->gb, component);
496  if (diff >= 0xffff)
497  return AVERROR_INVALIDDATA;
498  dc = s->last_dc[component];
499  dc += diff;
500  s->last_dc[component] = dc;
501  block[0] = dc * (1 << (3 - s->intra_dc_precision));
502  ff_tlog(s->avctx, "dc=%d\n", block[0]);
503  mismatch = block[0] ^ 1;
504  i = 0;
505  if (s->intra_vlc_format)
506  rl = &ff_rl_mpeg2;
507  else
508  rl = &ff_rl_mpeg1;
509 
510  {
511  OPEN_READER(re, &s->gb);
512  /* now quantify & encode AC coefficients */
513  for (;;) {
514  UPDATE_CACHE(re, &s->gb);
515  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
516  TEX_VLC_BITS, 2, 0);
517 
518  if (level == 127) {
519  break;
520  } else if (level != 0) {
521  i += run;
522  if (i > MAX_INDEX)
523  break;
524  j = scantable[i];
525  level = (level * qscale * quant_matrix[j]) >> 4;
526  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
527  SHOW_SBITS(re, &s->gb, 1);
528  LAST_SKIP_BITS(re, &s->gb, 1);
529  } else {
530  /* escape */
531  run = SHOW_UBITS(re, &s->gb, 6) + 1;
532  LAST_SKIP_BITS(re, &s->gb, 6);
533  UPDATE_CACHE(re, &s->gb);
534  level = SHOW_SBITS(re, &s->gb, 12);
535  SKIP_BITS(re, &s->gb, 12);
536  i += run;
537  if (i > MAX_INDEX)
538  break;
539  j = scantable[i];
540  if (level < 0) {
541  level = (-level * qscale * quant_matrix[j]) >> 4;
542  level = -level;
543  } else {
544  level = (level * qscale * quant_matrix[j]) >> 4;
545  }
546  }
547 
548  mismatch ^= level;
549  block[j] = level;
550  }
551  CLOSE_READER(re, &s->gb);
552  }
553  block[63] ^= mismatch & 1;
554 
555  check_scantable_index(s, i);
556 
557  s->block_last_index[n] = i;
558  return 0;
559 }
560 
561 /**
562  * Note: this function can read out of range and crash for corrupt streams.
563  * Changing this would eat up any speed benefits it has.
564  * Do not use "fast" flag if you need the code to be robust.
565  */
567  int16_t *block, int n)
568 {
569  int level, dc, diff, i, j, run;
570  int component;
571  RLTable *rl;
572  uint8_t *const scantable = s->intra_scantable.permutated;
573  const uint16_t *quant_matrix;
574  const int qscale = s->qscale;
575 
576  /* DC coefficient */
577  if (n < 4) {
578  quant_matrix = s->intra_matrix;
579  component = 0;
580  } else {
581  quant_matrix = s->chroma_intra_matrix;
582  component = (n & 1) + 1;
583  }
584  diff = decode_dc(&s->gb, component);
585  if (diff >= 0xffff)
586  return AVERROR_INVALIDDATA;
587  dc = s->last_dc[component];
588  dc += diff;
589  s->last_dc[component] = dc;
590  block[0] = dc * (1 << (3 - s->intra_dc_precision));
591  i = 0;
592  if (s->intra_vlc_format)
593  rl = &ff_rl_mpeg2;
594  else
595  rl = &ff_rl_mpeg1;
596 
597  {
598  OPEN_READER(re, &s->gb);
599  /* now quantify & encode AC coefficients */
600  for (;;) {
601  UPDATE_CACHE(re, &s->gb);
602  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
603  TEX_VLC_BITS, 2, 0);
604 
605  if (level >= 64 || i > 63) {
606  break;
607  } else if (level != 0) {
608  i += run;
609  j = scantable[i];
610  level = (level * qscale * quant_matrix[j]) >> 4;
611  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
612  SHOW_SBITS(re, &s->gb, 1);
613  LAST_SKIP_BITS(re, &s->gb, 1);
614  } else {
615  /* escape */
616  run = SHOW_UBITS(re, &s->gb, 6) + 1;
617  LAST_SKIP_BITS(re, &s->gb, 6);
618  UPDATE_CACHE(re, &s->gb);
619  level = SHOW_SBITS(re, &s->gb, 12);
620  SKIP_BITS(re, &s->gb, 12);
621  i += run;
622  j = scantable[i];
623  if (level < 0) {
624  level = (-level * qscale * quant_matrix[j]) >> 4;
625  level = -level;
626  } else {
627  level = (level * qscale * quant_matrix[j]) >> 4;
628  }
629  }
630 
631  block[j] = level;
632  }
633  CLOSE_READER(re, &s->gb);
634  }
635 
636  check_scantable_index(s, i);
637 
638  s->block_last_index[n] = i;
639  return 0;
640 }
641 
642 /******************************************/
643 /* decoding */
644 
645 static inline int get_dmv(MpegEncContext *s)
646 {
647  if (get_bits1(&s->gb))
648  return 1 - (get_bits1(&s->gb) << 1);
649  else
650  return 0;
651 }
652 
653 /* motion type (for MPEG-2) */
654 #define MT_FIELD 1
655 #define MT_FRAME 2
656 #define MT_16X8 2
657 #define MT_DMV 3
658 
659 static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
660 {
661  int i, j, k, cbp, val, mb_type, motion_type;
662  const int mb_block_count = 4 + (1 << s->chroma_format);
663  int ret;
664 
665  ff_tlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
666 
667  av_assert2(s->mb_skipped == 0);
668 
669  if (s->mb_skip_run-- != 0) {
670  if (s->pict_type == AV_PICTURE_TYPE_P) {
671  s->mb_skipped = 1;
672  s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
674  } else {
675  int mb_type;
676 
677  if (s->mb_x)
678  mb_type = s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];
679  else
680  // FIXME not sure if this is allowed in MPEG at all
681  mb_type = s->current_picture.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1];
682  if (IS_INTRA(mb_type)) {
683  av_log(s->avctx, AV_LOG_ERROR, "skip with previntra\n");
684  return AVERROR_INVALIDDATA;
685  }
686  s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
687  mb_type | MB_TYPE_SKIP;
688 
689  if ((s->mv[0][0][0] | s->mv[0][0][1] | s->mv[1][0][0] | s->mv[1][0][1]) == 0)
690  s->mb_skipped = 1;
691  }
692 
693  return 0;
694  }
695 
696  switch (s->pict_type) {
697  default:
698  case AV_PICTURE_TYPE_I:
699  if (get_bits1(&s->gb) == 0) {
700  if (get_bits1(&s->gb) == 0) {
702  "Invalid mb type in I-frame at %d %d\n",
703  s->mb_x, s->mb_y);
704  return AVERROR_INVALIDDATA;
705  }
706  mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
707  } else {
708  mb_type = MB_TYPE_INTRA;
709  }
710  break;
711  case AV_PICTURE_TYPE_P:
712  mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
713  if (mb_type < 0) {
715  "Invalid mb type in P-frame at %d %d\n", s->mb_x, s->mb_y);
716  return AVERROR_INVALIDDATA;
717  }
718  mb_type = ptype2mb_type[mb_type];
719  break;
720  case AV_PICTURE_TYPE_B:
721  mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
722  if (mb_type < 0) {
724  "Invalid mb type in B-frame at %d %d\n", s->mb_x, s->mb_y);
725  return AVERROR_INVALIDDATA;
726  }
727  mb_type = btype2mb_type[mb_type];
728  break;
729  }
730  ff_tlog(s->avctx, "mb_type=%x\n", mb_type);
731 // motion_type = 0; /* avoid warning */
732  if (IS_INTRA(mb_type)) {
733  s->bdsp.clear_blocks(s->block[0]);
734 
735  if (!s->chroma_y_shift)
736  s->bdsp.clear_blocks(s->block[6]);
737 
738  /* compute DCT type */
739  // FIXME: add an interlaced_dct coded var?
740  if (s->picture_structure == PICT_FRAME &&
742  s->interlaced_dct = get_bits1(&s->gb);
743 
744  if (IS_QUANT(mb_type))
745  s->qscale = mpeg_get_qscale(s);
746 
748  /* just parse them */
749  if (s->picture_structure != PICT_FRAME)
750  skip_bits1(&s->gb); /* field select */
751 
752  s->mv[0][0][0] =
753  s->last_mv[0][0][0] =
754  s->last_mv[0][1][0] = mpeg_decode_motion(s, s->mpeg_f_code[0][0],
755  s->last_mv[0][0][0]);
756  s->mv[0][0][1] =
757  s->last_mv[0][0][1] =
758  s->last_mv[0][1][1] = mpeg_decode_motion(s, s->mpeg_f_code[0][1],
759  s->last_mv[0][0][1]);
760 
761  check_marker(s->avctx, &s->gb, "after concealment_motion_vectors");
762  } else {
763  /* reset mv prediction */
764  memset(s->last_mv, 0, sizeof(s->last_mv));
765  }
766  s->mb_intra = 1;
767  // if 1, we memcpy blocks in xvmcvideo
768  if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
769  ff_xvmc_pack_pblocks(s, -1); // inter are always full blocks
770 
771  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
772  if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
773  for (i = 0; i < 6; i++)
775  } else {
776  for (i = 0; i < mb_block_count; i++)
777  if ((ret = mpeg2_decode_block_intra(s, *s->pblocks[i], i)) < 0)
778  return ret;
779  }
780  } else {
781  for (i = 0; i < 6; i++) {
783  s->intra_matrix,
785  s->last_dc, *s->pblocks[i],
786  i, s->qscale);
787  if (ret < 0) {
788  av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n",
789  s->mb_x, s->mb_y);
790  return ret;
791  }
792 
793  s->block_last_index[i] = ret;
794  }
795  }
796  } else {
797  if (mb_type & MB_TYPE_ZERO_MV) {
798  av_assert2(mb_type & MB_TYPE_CBP);
799 
800  s->mv_dir = MV_DIR_FORWARD;
801  if (s->picture_structure == PICT_FRAME) {
802  if (s->picture_structure == PICT_FRAME
803  && !s->frame_pred_frame_dct)
804  s->interlaced_dct = get_bits1(&s->gb);
805  s->mv_type = MV_TYPE_16X16;
806  } else {
807  s->mv_type = MV_TYPE_FIELD;
808  mb_type |= MB_TYPE_INTERLACED;
809  s->field_select[0][0] = s->picture_structure - 1;
810  }
811 
812  if (IS_QUANT(mb_type))
813  s->qscale = mpeg_get_qscale(s);
814 
815  s->last_mv[0][0][0] = 0;
816  s->last_mv[0][0][1] = 0;
817  s->last_mv[0][1][0] = 0;
818  s->last_mv[0][1][1] = 0;
819  s->mv[0][0][0] = 0;
820  s->mv[0][0][1] = 0;
821  } else {
822  av_assert2(mb_type & MB_TYPE_L0L1);
823  // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
824  /* get additional motion vector type */
826  motion_type = MT_FRAME;
827  } else {
828  motion_type = get_bits(&s->gb, 2);
829  if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
830  s->interlaced_dct = get_bits1(&s->gb);
831  }
832 
833  if (IS_QUANT(mb_type))
834  s->qscale = mpeg_get_qscale(s);
835 
836  /* motion vectors */
837  s->mv_dir = (mb_type >> 13) & 3;
838  ff_tlog(s->avctx, "motion_type=%d\n", motion_type);
839  switch (motion_type) {
840  case MT_FRAME: /* or MT_16X8 */
841  if (s->picture_structure == PICT_FRAME) {
842  mb_type |= MB_TYPE_16x16;
843  s->mv_type = MV_TYPE_16X16;
844  for (i = 0; i < 2; i++) {
845  if (USES_LIST(mb_type, i)) {
846  /* MT_FRAME */
847  s->mv[i][0][0] =
848  s->last_mv[i][0][0] =
849  s->last_mv[i][1][0] =
850  mpeg_decode_motion(s, s->mpeg_f_code[i][0],
851  s->last_mv[i][0][0]);
852  s->mv[i][0][1] =
853  s->last_mv[i][0][1] =
854  s->last_mv[i][1][1] =
855  mpeg_decode_motion(s, s->mpeg_f_code[i][1],
856  s->last_mv[i][0][1]);
857  /* full_pel: only for MPEG-1 */
858  if (s->full_pel[i]) {
859  s->mv[i][0][0] *= 2;
860  s->mv[i][0][1] *= 2;
861  }
862  }
863  }
864  } else {
865  mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
866  s->mv_type = MV_TYPE_16X8;
867  for (i = 0; i < 2; i++) {
868  if (USES_LIST(mb_type, i)) {
869  /* MT_16X8 */
870  for (j = 0; j < 2; j++) {
871  s->field_select[i][j] = get_bits1(&s->gb);
872  for (k = 0; k < 2; k++) {
873  val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
874  s->last_mv[i][j][k]);
875  s->last_mv[i][j][k] = val;
876  s->mv[i][j][k] = val;
877  }
878  }
879  }
880  }
881  }
882  break;
883  case MT_FIELD:
884  s->mv_type = MV_TYPE_FIELD;
885  if (s->picture_structure == PICT_FRAME) {
886  mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
887  for (i = 0; i < 2; i++) {
888  if (USES_LIST(mb_type, i)) {
889  for (j = 0; j < 2; j++) {
890  s->field_select[i][j] = get_bits1(&s->gb);
891  val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
892  s->last_mv[i][j][0]);
893  s->last_mv[i][j][0] = val;
894  s->mv[i][j][0] = val;
895  ff_tlog(s->avctx, "fmx=%d\n", val);
896  val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
897  s->last_mv[i][j][1] >> 1);
898  s->last_mv[i][j][1] = 2 * val;
899  s->mv[i][j][1] = val;
900  ff_tlog(s->avctx, "fmy=%d\n", val);
901  }
902  }
903  }
904  } else {
906  mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
907  for (i = 0; i < 2; i++) {
908  if (USES_LIST(mb_type, i)) {
909  s->field_select[i][0] = get_bits1(&s->gb);
910  for (k = 0; k < 2; k++) {
911  val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
912  s->last_mv[i][0][k]);
913  s->last_mv[i][0][k] = val;
914  s->last_mv[i][1][k] = val;
915  s->mv[i][0][k] = val;
916  }
917  }
918  }
919  }
920  break;
921  case MT_DMV:
922  if (s->progressive_sequence){
923  av_log(s->avctx, AV_LOG_ERROR, "MT_DMV in progressive_sequence\n");
924  return AVERROR_INVALIDDATA;
925  }
926  s->mv_type = MV_TYPE_DMV;
927  for (i = 0; i < 2; i++) {
928  if (USES_LIST(mb_type, i)) {
929  int dmx, dmy, mx, my, m;
930  const int my_shift = s->picture_structure == PICT_FRAME;
931 
932  mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
933  s->last_mv[i][0][0]);
934  s->last_mv[i][0][0] = mx;
935  s->last_mv[i][1][0] = mx;
936  dmx = get_dmv(s);
937  my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
938  s->last_mv[i][0][1] >> my_shift);
939  dmy = get_dmv(s);
940 
941 
942  s->last_mv[i][0][1] = my * (1 << my_shift);
943  s->last_mv[i][1][1] = my * (1 << my_shift);
944 
945  s->mv[i][0][0] = mx;
946  s->mv[i][0][1] = my;
947  s->mv[i][1][0] = mx; // not used
948  s->mv[i][1][1] = my; // not used
949 
950  if (s->picture_structure == PICT_FRAME) {
951  mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
952 
953  // m = 1 + 2 * s->top_field_first;
954  m = s->top_field_first ? 1 : 3;
955 
956  /* top -> top pred */
957  s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
958  s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
959  m = 4 - m;
960  s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
961  s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
962  } else {
963  mb_type |= MB_TYPE_16x16;
964 
965  s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
966  s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
968  s->mv[i][2][1]--;
969  else
970  s->mv[i][2][1]++;
971  }
972  }
973  }
974  break;
975  default:
977  "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
978  return AVERROR_INVALIDDATA;
979  }
980  }
981 
982  s->mb_intra = 0;
983  if (HAS_CBP(mb_type)) {
984  s->bdsp.clear_blocks(s->block[0]);
985 
987  if (mb_block_count > 6) {
988  cbp *= 1 << mb_block_count - 6;
989  cbp |= get_bits(&s->gb, mb_block_count - 6);
990  s->bdsp.clear_blocks(s->block[6]);
991  }
992  if (cbp <= 0) {
994  "invalid cbp %d at %d %d\n", cbp, s->mb_x, s->mb_y);
995  return AVERROR_INVALIDDATA;
996  }
997 
998  // if 1, we memcpy blocks in xvmcvideo
999  if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1000  ff_xvmc_pack_pblocks(s, cbp);
1001 
1002  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1003  if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1004  for (i = 0; i < 6; i++) {
1005  if (cbp & 32)
1007  else
1008  s->block_last_index[i] = -1;
1009  cbp += cbp;
1010  }
1011  } else {
1012  cbp <<= 12 - mb_block_count;
1013 
1014  for (i = 0; i < mb_block_count; i++) {
1015  if (cbp & (1 << 11)) {
1016  if ((ret = mpeg2_decode_block_non_intra(s, *s->pblocks[i], i)) < 0)
1017  return ret;
1018  } else {
1019  s->block_last_index[i] = -1;
1020  }
1021  cbp += cbp;
1022  }
1023  }
1024  } else {
1025  if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1026  for (i = 0; i < 6; i++) {
1027  if (cbp & 32)
1028  mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i);
1029  else
1030  s->block_last_index[i] = -1;
1031  cbp += cbp;
1032  }
1033  } else {
1034  for (i = 0; i < 6; i++) {
1035  if (cbp & 32) {
1036  if ((ret = mpeg1_decode_block_inter(s, *s->pblocks[i], i)) < 0)
1037  return ret;
1038  } else {
1039  s->block_last_index[i] = -1;
1040  }
1041  cbp += cbp;
1042  }
1043  }
1044  }
1045  } else {
1046  for (i = 0; i < 12; i++)
1047  s->block_last_index[i] = -1;
1048  }
1049  }
1050 
1051  s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;
1052 
1053  return 0;
1054 }
1055 
1057 {
1058  Mpeg1Context *s = avctx->priv_data;
1060 
1062 
1063  if ( avctx->codec_tag != AV_RL32("VCR2")
1064  && avctx->codec_tag != AV_RL32("BW10"))
1065  avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
1066  ff_mpv_decode_init(s2, avctx);
1067 
1068  s->mpeg_enc_ctx.avctx = avctx;
1069 
1070  /* we need some permutation to store matrices,
1071  * until the decoder sets the real permutation. */
1072  ff_mpv_idct_init(s2);
1075 
1076  s2->chroma_format = 1;
1077  s->mpeg_enc_ctx_allocated = 0;
1079  s->repeat_field = 0;
1080  s->mpeg_enc_ctx.codec_id = avctx->codec->id;
1081  avctx->color_range = AVCOL_RANGE_MPEG;
1082  return 0;
1083 }
1084 
1085 #if HAVE_THREADS
1086 static int mpeg_decode_update_thread_context(AVCodecContext *avctx,
1087  const AVCodecContext *avctx_from)
1088 {
1089  Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data;
1090  MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx;
1091  int err;
1092 
1093  if (avctx == avctx_from ||
1094  !ctx_from->mpeg_enc_ctx_allocated ||
1095  !s1->context_initialized)
1096  return 0;
1097 
1098  err = ff_mpeg_update_thread_context(avctx, avctx_from);
1099  if (err)
1100  return err;
1101 
1102  if (!ctx->mpeg_enc_ctx_allocated)
1103  memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext));
1104 
1105  if (!(s->pict_type == AV_PICTURE_TYPE_B || s->low_delay))
1106  s->picture_number++;
1107 
1108  return 0;
1109 }
1110 #endif
1111 
1112 static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1113  const uint8_t *new_perm)
1114 {
1115  uint16_t temp_matrix[64];
1116  int i;
1117 
1118  memcpy(temp_matrix, matrix, 64 * sizeof(uint16_t));
1119 
1120  for (i = 0; i < 64; i++)
1121  matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1122 }
1123 
1125 #if CONFIG_MPEG1_NVDEC_HWACCEL
1127 #endif
1128 #if CONFIG_MPEG1_XVMC_HWACCEL
1130 #endif
1131 #if CONFIG_MPEG1_VDPAU_HWACCEL
1133 #endif
1136 };
1137 
1139 #if CONFIG_MPEG2_NVDEC_HWACCEL
1141 #endif
1142 #if CONFIG_MPEG2_XVMC_HWACCEL
1144 #endif
1145 #if CONFIG_MPEG2_VDPAU_HWACCEL
1147 #endif
1148 #if CONFIG_MPEG2_DXVA2_HWACCEL
1150 #endif
1151 #if CONFIG_MPEG2_D3D11VA_HWACCEL
1154 #endif
1155 #if CONFIG_MPEG2_VAAPI_HWACCEL
1157 #endif
1158 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
1160 #endif
1163 };
1164 
1165 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
1168 };
1169 
1170 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
1173 };
1174 
1176 {
1177  Mpeg1Context *s1 = avctx->priv_data;
1178  MpegEncContext *s = &s1->mpeg_enc_ctx;
1179  const enum AVPixelFormat *pix_fmts;
1180 
1181  if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
1182  return AV_PIX_FMT_GRAY8;
1183 
1184  if (s->chroma_format < 2)
1185  pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
1188  else if (s->chroma_format == 2)
1189  pix_fmts = mpeg12_pixfmt_list_422;
1190  else
1191  pix_fmts = mpeg12_pixfmt_list_444;
1192 
1193  return ff_thread_get_format(avctx, pix_fmts);
1194 }
1195 
1197 {
1198  // until then pix_fmt may be changed right after codec init
1199  if (avctx->hwaccel)
1200  if (avctx->idct_algo == FF_IDCT_AUTO)
1201  avctx->idct_algo = FF_IDCT_NONE;
1202 
1203  if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
1204  Mpeg1Context *s1 = avctx->priv_data;
1205  MpegEncContext *s = &s1->mpeg_enc_ctx;
1206 
1207  s->pack_pblocks = 1;
1208  }
1209 }
1210 
1211 /* Call this function when we know all parameters.
1212  * It may be called in different places for MPEG-1 and MPEG-2. */
1214 {
1215  Mpeg1Context *s1 = avctx->priv_data;
1216  MpegEncContext *s = &s1->mpeg_enc_ctx;
1217  uint8_t old_permutation[64];
1218  int ret;
1219 
1220  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1221  // MPEG-1 aspect
1222  AVRational aspect_inv = av_d2q(ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1223  avctx->sample_aspect_ratio = (AVRational) { aspect_inv.den, aspect_inv.num };
1224  } else { // MPEG-2
1225  // MPEG-2 aspect
1226  if (s->aspect_ratio_info > 1) {
1227  AVRational dar =
1229  (AVRational) { s1->pan_scan.width,
1230  s1->pan_scan.height }),
1231  (AVRational) { s->width, s->height });
1232 
1233  /* We ignore the spec here and guess a bit as reality does not
1234  * match the spec, see for example res_change_ffmpeg_aspect.ts
1235  * and sequence-display-aspect.mpg.
1236  * issue1613, 621, 562 */
1237  if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1238  (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
1239  av_cmp_q(dar, (AVRational) { 16, 9 }))) {
1242  (AVRational) { s->width, s->height });
1243  } else {
1246  (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
1247 // issue1613 4/3 16/9 -> 16/9
1248 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1249 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
1250 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1251  ff_dlog(avctx, "aspect A %d/%d\n",
1254  ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1256  }
1257  } else {
1260  }
1261  } // MPEG-2
1262 
1263  if (av_image_check_sar(s->width, s->height,
1264  avctx->sample_aspect_ratio) < 0) {
1265  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1266  avctx->sample_aspect_ratio.num,
1267  avctx->sample_aspect_ratio.den);
1268  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1269  }
1270 
1271  if ((s1->mpeg_enc_ctx_allocated == 0) ||
1272  avctx->coded_width != s->width ||
1273  avctx->coded_height != s->height ||
1274  s1->save_width != s->width ||
1275  s1->save_height != s->height ||
1277  (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
1278  0) {
1279  if (s1->mpeg_enc_ctx_allocated) {
1280  ParseContext pc = s->parse_context;
1281  s->parse_context.buffer = 0;
1282  ff_mpv_common_end(s);
1283  s->parse_context = pc;
1284  s1->mpeg_enc_ctx_allocated = 0;
1285  }
1286 
1287  ret = ff_set_dimensions(avctx, s->width, s->height);
1288  if (ret < 0)
1289  return ret;
1290 
1291  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
1292  avctx->rc_max_rate = s->bit_rate;
1293  } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
1294  (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
1295  avctx->bit_rate = s->bit_rate;
1296  }
1298  s1->save_width = s->width;
1299  s1->save_height = s->height;
1301 
1302  /* low_delay may be forced, in this case we will have B-frames
1303  * that behave like P-frames. */
1304  avctx->has_b_frames = !s->low_delay;
1305 
1306  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1307  // MPEG-1 fps
1309  avctx->ticks_per_frame = 1;
1310 
1312  } else { // MPEG-2
1313  // MPEG-2 fps
1315  &s->avctx->framerate.den,
1318  1 << 30);
1319  avctx->ticks_per_frame = 2;
1320 
1321  switch (s->chroma_format) {
1322  case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
1323  case 2:
1324  case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
1325  default: av_assert0(0);
1326  }
1327  } // MPEG-2
1328 
1329  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1330  setup_hwaccel_for_pixfmt(avctx);
1331 
1332  /* Quantization matrices may need reordering
1333  * if DCT permutation is changed. */
1334  memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1335 
1336  ff_mpv_idct_init(s);
1337  if ((ret = ff_mpv_common_init(s)) < 0)
1338  return ret;
1339 
1340  quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
1341  quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
1344 
1345  s1->mpeg_enc_ctx_allocated = 1;
1346  }
1347  return 0;
1348 }
1349 
1351  int buf_size)
1352 {
1353  Mpeg1Context *s1 = avctx->priv_data;
1354  MpegEncContext *s = &s1->mpeg_enc_ctx;
1355  int ref, f_code, vbv_delay;
1356 
1357  init_get_bits(&s->gb, buf, buf_size * 8);
1358 
1359  ref = get_bits(&s->gb, 10); /* temporal ref */
1360  s->pict_type = get_bits(&s->gb, 3);
1361  if (s->pict_type == 0 || s->pict_type > 3)
1362  return AVERROR_INVALIDDATA;
1363 
1364  vbv_delay = get_bits(&s->gb, 16);
1365  s->vbv_delay = vbv_delay;
1366  if (s->pict_type == AV_PICTURE_TYPE_P ||
1367  s->pict_type == AV_PICTURE_TYPE_B) {
1368  s->full_pel[0] = get_bits1(&s->gb);
1369  f_code = get_bits(&s->gb, 3);
1370  if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1371  return AVERROR_INVALIDDATA;
1372  f_code += !f_code;
1373  s->mpeg_f_code[0][0] = f_code;
1374  s->mpeg_f_code[0][1] = f_code;
1375  }
1376  if (s->pict_type == AV_PICTURE_TYPE_B) {
1377  s->full_pel[1] = get_bits1(&s->gb);
1378  f_code = get_bits(&s->gb, 3);
1379  if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1380  return AVERROR_INVALIDDATA;
1381  f_code += !f_code;
1382  s->mpeg_f_code[1][0] = f_code;
1383  s->mpeg_f_code[1][1] = f_code;
1384  }
1387 
1388  if (avctx->debug & FF_DEBUG_PICT_INFO)
1389  av_log(avctx, AV_LOG_DEBUG,
1390  "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1391 
1392  s->y_dc_scale = 8;
1393  s->c_dc_scale = 8;
1394  return 0;
1395 }
1396 
1398 {
1399  MpegEncContext *s = &s1->mpeg_enc_ctx;
1400  int horiz_size_ext, vert_size_ext;
1401  int bit_rate_ext;
1402  AVCPBProperties *cpb_props;
1403 
1404  skip_bits(&s->gb, 1); /* profile and level esc*/
1405  s->avctx->profile = get_bits(&s->gb, 3);
1406  s->avctx->level = get_bits(&s->gb, 4);
1407  s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1408  s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1409 
1410  if (!s->chroma_format) {
1411  s->chroma_format = 1;
1412  av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1413  }
1414 
1415  horiz_size_ext = get_bits(&s->gb, 2);
1416  vert_size_ext = get_bits(&s->gb, 2);
1417  s->width |= (horiz_size_ext << 12);
1418  s->height |= (vert_size_ext << 12);
1419  bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1420  s->bit_rate += (bit_rate_ext << 18) * 400LL;
1421  check_marker(s->avctx, &s->gb, "after bit rate extension");
1422  s1->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1423 
1424  s->low_delay = get_bits1(&s->gb);
1426  s->low_delay = 1;
1427 
1428  s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1429  s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1430 
1431  ff_dlog(s->avctx, "sequence extension\n");
1433 
1434  if (cpb_props = ff_add_cpb_side_data(s->avctx)) {
1435  cpb_props->buffer_size = s1->rc_buffer_size;
1436  if (s->bit_rate != 0x3FFFF*400)
1437  cpb_props->max_bitrate = s->bit_rate;
1438  }
1439 
1440  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1442  "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n",
1444  s1->rc_buffer_size, s->bit_rate);
1445 }
1446 
1448 {
1449  MpegEncContext *s = &s1->mpeg_enc_ctx;
1450  int color_description, w, h;
1451 
1452  skip_bits(&s->gb, 3); /* video format */
1453  color_description = get_bits1(&s->gb);
1454  if (color_description) {
1455  s->avctx->color_primaries = get_bits(&s->gb, 8);
1456  s->avctx->color_trc = get_bits(&s->gb, 8);
1457  s->avctx->colorspace = get_bits(&s->gb, 8);
1458  }
1459  w = get_bits(&s->gb, 14);
1460  skip_bits(&s->gb, 1); // marker
1461  h = get_bits(&s->gb, 14);
1462  // remaining 3 bits are zero padding
1463 
1464  s1->pan_scan.width = 16 * w;
1465  s1->pan_scan.height = 16 * h;
1466 
1467  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1468  av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1469 }
1470 
1472 {
1473  MpegEncContext *s = &s1->mpeg_enc_ctx;
1474  int i, nofco;
1475 
1476  nofco = 1;
1477  if (s->progressive_sequence) {
1478  if (s->repeat_first_field) {
1479  nofco++;
1480  if (s->top_field_first)
1481  nofco++;
1482  }
1483  } else {
1484  if (s->picture_structure == PICT_FRAME) {
1485  nofco++;
1486  if (s->repeat_first_field)
1487  nofco++;
1488  }
1489  }
1490  for (i = 0; i < nofco; i++) {
1491  s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1492  skip_bits(&s->gb, 1); // marker
1493  s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1494  skip_bits(&s->gb, 1); // marker
1495  }
1496 
1497  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1499  "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1500  s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1501  s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1502  s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1503 }
1504 
1505 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1506  uint16_t matrix1[64], int intra)
1507 {
1508  int i;
1509 
1510  for (i = 0; i < 64; i++) {
1511  int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1512  int v = get_bits(&s->gb, 8);
1513  if (v == 0) {
1514  av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1515  return AVERROR_INVALIDDATA;
1516  }
1517  if (intra && i == 0 && v != 8) {
1518  av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1519  v = 8; // needed by pink.mpg / issue1046
1520  }
1521  matrix0[j] = v;
1522  if (matrix1)
1523  matrix1[j] = v;
1524  }
1525  return 0;
1526 }
1527 
1529 {
1530  ff_dlog(s->avctx, "matrix extension\n");
1531 
1532  if (get_bits1(&s->gb))
1534  if (get_bits1(&s->gb))
1536  if (get_bits1(&s->gb))
1538  if (get_bits1(&s->gb))
1540 }
1541 
1543 {
1544  MpegEncContext *s = &s1->mpeg_enc_ctx;
1545 
1546  s->full_pel[0] = s->full_pel[1] = 0;
1547  s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1548  s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1549  s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1550  s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1551  if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1553  "Missing picture start code, guessing missing values\n");
1554  if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1555  if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1557  else
1559  } else
1563  }
1564  s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1565  s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1566  s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1567  s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1568 
1569  s->intra_dc_precision = get_bits(&s->gb, 2);
1570  s->picture_structure = get_bits(&s->gb, 2);
1571  s->top_field_first = get_bits1(&s->gb);
1572  s->frame_pred_frame_dct = get_bits1(&s->gb);
1574  s->q_scale_type = get_bits1(&s->gb);
1575  s->intra_vlc_format = get_bits1(&s->gb);
1576  s->alternate_scan = get_bits1(&s->gb);
1577  s->repeat_first_field = get_bits1(&s->gb);
1578  s->chroma_420_type = get_bits1(&s->gb);
1579  s->progressive_frame = get_bits1(&s->gb);
1580 
1581  if (s->alternate_scan) {
1584  } else {
1587  }
1588 
1589  /* composite display not parsed */
1590  ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1591  ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1592  ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1593  ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1594  ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1595  ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1596  ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1597  ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1598  ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1599 }
1600 
1601 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1602 {
1603  AVCodecContext *avctx = s->avctx;
1604  Mpeg1Context *s1 = (Mpeg1Context *) s;
1605  int ret;
1606 
1607  if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
1608  if (s->mb_width * s->mb_height * 11LL / (33 * 2 * 8) > buf_size)
1609  return AVERROR_INVALIDDATA;
1610  }
1611 
1612  /* start frame decoding */
1613  if (s->first_field || s->picture_structure == PICT_FRAME) {
1615 
1616  if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1617  return ret;
1618 
1620 
1621  /* first check if we must repeat the frame */
1623  if (s->repeat_first_field) {
1624  if (s->progressive_sequence) {
1625  if (s->top_field_first)
1627  else
1629  } else if (s->progressive_frame) {
1631  }
1632  }
1633 
1636  sizeof(s1->pan_scan));
1637  if (!pan_scan)
1638  return AVERROR(ENOMEM);
1639  memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1640 
1641  if (s1->a53_caption) {
1644  s1->a53_caption_size);
1645  if (sd)
1646  memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1647  av_freep(&s1->a53_caption);
1648  }
1649 
1650  if (s1->has_stereo3d) {
1652  if (!stereo)
1653  return AVERROR(ENOMEM);
1654 
1655  *stereo = s1->stereo3d;
1656  s1->has_stereo3d = 0;
1657  }
1658 
1659  if (s1->has_afd) {
1660  AVFrameSideData *sd =
1662  AV_FRAME_DATA_AFD, 1);
1663  if (!sd)
1664  return AVERROR(ENOMEM);
1665 
1666  *sd->data = s1->afd;
1667  s1->has_afd = 0;
1668  }
1669 
1670  if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1671  ff_thread_finish_setup(avctx);
1672  } else { // second field
1673  int i;
1674 
1675  if (!s->current_picture_ptr) {
1676  av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1677  return AVERROR_INVALIDDATA;
1678  }
1679 
1680  if (s->avctx->hwaccel) {
1681  if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
1682  av_log(avctx, AV_LOG_ERROR,
1683  "hardware accelerator failed to decode first field\n");
1684  return ret;
1685  }
1686  }
1687 
1688  for (i = 0; i < 4; i++) {
1691  s->current_picture.f->data[i] +=
1693  }
1694  }
1695 
1696  if (avctx->hwaccel) {
1697  if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1698  return ret;
1699  }
1700 
1701  return 0;
1702 }
1703 
1704 #define DECODE_SLICE_ERROR -1
1705 #define DECODE_SLICE_OK 0
1706 
1707 /**
1708  * Decode a slice.
1709  * MpegEncContext.mb_y must be set to the MB row from the startcode.
1710  * @return DECODE_SLICE_ERROR if the slice is damaged,
1711  * DECODE_SLICE_OK if this slice is OK
1712  */
1713 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1714  const uint8_t **buf, int buf_size)
1715 {
1716  AVCodecContext *avctx = s->avctx;
1717  const int lowres = s->avctx->lowres;
1718  const int field_pic = s->picture_structure != PICT_FRAME;
1719  int ret;
1720 
1721  s->resync_mb_x =
1722  s->resync_mb_y = -1;
1723 
1724  av_assert0(mb_y < s->mb_height);
1725 
1726  init_get_bits(&s->gb, *buf, buf_size * 8);
1727  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1728  skip_bits(&s->gb, 3);
1729 
1731  s->interlaced_dct = 0;
1732 
1733  s->qscale = mpeg_get_qscale(s);
1734 
1735  if (s->qscale == 0) {
1736  av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1737  return AVERROR_INVALIDDATA;
1738  }
1739 
1740  /* extra slice info */
1741  if (skip_1stop_8data_bits(&s->gb) < 0)
1742  return AVERROR_INVALIDDATA;
1743 
1744  s->mb_x = 0;
1745 
1746  if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1747  skip_bits1(&s->gb);
1748  } else {
1749  while (get_bits_left(&s->gb) > 0) {
1750  int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1751  MBINCR_VLC_BITS, 2);
1752  if (code < 0) {
1753  av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1754  return AVERROR_INVALIDDATA;
1755  }
1756  if (code >= 33) {
1757  if (code == 33)
1758  s->mb_x += 33;
1759  /* otherwise, stuffing, nothing to do */
1760  } else {
1761  s->mb_x += code;
1762  break;
1763  }
1764  }
1765  }
1766 
1767  if (s->mb_x >= (unsigned) s->mb_width) {
1768  av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1769  return AVERROR_INVALIDDATA;
1770  }
1771 
1772  if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1773  const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1774  int start_code = -1;
1775  buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1776  if (buf_end < *buf + buf_size)
1777  buf_end -= 4;
1778  s->mb_y = mb_y;
1779  if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1780  return DECODE_SLICE_ERROR;
1781  *buf = buf_end;
1782  return DECODE_SLICE_OK;
1783  }
1784 
1785  s->resync_mb_x = s->mb_x;
1786  s->resync_mb_y = s->mb_y = mb_y;
1787  s->mb_skip_run = 0;
1789 
1790  if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1791  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1793  "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",
1794  s->qscale,
1795  s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1796  s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1797  s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1798  (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1799  (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1800  s->progressive_sequence ? "ps" : "",
1801  s->progressive_frame ? "pf" : "",
1802  s->alternate_scan ? "alt" : "",
1803  s->top_field_first ? "top" : "",
1807  s->repeat_first_field, s->chroma_420_type ? "420" : "");
1808  }
1809  }
1810 
1811  for (;;) {
1812  // If 1, we memcpy blocks in xvmcvideo.
1813  if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1814  ff_xvmc_init_block(s); // set s->block
1815 
1816  if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1817  return ret;
1818 
1819  // Note motion_val is normally NULL unless we want to extract the MVs.
1820  if (s->current_picture.motion_val[0] && !s->encoding) {
1821  const int wrap = s->b8_stride;
1822  int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1823  int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1824  int motion_x, motion_y, dir, i;
1825 
1826  for (i = 0; i < 2; i++) {
1827  for (dir = 0; dir < 2; dir++) {
1828  if (s->mb_intra ||
1829  (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1830  motion_x = motion_y = 0;
1831  } else if (s->mv_type == MV_TYPE_16X16 ||
1832  (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1833  motion_x = s->mv[dir][0][0];
1834  motion_y = s->mv[dir][0][1];
1835  } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1836  motion_x = s->mv[dir][i][0];
1837  motion_y = s->mv[dir][i][1];
1838  }
1839 
1840  s->current_picture.motion_val[dir][xy][0] = motion_x;
1841  s->current_picture.motion_val[dir][xy][1] = motion_y;
1842  s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1843  s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1844  s->current_picture.ref_index [dir][b8_xy] =
1845  s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1846  av_assert2(s->field_select[dir][i] == 0 ||
1847  s->field_select[dir][i] == 1);
1848  }
1849  xy += wrap;
1850  b8_xy += 2;
1851  }
1852  }
1853 
1854  s->dest[0] += 16 >> lowres;
1855  s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1856  s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1857 
1859 
1860  if (++s->mb_x >= s->mb_width) {
1861  const int mb_size = 16 >> s->avctx->lowres;
1862  int left;
1863 
1864  ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1866 
1867  s->mb_x = 0;
1868  s->mb_y += 1 << field_pic;
1869 
1870  if (s->mb_y >= s->mb_height) {
1871  int left = get_bits_left(&s->gb);
1872  int is_d10 = s->chroma_format == 2 &&
1873  s->pict_type == AV_PICTURE_TYPE_I &&
1874  avctx->profile == 0 && avctx->level == 5 &&
1875  s->intra_dc_precision == 2 &&
1876  s->q_scale_type == 1 && s->alternate_scan == 0 &&
1877  s->progressive_frame == 0
1878  /* vbv_delay == 0xBBB || 0xE10 */;
1879 
1880  if (left >= 32 && !is_d10) {
1881  GetBitContext gb = s->gb;
1882  align_get_bits(&gb);
1883  if (show_bits(&gb, 24) == 0x060E2B) {
1884  av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1885  is_d10 = 1;
1886  }
1887  if (left > 32 && show_bits_long(&gb, 32) == 0x201) {
1888  av_log(avctx, AV_LOG_DEBUG, "skipping m704 alpha (unsupported)\n");
1889  goto eos;
1890  }
1891  }
1892 
1893  if (left < 0 ||
1894  (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1895  ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1896  av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X at %d %d\n",
1897  left, left>0 ? show_bits(&s->gb, FFMIN(left, 23)) : 0, s->mb_x, s->mb_y);
1898  return AVERROR_INVALIDDATA;
1899  } else
1900  goto eos;
1901  }
1902  // There are some files out there which are missing the last slice
1903  // in cases where the slice is completely outside the visible
1904  // area, we detect this here instead of running into the end expecting
1905  // more data
1906  left = get_bits_left(&s->gb);
1907  if (s->mb_y >= ((s->height + 15) >> 4) &&
1908  !s->progressive_sequence &&
1909  left <= 25 &&
1910  left >= 0 &&
1911  s->mb_skip_run == -1 &&
1912  (!left || show_bits(&s->gb, left) == 0))
1913  goto eos;
1914 
1916  }
1917 
1918  /* skip mb handling */
1919  if (s->mb_skip_run == -1) {
1920  /* read increment again */
1921  s->mb_skip_run = 0;
1922  for (;;) {
1923  int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1924  MBINCR_VLC_BITS, 2);
1925  if (code < 0) {
1926  av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1927  return AVERROR_INVALIDDATA;
1928  }
1929  if (code >= 33) {
1930  if (code == 33) {
1931  s->mb_skip_run += 33;
1932  } else if (code == 35) {
1933  if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1934  av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1935  return AVERROR_INVALIDDATA;
1936  }
1937  goto eos; /* end of slice */
1938  }
1939  /* otherwise, stuffing, nothing to do */
1940  } else {
1941  s->mb_skip_run += code;
1942  break;
1943  }
1944  }
1945  if (s->mb_skip_run) {
1946  int i;
1947  if (s->pict_type == AV_PICTURE_TYPE_I) {
1949  "skipped MB in I-frame at %d %d\n", s->mb_x, s->mb_y);
1950  return AVERROR_INVALIDDATA;
1951  }
1952 
1953  /* skip mb */
1954  s->mb_intra = 0;
1955  for (i = 0; i < 12; i++)
1956  s->block_last_index[i] = -1;
1958  s->mv_type = MV_TYPE_16X16;
1959  else
1960  s->mv_type = MV_TYPE_FIELD;
1961  if (s->pict_type == AV_PICTURE_TYPE_P) {
1962  /* if P type, zero motion vector is implied */
1963  s->mv_dir = MV_DIR_FORWARD;
1964  s->mv[0][0][0] = s->mv[0][0][1] = 0;
1965  s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1966  s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1967  s->field_select[0][0] = (s->picture_structure - 1) & 1;
1968  } else {
1969  /* if B type, reuse previous vectors and directions */
1970  s->mv[0][0][0] = s->last_mv[0][0][0];
1971  s->mv[0][0][1] = s->last_mv[0][0][1];
1972  s->mv[1][0][0] = s->last_mv[1][0][0];
1973  s->mv[1][0][1] = s->last_mv[1][0][1];
1974  s->field_select[0][0] = (s->picture_structure - 1) & 1;
1975  s->field_select[1][0] = (s->picture_structure - 1) & 1;
1976  }
1977  }
1978  }
1979  }
1980 eos: // end of slice
1981  if (get_bits_left(&s->gb) < 0) {
1982  av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
1983  return AVERROR_INVALIDDATA;
1984  }
1985  *buf += (get_bits_count(&s->gb) - 1) / 8;
1986  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);
1987  return 0;
1988 }
1989 
1991 {
1992  MpegEncContext *s = *(void **) arg;
1993  const uint8_t *buf = s->gb.buffer;
1994  int mb_y = s->start_mb_y;
1995  const int field_pic = s->picture_structure != PICT_FRAME;
1996 
1997  s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
1998 
1999  for (;;) {
2000  uint32_t start_code;
2001  int ret;
2002 
2003  ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2004  emms_c();
2005  ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2006  ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2007  s->start_mb_y, s->end_mb_y, s->er.error_count);
2008  if (ret < 0) {
2009  if (c->err_recognition & AV_EF_EXPLODE)
2010  return ret;
2011  if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2013  s->mb_x, s->mb_y,
2015  } else {
2017  s->mb_x - 1, s->mb_y,
2019  }
2020 
2021  if (s->mb_y == s->end_mb_y)
2022  return 0;
2023 
2024  start_code = -1;
2025  buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2026  if (start_code < SLICE_MIN_START_CODE || start_code > SLICE_MAX_START_CODE)
2027  return AVERROR_INVALIDDATA;
2028  mb_y = start_code - SLICE_MIN_START_CODE;
2029  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2030  mb_y += (*buf&0xE0)<<2;
2031  mb_y <<= field_pic;
2033  mb_y++;
2034  if (mb_y >= s->end_mb_y)
2035  return AVERROR_INVALIDDATA;
2036  }
2037 }
2038 
2039 /**
2040  * Handle slice ends.
2041  * @return 1 if it seems to be the last slice
2042  */
2043 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2044 {
2045  Mpeg1Context *s1 = avctx->priv_data;
2046  MpegEncContext *s = &s1->mpeg_enc_ctx;
2047 
2049  return 0;
2050 
2051  if (s->avctx->hwaccel) {
2052  int ret = s->avctx->hwaccel->end_frame(s->avctx);
2053  if (ret < 0) {
2054  av_log(avctx, AV_LOG_ERROR,
2055  "hardware accelerator failed to decode picture\n");
2056  return ret;
2057  }
2058  }
2059 
2060  /* end of slice reached */
2061  if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2062  /* end of image */
2063 
2064  ff_er_frame_end(&s->er);
2065 
2066  ff_mpv_frame_end(s);
2067 
2068  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2069  int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2070  if (ret < 0)
2071  return ret;
2074  } else {
2075  if (avctx->active_thread_type & FF_THREAD_FRAME)
2076  s->picture_number++;
2077  /* latency of 1 frame for I- and P-frames */
2078  /* XXX: use another variable than picture_number */
2079  if (s->last_picture_ptr) {
2080  int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2081  if (ret < 0)
2082  return ret;
2085  }
2086  }
2087 
2088  return 1;
2089  } else {
2090  return 0;
2091  }
2092 }
2093 
2095  const uint8_t *buf, int buf_size)
2096 {
2097  Mpeg1Context *s1 = avctx->priv_data;
2098  MpegEncContext *s = &s1->mpeg_enc_ctx;
2099  int width, height;
2100  int i, v, j;
2101 
2102  init_get_bits(&s->gb, buf, buf_size * 8);
2103 
2104  width = get_bits(&s->gb, 12);
2105  height = get_bits(&s->gb, 12);
2106  if (width == 0 || height == 0) {
2107  av_log(avctx, AV_LOG_WARNING,
2108  "Invalid horizontal or vertical size value.\n");
2110  return AVERROR_INVALIDDATA;
2111  }
2112  s->aspect_ratio_info = get_bits(&s->gb, 4);
2113  if (s->aspect_ratio_info == 0) {
2114  av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2116  return AVERROR_INVALIDDATA;
2117  }
2118  s->frame_rate_index = get_bits(&s->gb, 4);
2119  if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2120  av_log(avctx, AV_LOG_WARNING,
2121  "frame_rate_index %d is invalid\n", s->frame_rate_index);
2122  s->frame_rate_index = 1;
2123  }
2124  s->bit_rate = get_bits(&s->gb, 18) * 400LL;
2125  if (check_marker(s->avctx, &s->gb, "in sequence header") == 0) {
2126  return AVERROR_INVALIDDATA;
2127  }
2128 
2129  s1->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2130  skip_bits(&s->gb, 1);
2131 
2132  /* get matrix */
2133  if (get_bits1(&s->gb)) {
2135  } else {
2136  for (i = 0; i < 64; i++) {
2137  j = s->idsp.idct_permutation[i];
2139  s->intra_matrix[j] = v;
2140  s->chroma_intra_matrix[j] = v;
2141  }
2142  }
2143  if (get_bits1(&s->gb)) {
2145  } else {
2146  for (i = 0; i < 64; i++) {
2147  int j = s->idsp.idct_permutation[i];
2149  s->inter_matrix[j] = v;
2150  s->chroma_inter_matrix[j] = v;
2151  }
2152  }
2153 
2154  if (show_bits(&s->gb, 23) != 0) {
2155  av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2156  return AVERROR_INVALIDDATA;
2157  }
2158 
2159  s->width = width;
2160  s->height = height;
2161 
2162  /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2163  s->progressive_sequence = 1;
2164  s->progressive_frame = 1;
2166  s->first_field = 0;
2167  s->frame_pred_frame_dct = 1;
2168  s->chroma_format = 1;
2169  s->codec_id =
2171  s->out_format = FMT_MPEG1;
2172  s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2174  s->low_delay = 1;
2175 
2176  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2177  av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
2179 
2180  return 0;
2181 }
2182 
2184 {
2185  Mpeg1Context *s1 = avctx->priv_data;
2186  MpegEncContext *s = &s1->mpeg_enc_ctx;
2187  int i, v, ret;
2188 
2189  /* start new MPEG-1 context decoding */
2190  s->out_format = FMT_MPEG1;
2191  if (s1->mpeg_enc_ctx_allocated) {
2192  ff_mpv_common_end(s);
2193  s1->mpeg_enc_ctx_allocated = 0;
2194  }
2195  s->width = avctx->coded_width;
2196  s->height = avctx->coded_height;
2197  avctx->has_b_frames = 0; // true?
2198  s->low_delay = 1;
2199 
2200  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2201  setup_hwaccel_for_pixfmt(avctx);
2202 
2203  ff_mpv_idct_init(s);
2204  if ((ret = ff_mpv_common_init(s)) < 0)
2205  return ret;
2206  s1->mpeg_enc_ctx_allocated = 1;
2207 
2208  for (i = 0; i < 64; i++) {
2209  int j = s->idsp.idct_permutation[i];
2211  s->intra_matrix[j] = v;
2212  s->chroma_intra_matrix[j] = v;
2213 
2215  s->inter_matrix[j] = v;
2216  s->chroma_inter_matrix[j] = v;
2217  }
2218 
2219  s->progressive_sequence = 1;
2220  s->progressive_frame = 1;
2222  s->first_field = 0;
2223  s->frame_pred_frame_dct = 1;
2224  s->chroma_format = 1;
2225  if (s->codec_tag == AV_RL32("BW10")) {
2227  } else {
2228  s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2230  }
2231  s1->save_width = s->width;
2232  s1->save_height = s->height;
2234  return 0;
2235 }
2236 
2238  const uint8_t *p, int buf_size)
2239 {
2240  Mpeg1Context *s1 = avctx->priv_data;
2241 
2242  if (buf_size >= 6 &&
2243  p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2244  p[4] == 3 && (p[5] & 0x40)) {
2245  /* extract A53 Part 4 CC data */
2246  int cc_count = p[5] & 0x1f;
2247  if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2248  av_freep(&s1->a53_caption);
2249  s1->a53_caption_size = cc_count * 3;
2251  if (!s1->a53_caption) {
2252  s1->a53_caption_size = 0;
2253  } else {
2254  memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2255  }
2257  }
2258  return 1;
2259  } else if (buf_size >= 2 &&
2260  p[0] == 0x03 && (p[1]&0x7f) == 0x01) {
2261  /* extract SCTE-20 CC data */
2262  GetBitContext gb;
2263  int cc_count = 0;
2264  int i;
2265 
2266  init_get_bits(&gb, p + 2, buf_size - 2);
2267  cc_count = get_bits(&gb, 5);
2268  if (cc_count > 0) {
2269  av_freep(&s1->a53_caption);
2270  s1->a53_caption_size = cc_count * 3;
2272  if (!s1->a53_caption) {
2273  s1->a53_caption_size = 0;
2274  } else {
2275  uint8_t field, cc1, cc2;
2276  uint8_t *cap = s1->a53_caption;
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;
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  av_freep(&s1->a53_caption);
2336  s1->a53_caption_size = cc_count * 6;
2338  if (!s1->a53_caption) {
2339  s1->a53_caption_size = 0;
2340  } else {
2341  uint8_t field1 = !!(p[4] & 0x80);
2342  uint8_t *cap = s1->a53_caption;
2343  p += 5;
2344  for (i = 0; i < cc_count; i++) {
2345  cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2346  cap[1] = p[1];
2347  cap[2] = p[2];
2348  cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2349  cap[4] = p[4];
2350  cap[5] = p[5];
2351  cap += 6;
2352  p += 6;
2353  }
2354  }
2356  }
2357  return 1;
2358  }
2359  return 0;
2360 }
2361 
2363  const uint8_t *p, int buf_size)
2364 {
2365  Mpeg1Context *s = avctx->priv_data;
2366  const uint8_t *buf_end = p + buf_size;
2367  Mpeg1Context *s1 = avctx->priv_data;
2368 
2369 #if 0
2370  int i;
2371  for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2372  av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2373  }
2374  av_log(avctx, AV_LOG_ERROR, "\n");
2375 #endif
2376 
2377  if (buf_size > 29){
2378  int i;
2379  for(i=0; i<20; i++)
2380  if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2381  s->tmpgexs= 1;
2382  }
2383  }
2384  /* we parse the DTG active format information */
2385  if (buf_end - p >= 5 &&
2386  p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2387  int flags = p[4];
2388  p += 5;
2389  if (flags & 0x80) {
2390  /* skip event id */
2391  p += 2;
2392  }
2393  if (flags & 0x40) {
2394  if (buf_end - p < 1)
2395  return;
2396  s1->has_afd = 1;
2397  s1->afd = p[0] & 0x0f;
2398  }
2399  } else if (buf_end - p >= 6 &&
2400  p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2401  p[4] == 0x03) { // S3D_video_format_length
2402  // the 0x7F mask ignores the reserved_bit value
2403  const uint8_t S3D_video_format_type = p[5] & 0x7F;
2404 
2405  if (S3D_video_format_type == 0x03 ||
2406  S3D_video_format_type == 0x04 ||
2407  S3D_video_format_type == 0x08 ||
2408  S3D_video_format_type == 0x23) {
2409 
2410  s1->has_stereo3d = 1;
2411 
2412  switch (S3D_video_format_type) {
2413  case 0x03:
2415  break;
2416  case 0x04:
2418  break;
2419  case 0x08:
2421  break;
2422  case 0x23:
2424  break;
2425  }
2426  }
2427  } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2428  return;
2429  }
2430 }
2431 
2432 static void mpeg_decode_gop(AVCodecContext *avctx,
2433  const uint8_t *buf, int buf_size)
2434 {
2435  Mpeg1Context *s1 = avctx->priv_data;
2436  MpegEncContext *s = &s1->mpeg_enc_ctx;
2437  int broken_link;
2438  int64_t tc;
2439 
2440  init_get_bits(&s->gb, buf, buf_size * 8);
2441 
2442  tc = s-> timecode_frame_start = get_bits(&s->gb, 25);
2443 
2444 #if FF_API_PRIVATE_OPT
2446  avctx->timecode_frame_start = tc;
2448 #endif
2449 
2450  s->closed_gop = get_bits1(&s->gb);
2451  /* broken_link indicates that after editing the
2452  * reference frames of the first B-Frames after GOP I-Frame
2453  * are missing (open gop) */
2454  broken_link = get_bits1(&s->gb);
2455 
2456  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2457  char tcbuf[AV_TIMECODE_STR_SIZE];
2460  "GOP (%s) closed_gop=%d broken_link=%d\n",
2461  tcbuf, s->closed_gop, broken_link);
2462  }
2463 }
2464 
2465 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2466  int *got_output, const uint8_t *buf, int buf_size)
2467 {
2468  Mpeg1Context *s = avctx->priv_data;
2470  const uint8_t *buf_ptr = buf;
2471  const uint8_t *buf_end = buf + buf_size;
2472  int ret, input_size;
2473  int last_code = 0, skip_frame = 0;
2474  int picture_start_code_seen = 0;
2475 
2476  for (;;) {
2477  /* find next start code */
2478  uint32_t start_code = -1;
2479  buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2480  if (start_code > 0x1ff) {
2481  if (!skip_frame) {
2482  if (HAVE_THREADS &&
2483  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2484  !avctx->hwaccel) {
2485  int i;
2486  av_assert0(avctx->thread_count > 1);
2487 
2488  avctx->execute(avctx, slice_decode_thread,
2489  &s2->thread_context[0], NULL,
2490  s->slice_count, sizeof(void *));
2491  for (i = 0; i < s->slice_count; i++)
2492  s2->er.error_count += s2->thread_context[i]->er.error_count;
2493  }
2494 
2495  ret = slice_end(avctx, picture);
2496  if (ret < 0)
2497  return ret;
2498  else if (ret) {
2499  // FIXME: merge with the stuff in mpeg_decode_slice
2500  if (s2->last_picture_ptr || s2->low_delay)
2501  *got_output = 1;
2502  }
2503  }
2504  s2->pict_type = 0;
2505 
2506  if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2507  return AVERROR_INVALIDDATA;
2508 
2509  return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2510  }
2511 
2512  input_size = buf_end - buf_ptr;
2513 
2514  if (avctx->debug & FF_DEBUG_STARTCODE)
2515  av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2516  start_code, buf_ptr - buf, input_size);
2517 
2518  /* prepare data for next start code */
2519  switch (start_code) {
2520  case SEQ_START_CODE:
2521  if (last_code == 0) {
2522  mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2523  if (buf != avctx->extradata)
2524  s->sync = 1;
2525  } else {
2526  av_log(avctx, AV_LOG_ERROR,
2527  "ignoring SEQ_START_CODE after %X\n", last_code);
2528  if (avctx->err_recognition & AV_EF_EXPLODE)
2529  return AVERROR_INVALIDDATA;
2530  }
2531  break;
2532 
2533  case PICTURE_START_CODE:
2534  if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2535  /* If it's a frame picture, there can't be more than one picture header.
2536  Yet, it does happen and we need to handle it. */
2537  av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2538  break;
2539  }
2540  picture_start_code_seen = 1;
2541 
2542  if (s2->width <= 0 || s2->height <= 0) {
2543  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2544  s2->width, s2->height);
2545  return AVERROR_INVALIDDATA;
2546  }
2547 
2548  if (s->tmpgexs){
2549  s2->intra_dc_precision= 3;
2550  s2->intra_matrix[0]= 1;
2551  }
2552  if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2553  !avctx->hwaccel && s->slice_count) {
2554  int i;
2555 
2556  avctx->execute(avctx, slice_decode_thread,
2557  s2->thread_context, NULL,
2558  s->slice_count, sizeof(void *));
2559  for (i = 0; i < s->slice_count; i++)
2560  s2->er.error_count += s2->thread_context[i]->er.error_count;
2561  s->slice_count = 0;
2562  }
2563  if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2564  ret = mpeg_decode_postinit(avctx);
2565  if (ret < 0) {
2566  av_log(avctx, AV_LOG_ERROR,
2567  "mpeg_decode_postinit() failure\n");
2568  return ret;
2569  }
2570 
2571  /* We have a complete image: we try to decompress it. */
2572  if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2573  s2->pict_type = 0;
2574  s->first_slice = 1;
2575  last_code = PICTURE_START_CODE;
2576  } else {
2577  av_log(avctx, AV_LOG_ERROR,
2578  "ignoring pic after %X\n", last_code);
2579  if (avctx->err_recognition & AV_EF_EXPLODE)
2580  return AVERROR_INVALIDDATA;
2581  }
2582  break;
2583  case EXT_START_CODE:
2584  init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2585 
2586  switch (get_bits(&s2->gb, 4)) {
2587  case 0x1:
2588  if (last_code == 0) {
2590  } else {
2591  av_log(avctx, AV_LOG_ERROR,
2592  "ignoring seq ext after %X\n", last_code);
2593  if (avctx->err_recognition & AV_EF_EXPLODE)
2594  return AVERROR_INVALIDDATA;
2595  }
2596  break;
2597  case 0x2:
2599  break;
2600  case 0x3:
2602  break;
2603  case 0x7:
2605  break;
2606  case 0x8:
2607  if (last_code == PICTURE_START_CODE) {
2609  } else {
2610  av_log(avctx, AV_LOG_ERROR,
2611  "ignoring pic cod ext after %X\n", last_code);
2612  if (avctx->err_recognition & AV_EF_EXPLODE)
2613  return AVERROR_INVALIDDATA;
2614  }
2615  break;
2616  }
2617  break;
2618  case USER_START_CODE:
2619  mpeg_decode_user_data(avctx, buf_ptr, input_size);
2620  break;
2621  case GOP_START_CODE:
2622  if (last_code == 0) {
2623  s2->first_field = 0;
2624  mpeg_decode_gop(avctx, buf_ptr, input_size);
2625  s->sync = 1;
2626  } else {
2627  av_log(avctx, AV_LOG_ERROR,
2628  "ignoring GOP_START_CODE after %X\n", last_code);
2629  if (avctx->err_recognition & AV_EF_EXPLODE)
2630  return AVERROR_INVALIDDATA;
2631  }
2632  break;
2633  default:
2634  if (start_code >= SLICE_MIN_START_CODE &&
2635  start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2636  if (s2->progressive_sequence && !s2->progressive_frame) {
2637  s2->progressive_frame = 1;
2638  av_log(s2->avctx, AV_LOG_ERROR,
2639  "interlaced frame in progressive sequence, ignoring\n");
2640  }
2641 
2642  if (s2->picture_structure == 0 ||
2644  av_log(s2->avctx, AV_LOG_ERROR,
2645  "picture_structure %d invalid, ignoring\n",
2646  s2->picture_structure);
2648  }
2649 
2651  av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2652 
2653  if (s2->picture_structure == PICT_FRAME) {
2654  s2->first_field = 0;
2655  s2->v_edge_pos = 16 * s2->mb_height;
2656  } else {
2657  s2->first_field ^= 1;
2658  s2->v_edge_pos = 8 * s2->mb_height;
2659  memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2660  }
2661  }
2662  if (start_code >= SLICE_MIN_START_CODE &&
2663  start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2664  const int field_pic = s2->picture_structure != PICT_FRAME;
2665  int mb_y = start_code - SLICE_MIN_START_CODE;
2666  last_code = SLICE_MIN_START_CODE;
2667  if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2668  mb_y += (*buf_ptr&0xE0)<<2;
2669 
2670  mb_y <<= field_pic;
2672  mb_y++;
2673 
2674  if (buf_end - buf_ptr < 2) {
2675  av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2676  return AVERROR_INVALIDDATA;
2677  }
2678 
2679  if (mb_y >= s2->mb_height) {
2680  av_log(s2->avctx, AV_LOG_ERROR,
2681  "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2682  return AVERROR_INVALIDDATA;
2683  }
2684 
2685  if (!s2->last_picture_ptr) {
2686  /* Skip B-frames if we do not have reference frames and
2687  * GOP is not closed. */
2688  if (s2->pict_type == AV_PICTURE_TYPE_B) {
2689  if (!s2->closed_gop) {
2690  skip_frame = 1;
2691  av_log(s2->avctx, AV_LOG_DEBUG,
2692  "Skipping B slice due to open GOP\n");
2693  break;
2694  }
2695  }
2696  }
2698  s->sync = 1;
2699  if (!s2->next_picture_ptr) {
2700  /* Skip P-frames if we do not have a reference frame or
2701  * we have an invalid header. */
2702  if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2703  skip_frame = 1;
2704  av_log(s2->avctx, AV_LOG_DEBUG,
2705  "Skipping P slice due to !sync\n");
2706  break;
2707  }
2708  }
2709  if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2710  s2->pict_type == AV_PICTURE_TYPE_B) ||
2711  (avctx->skip_frame >= AVDISCARD_NONKEY &&
2712  s2->pict_type != AV_PICTURE_TYPE_I) ||
2713  avctx->skip_frame >= AVDISCARD_ALL) {
2714  skip_frame = 1;
2715  break;
2716  }
2717 
2718  if (!s->mpeg_enc_ctx_allocated)
2719  break;
2720 
2721  if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2722  if (mb_y < avctx->skip_top ||
2723  mb_y >= s2->mb_height - avctx->skip_bottom)
2724  break;
2725  }
2726 
2727  if (!s2->pict_type) {
2728  av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2729  if (avctx->err_recognition & AV_EF_EXPLODE)
2730  return AVERROR_INVALIDDATA;
2731  break;
2732  }
2733 
2734  if (s->first_slice) {
2735  skip_frame = 0;
2736  s->first_slice = 0;
2737  if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2738  return ret;
2739  }
2740  if (!s2->current_picture_ptr) {
2741  av_log(avctx, AV_LOG_ERROR,
2742  "current_picture not initialized\n");
2743  return AVERROR_INVALIDDATA;
2744  }
2745 
2746  if (HAVE_THREADS &&
2747  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2748  !avctx->hwaccel) {
2749  int threshold = (s2->mb_height * s->slice_count +
2750  s2->slice_context_count / 2) /
2751  s2->slice_context_count;
2752  av_assert0(avctx->thread_count > 1);
2753  if (threshold <= mb_y) {
2754  MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2755 
2756  thread_context->start_mb_y = mb_y;
2757  thread_context->end_mb_y = s2->mb_height;
2758  if (s->slice_count) {
2759  s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2760  ret = ff_update_duplicate_context(thread_context, s2);
2761  if (ret < 0)
2762  return ret;
2763  }
2764  init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2765  s->slice_count++;
2766  }
2767  buf_ptr += 2; // FIXME add minimum number of bytes per slice
2768  } else {
2769  ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2770  emms_c();
2771 
2772  if (ret < 0) {
2773  if (avctx->err_recognition & AV_EF_EXPLODE)
2774  return ret;
2775  if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2776  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2777  s2->resync_mb_y, s2->mb_x, s2->mb_y,
2779  } else {
2780  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2781  s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2783  }
2784  }
2785  }
2786  break;
2787  }
2788  }
2789 }
2790 
2791 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2792  int *got_output, AVPacket *avpkt)
2793 {
2794  const uint8_t *buf = avpkt->data;
2795  int ret;
2796  int buf_size = avpkt->size;
2797  Mpeg1Context *s = avctx->priv_data;
2798  AVFrame *picture = data;
2800 
2801  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2802  /* special case for last picture */
2803  if (s2->low_delay == 0 && s2->next_picture_ptr) {
2804  int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2805  if (ret < 0)
2806  return ret;
2807 
2808  s2->next_picture_ptr = NULL;
2809 
2810  *got_output = 1;
2811  }
2812  return buf_size;
2813  }
2814 
2815  if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2816  int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2817  buf_size, NULL);
2818 
2819  if (ff_combine_frame(&s2->parse_context, next,
2820  (const uint8_t **) &buf, &buf_size) < 0)
2821  return buf_size;
2822  }
2823 
2824  s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2825  if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2826  || s2->codec_tag == AV_RL32("BW10")
2827  ))
2828  vcr2_init_sequence(avctx);
2829 
2830  s->slice_count = 0;
2831 
2832  if (avctx->extradata && !s->extradata_decoded) {
2833  ret = decode_chunks(avctx, picture, got_output,
2834  avctx->extradata, avctx->extradata_size);
2835  if (*got_output) {
2836  av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2837  av_frame_unref(picture);
2838  *got_output = 0;
2839  }
2840  s->extradata_decoded = 1;
2841  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2842  s2->current_picture_ptr = NULL;
2843  return ret;
2844  }
2845  }
2846 
2847  ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2848  if (ret<0 || *got_output) {
2849  s2->current_picture_ptr = NULL;
2850 
2851  if (s2->timecode_frame_start != -1 && *got_output) {
2852  AVFrameSideData *tcside = av_frame_new_side_data(picture,
2854  sizeof(int64_t));
2855  if (!tcside)
2856  return AVERROR(ENOMEM);
2857  memcpy(tcside->data, &s2->timecode_frame_start, sizeof(int64_t));
2858 
2859  s2->timecode_frame_start = -1;
2860  }
2861  }
2862 
2863  return ret;
2864 }
2865 
2866 static void flush(AVCodecContext *avctx)
2867 {
2868  Mpeg1Context *s = avctx->priv_data;
2869 
2870  s->sync = 0;
2871 
2872  ff_mpeg_flush(avctx);
2873 }
2874 
2876 {
2877  Mpeg1Context *s = avctx->priv_data;
2878 
2879  if (s->mpeg_enc_ctx_allocated)
2881  av_freep(&s->a53_caption);
2882  return 0;
2883 }
2884 
2886  .name = "mpeg1video",
2887  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2888  .type = AVMEDIA_TYPE_VIDEO,
2889  .id = AV_CODEC_ID_MPEG1VIDEO,
2890  .priv_data_size = sizeof(Mpeg1Context),
2892  .close = mpeg_decode_end,
2897  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2898  .flush = flush,
2899  .max_lowres = 3,
2900  .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context),
2901  .hw_configs = (const AVCodecHWConfigInternal*[]) {
2902 #if CONFIG_MPEG1_NVDEC_HWACCEL
2903  HWACCEL_NVDEC(mpeg1),
2904 #endif
2905 #if CONFIG_MPEG1_VDPAU_HWACCEL
2906  HWACCEL_VDPAU(mpeg1),
2907 #endif
2908 #if CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL
2909  HWACCEL_VIDEOTOOLBOX(mpeg1),
2910 #endif
2911 #if CONFIG_MPEG1_XVMC_HWACCEL
2912  HWACCEL_XVMC(mpeg1),
2913 #endif
2914  NULL
2915  },
2916 };
2917 
2919  .name = "mpeg2video",
2920  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2921  .type = AVMEDIA_TYPE_VIDEO,
2922  .id = AV_CODEC_ID_MPEG2VIDEO,
2923  .priv_data_size = sizeof(Mpeg1Context),
2925  .close = mpeg_decode_end,
2930  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2931  .flush = flush,
2932  .max_lowres = 3,
2934  .hw_configs = (const AVCodecHWConfigInternal*[]) {
2935 #if CONFIG_MPEG2_DXVA2_HWACCEL
2936  HWACCEL_DXVA2(mpeg2),
2937 #endif
2938 #if CONFIG_MPEG2_D3D11VA_HWACCEL
2939  HWACCEL_D3D11VA(mpeg2),
2940 #endif
2941 #if CONFIG_MPEG2_D3D11VA2_HWACCEL
2942  HWACCEL_D3D11VA2(mpeg2),
2943 #endif
2944 #if CONFIG_MPEG2_NVDEC_HWACCEL
2945  HWACCEL_NVDEC(mpeg2),
2946 #endif
2947 #if CONFIG_MPEG2_VAAPI_HWACCEL
2948  HWACCEL_VAAPI(mpeg2),
2949 #endif
2950 #if CONFIG_MPEG2_VDPAU_HWACCEL
2951  HWACCEL_VDPAU(mpeg2),
2952 #endif
2953 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
2954  HWACCEL_VIDEOTOOLBOX(mpeg2),
2955 #endif
2956 #if CONFIG_MPEG2_XVMC_HWACCEL
2957  HWACCEL_XVMC(mpeg2),
2958 #endif
2959  NULL
2960  },
2961 };
2962 
2963 //legacy decoder
2965  .name = "mpegvideo",
2966  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2967  .type = AVMEDIA_TYPE_VIDEO,
2968  .id = AV_CODEC_ID_MPEG2VIDEO,
2969  .priv_data_size = sizeof(Mpeg1Context),
2971  .close = mpeg_decode_end,
2974  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2975  .flush = flush,
2976  .max_lowres = 3,
2977 };
static const uint32_t btype2mb_type[11]
Definition: mpeg12dec.c:87
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
Definition: mpeg12data.c:41
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:2766
#define ff_tlog(ctx,...)
Definition: internal.h:81
IDCTDSPContext idsp
Definition: mpegvideo.h:230
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:1630
AVRational framerate
Definition: avcodec.h:3161
const char const char void * val
Definition: avisynth_c.h:863
discard all frames except keyframes
Definition: avcodec.h:828
int8_t * ref_index[2]
Definition: mpegpicture.h:62
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2270
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
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
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:556
#define MAX_INDEX
Definition: mpeg12dec.c:128
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
int rc_buffer_size
Definition: mpeg12dec.c:67
static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm, const uint8_t *new_perm)
Definition: mpeg12dec.c:1112
#define HWACCEL_D3D11VA2(codec)
Definition: hwaccel.h:69
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
#define HWACCEL_NVDEC(codec)
Definition: hwaccel.h:71
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:1809
float re
Definition: fft.c:82
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1447
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:182
av_cold void ff_mpeg12_init_vlcs(void)
Definition: mpeg12.c:137
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1671
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:104
uint8_t afd
Definition: mpeg12dec.c:62
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
uint8_t * a53_caption
Definition: mpeg12dec.c:60
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:1164
const uint8_t ff_reverse[256]
Definition: reverse.c:23
int height
Definition: avcodec.h:1143
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)
Note: this function can read out of range and crash for corrupt streams.
Definition: mpeg12dec.c:404
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2256
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:437
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:117
int size
Definition: avcodec.h:1534
enum AVCodecID codec_id
Definition: mpegvideo.h:112
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:2765
static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1542
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:2000
#define MB_TYPE_INTRA
Definition: mpegutils.h:73
AVCodec ff_mpeg1video_decoder
Definition: mpeg12dec.c:2885
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:130
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1831
#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:1056
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: avcodec.h:2759
mpegvideo header.
#define HAS_CBP(a)
Definition: mpegutils.h:101
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
discard all
Definition: avcodec.h:829
uint8_t permutated[64]
Definition: idctdsp.h:33
Views are next to each other.
Definition: stereo3d.h:67
uint8_t run
Definition: svq3.c:208
#define AV_CODEC_FLAG2_CHUNKS
Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries...
Definition: avcodec.h:960
#define HWACCEL_D3D11VA(codec)
Definition: hwaccel.h:79
#define ER_MV_ERROR
static void mpeg_decode_gop(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2432
#define SLICE_MIN_START_CODE
Definition: mpegvideo.h:71
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2785
int profile
profile
Definition: avcodec.h:2954
AVCodec.
Definition: avcodec.h:3555
static int get_dmv(MpegEncContext *s)
Definition: mpeg12dec.c:645
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:3096
#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: avcodec.h:1024
#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:2263
#define MBINCR_VLC_BITS
Definition: mpeg12vlc.h:37
static const uint32_t ptype2mb_type[7]
Definition: mpeg12dec.c:77
The exact code depends on how similar the blocks are and how related they are to the block
#define SLICE_MAX_START_CODE
Definition: avs2_parser.c:24
uint8_t
#define av_cold
Definition: attributes.h:82
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.If the codec allocates writable tables in its init()
#define av_malloc(s)
#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:2707
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
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:918
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:444
static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1[64], int intra)
Definition: mpeg12dec.c:1505
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1722
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:1175
static int mpeg1_fast_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
Note: this function can read out of range and crash for corrupt streams.
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:87
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:180
int first_slice
Definition: mpeg12dec.c:71
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:201
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:287
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
#define height
uint8_t * data
Definition: avcodec.h:1533
#define HWACCEL_DXVA2(codec)
Definition: hwaccel.h:67
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,...)
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:2860
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:1191
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:901
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:2263
#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:2825
#define MB_TYPE_QUANT
Definition: mpegutils.h:70
static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
Definition: mpeg12dec.c:1196
Libavcodec version macros.
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
enum AVCodecID id
Definition: avcodec.h:3569
int slice_context_count
number of used thread_contexts
Definition: mpegvideo.h:156
int extradata_decoded
Definition: mpeg12dec.c:72
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define FF_IDCT_NONE
Definition: avcodec.h:2837
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1911
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:654
#define PTRDIFF_SPECIFIER
Definition: internal.h:261
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:1397
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:186
ERContext er
Definition: mpegvideo.h:566
static int mpeg1_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:138
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2899
AVCodec ff_mpegvideo_decoder
Definition: mpeg12dec.c:2964
#define MB_TYPE_CBP
Definition: mpegutils.h:71
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
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:1701
#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: avcodec.h:3562
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
Definition: mpeg12dec.c:102
int width
width and height in 1/16 pel
Definition: avcodec.h:1142
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:406
static void mpeg_decode_user_data(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition: mpeg12dec.c:2362
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:1129
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:56
attribute_deprecated int64_t timecode_frame_start
Definition: avcodec.h:2583
#define DECODE_SLICE_ERROR
Definition: mpeg12dec.c:1704
#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:1705
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:2303
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:225
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:1601
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: avcodec.h:993
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:1442
int progressive_frame
Definition: mpegvideo.h:489
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#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:2750
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2891
#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:2183
#define width
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:2824
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:2237
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:558
int alternate_scan
Definition: mpegvideo.h:471
int save_height
Definition: mpeg12dec.c:66
#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:2235
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
int a53_caption_size
Definition: mpeg12dec.c:61
#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:2892
int level
level
Definition: avcodec.h:3074
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
static av_cold int mpeg_decode_end(AVCodecContext *avctx)
Definition: mpeg12dec.c:2875
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:1528
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:2761
int n
Definition: avisynth_c.h:760
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:1753
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:55
#define check_scantable_index(ctx, x)
Definition: mpeg12dec.c:129
#define MB_TYPE_INTERLACED
Definition: mpegutils.h:58
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: avcodec.h:222
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
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:2880
static int mpeg1_decode_sequence(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2094
if(ret)
static const float pred[4]
Definition: siprdata.h:259
AVRational save_aspect
Definition: mpeg12dec.c:65
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: avcodec.h:1059
int save_width
Definition: mpeg12dec.c:66
#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
This structure describes the bitrate properties of an encoded bitstream.
Definition: avcodec.h:1158
static int mpeg2_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:476
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:1138
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:3829
AVRational frame_rate_ext
Definition: mpeg12dec.c:68
enum AVCodecID codec_id
Definition: avcodec.h:1631
BlockDSPContext bdsp
Definition: mpegvideo.h:226
static int mpeg2_fast_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
Note: this function can read out of range and crash for corrupt streams.
Definition: mpeg12dec.c:566
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
#define AV_CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
Definition: avcodec.h:941
int debug
debug
Definition: avcodec.h:2706
#define MB_PTYPE_VLC_BITS
Definition: mpeg12vlc.h:39
main external API structure.
Definition: avcodec.h:1621
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
#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:1646
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
uint8_t * data
Definition: frame.h:203
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
void * buf
Definition: avisynth_c.h:766
static int mpeg_decode_slice(MpegEncContext *s, int mb_y, const uint8_t **buf, int buf_size)
Decode a slice.
Definition: mpeg12dec.c:1713
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1435
int extradata_size
Definition: avcodec.h:1723
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:1809
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:3285
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:727
int closed_gop
MPEG1/2 GOP is closed.
Definition: mpegvideo.h:211
int has_stereo3d
Definition: mpeg12dec.c:59
VLC ff_mb_ptype_vlc
Definition: mpeg12.c:133
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1819
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2249
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2242
struct AVFrame * f
Definition: mpegpicture.h:46
#define HWACCEL_XVMC(codec)
Definition: hwaccel.h:81
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:197
static enum AVPixelFormat mpeg12_pixfmt_list_422[]
Definition: mpeg12dec.c:1165
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
#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:66
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
#define MT_DMV
Definition: mpeg12dec.c:657
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:1203
#define ER_DC_ERROR
#define MB_TYPE_SKIP
Definition: mpegutils.h: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:2791
#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:2465
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:275
av_cold void ff_mpeg12_common_init(MpegEncContext *s)
Definition: mpeg12.c:107
#define AV_CODEC_CAP_TRUNCATED
Definition: avcodec.h:1000
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
#define HWACCEL_VAAPI(codec)
Definition: hwaccel.h:73
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
int skip_bottom
Number of macroblock rows at the bottom which are skipped.
Definition: avcodec.h:2161
#define flags(name, subs,...)
Definition: cbs_av1.c:564
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:3818
Pan Scan area.
Definition: avcodec.h:1129
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t level
Definition: svq3.c:209
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:88
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
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:534
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:3790
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
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:825
const AVRational ff_mpeg2_aspect[16]
Definition: mpeg12data.c:395
static enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[]
Definition: mpeg12dec.c:1124
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:2918
#define TEX_VLC_BITS
Definition: dv.h:99
static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpeg12dec.c:659
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:2866
VLC ff_mbincr_vlc
Definition: mpeg12.c:132
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:1350
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:3283
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:1979
AVStereo3D stereo3d
Definition: mpeg12dec.c:58
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:2043
int16_t position[3][2]
position of the top left corner in 1/16 pel for up to 3 fields/frames
Definition: avcodec.h:1150
void * priv_data
Definition: avcodec.h:1648
#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:890
static int mpeg_decode_postinit(AVCodecContext *avctx)
Definition: mpeg12dec.c:1213
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:2720
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1427
#define MT_FRAME
Definition: mpeg12dec.c:655
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition: mpegvideo.h:270
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2251
#define SEQ_START_CODE
Definition: mpegvideo.h:68
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:373
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1708
MpegEncContext mpeg_enc_ctx
Definition: mpeg12dec.c:54
int slice_count
Definition: mpeg12dec.c:64
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:75
#define AV_CODEC_FLAG_TRUNCATED
Input bitstream might be truncated at a random location instead of only at frame boundaries.
Definition: avcodec.h:910
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition: avcodec.h:969
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
#define av_freep(p)
#define HWACCEL_VDPAU(codec)
Definition: hwaccel.h:75
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:557
#define ER_AC_END
static int mpeg_get_qscale(MpegEncContext *s)
Definition: mpegvideo.h:764
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:1990
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:2920
static enum AVPixelFormat mpeg12_pixfmt_list_444[]
Definition: mpeg12dec.c:1170
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1510
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo.c:2348
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:999
#define MB_TYPE_L0
Definition: mpegutils.h:67
static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1471
Predicted.
Definition: avutil.h:275
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2499
const AVRational ff_mpeg12_frame_rate_tab[]
AVPanScan pan_scan
Definition: mpeg12dec.c:57
VLC ff_mb_btype_vlc
Definition: mpeg12.c:134