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