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