FFmpeg
mpeg12dec.c
Go to the documentation of this file.
1 /*
2  * MPEG-1/2 decoder
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2002-2013 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * MPEG-1/2 decoder
26  */
27 
28 #define UNCHECKED_BITSTREAM_READER 1
29 #include <inttypes.h>
30 
31 #include "libavutil/attributes.h"
32 #include "libavutil/imgutils.h"
33 #include "libavutil/internal.h"
34 #include "libavutil/stereo3d.h"
35 
36 #include "avcodec.h"
37 #include "bytestream.h"
38 #include "error_resilience.h"
39 #include "hwaccel.h"
40 #include "idctdsp.h"
41 #include "internal.h"
42 #include "mpeg_er.h"
43 #include "mpeg12.h"
44 #include "mpeg12data.h"
45 #include "mpegutils.h"
46 #include "mpegvideo.h"
47 #include "mpegvideodata.h"
48 #include "profiles.h"
49 #include "thread.h"
50 #include "version.h"
51 #include "xvmc_internal.h"
52 
53 typedef struct Mpeg1Context {
54  MpegEncContext mpeg_enc_ctx;
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 */
58  AVStereo3D stereo3d;
59  int has_stereo3d;
60  uint8_t *a53_caption;
61  int a53_caption_size;
62  uint8_t afd;
63  int has_afd;
64  int slice_count;
65  AVRational save_aspect;
66  int save_width, save_height, save_progressive_seq;
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;
70  int first_slice;
71  int extradata_decoded;
72 } Mpeg1Context;
73 
74 #define MB_TYPE_ZERO_MV 0x20000000
75 
76 static const uint32_t ptype2mb_type[7] = {
77  MB_TYPE_INTRA,
78  MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
79  MB_TYPE_L0,
80  MB_TYPE_L0 | MB_TYPE_CBP,
81  MB_TYPE_QUANT | MB_TYPE_INTRA,
82  MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
83  MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
84 };
85 
86 static const uint32_t btype2mb_type[11] = {
87  MB_TYPE_INTRA,
88  MB_TYPE_L1,
89  MB_TYPE_L1 | MB_TYPE_CBP,
90  MB_TYPE_L0,
91  MB_TYPE_L0 | MB_TYPE_CBP,
92  MB_TYPE_L0L1,
93  MB_TYPE_L0L1 | MB_TYPE_CBP,
94  MB_TYPE_QUANT | MB_TYPE_INTRA,
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 
137 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
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  */
226 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s,
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 
311 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
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  */
401 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
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 
473 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
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  */
562 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
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] =
669  MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
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) {
697  av_log(s->avctx, AV_LOG_ERROR,
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) {
710  av_log(s->avctx, AV_LOG_ERROR,
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) {
719  av_log(s->avctx, AV_LOG_ERROR,
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 &&
737  !s->frame_pred_frame_dct)
738  s->interlaced_dct = get_bits1(&s->gb);
739 
740  if (IS_QUANT(mb_type))
741  s->qscale = mpeg_get_qscale(s);
742 
743  if (s->concealment_motion_vectors) {
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++)
770  mpeg2_fast_decode_block_intra(s, *s->pblocks[i], 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++) {
778  ret = ff_mpeg1_decode_block_intra(&s->gb,
779  s->intra_matrix,
780  s->intra_scantable.permutated,
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 */
821  if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) {
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 {
901  av_assert0(!s->progressive_sequence);
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;
963  if (s->picture_structure == PICT_TOP_FIELD)
964  s->mv[i][2][1]--;
965  else
966  s->mv[i][2][1]++;
967  }
968  }
969  }
970  break;
971  default:
972  av_log(s->avctx, AV_LOG_ERROR,
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 
982  cbp = get_vlc2(&s->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
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) {
989  av_log(s->avctx, AV_LOG_ERROR,
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)
1002  mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i);
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 
1052 static av_cold int mpeg_decode_init(AVCodecContext *avctx)
1053 {
1054  Mpeg1Context *s = avctx->priv_data;
1055  MpegEncContext *s2 = &s->mpeg_enc_ctx;
1056 
1057  ff_mpv_decode_defaults(s2);
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);
1069  ff_mpeg12_common_init(&s->mpeg_enc_ctx);
1070  ff_mpeg12_init_vlcs();
1071 
1072  s2->chroma_format = 1;
1073  s->mpeg_enc_ctx_allocated = 0;
1074  s->mpeg_enc_ctx.picture_number = 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 
1120 static const enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[] = {
1121 #if CONFIG_MPEG1_NVDEC_HWACCEL
1122  AV_PIX_FMT_CUDA,
1123 #endif
1124 #if CONFIG_MPEG1_XVMC_HWACCEL
1125  AV_PIX_FMT_XVMC,
1126 #endif
1127 #if CONFIG_MPEG1_VDPAU_HWACCEL
1128  AV_PIX_FMT_VDPAU,
1129 #endif
1130  AV_PIX_FMT_YUV420P,
1131  AV_PIX_FMT_NONE
1132 };
1133 
1134 static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = {
1135 #if CONFIG_MPEG2_NVDEC_HWACCEL
1136  AV_PIX_FMT_CUDA,
1137 #endif
1138 #if CONFIG_MPEG2_XVMC_HWACCEL
1139  AV_PIX_FMT_XVMC,
1140 #endif
1141 #if CONFIG_MPEG2_VDPAU_HWACCEL
1142  AV_PIX_FMT_VDPAU,
1143 #endif
1144 #if CONFIG_MPEG2_DXVA2_HWACCEL
1145  AV_PIX_FMT_DXVA2_VLD,
1146 #endif
1147 #if CONFIG_MPEG2_D3D11VA_HWACCEL
1148  AV_PIX_FMT_D3D11VA_VLD,
1149  AV_PIX_FMT_D3D11,
1150 #endif
1151 #if CONFIG_MPEG2_VAAPI_HWACCEL
1152  AV_PIX_FMT_VAAPI,
1153 #endif
1154 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
1155  AV_PIX_FMT_VIDEOTOOLBOX,
1156 #endif
1157  AV_PIX_FMT_YUV420P,
1158  AV_PIX_FMT_NONE
1159 };
1160 
1161 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
1162  AV_PIX_FMT_YUV422P,
1163  AV_PIX_FMT_NONE
1164 };
1165 
1166 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
1167  AV_PIX_FMT_YUV444P,
1168  AV_PIX_FMT_NONE
1169 };
1170 
1171 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
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 ?
1182  mpeg1_hwaccel_pixfmt_list_420 :
1183  mpeg2_hwaccel_pixfmt_list_420;
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 
1192 static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
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. */
1209 static int mpeg_decode_postinit(AVCodecContext *avctx)
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 =
1224  av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
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 }))) {
1236  s->avctx->sample_aspect_ratio =
1237  av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1238  (AVRational) { s->width, s->height });
1239  } else {
1240  s->avctx->sample_aspect_ratio =
1241  av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
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",
1248  ff_mpeg2_aspect[s->aspect_ratio_info].num,
1249  ff_mpeg2_aspect[s->aspect_ratio_info].den);
1250  ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1251  s->avctx->sample_aspect_ratio.den);
1252  }
1253  } else {
1254  s->avctx->sample_aspect_ratio =
1255  ff_mpeg2_aspect[s->aspect_ratio_info];
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 ||
1272  av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
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  }
1293  s1->save_aspect = s->avctx->sample_aspect_ratio;
1294  s1->save_width = s->width;
1295  s1->save_height = s->height;
1296  s1->save_progressive_seq = s->progressive_sequence;
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
1304  avctx->framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
1305  avctx->ticks_per_frame = 1;
1306 
1307  avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1308  } else { // MPEG-2
1309  // MPEG-2 fps
1310  av_reduce(&s->avctx->framerate.num,
1311  &s->avctx->framerate.den,
1312  ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1313  ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.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);
1338  quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
1339  quant_matrix_rebuild(s->chroma_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  }
1381  s->current_picture.f->pict_type = s->pict_type;
1382  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
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 
1393 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1394 {
1395  MpegEncContext *s = &s1->mpeg_enc_ctx;
1396  int horiz_size_ext, vert_size_ext;
1397  int bit_rate_ext;
1398 
1399  skip_bits(&s->gb, 1); /* profile and level esc*/
1400  s->avctx->profile = get_bits(&s->gb, 3);
1401  s->avctx->level = get_bits(&s->gb, 4);
1402  s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1403  s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1404 
1405  if (!s->chroma_format) {
1406  s->chroma_format = 1;
1407  av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1408  }
1409 
1410  horiz_size_ext = get_bits(&s->gb, 2);
1411  vert_size_ext = get_bits(&s->gb, 2);
1412  s->width |= (horiz_size_ext << 12);
1413  s->height |= (vert_size_ext << 12);
1414  bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1415  s->bit_rate += (bit_rate_ext << 18) * 400LL;
1416  check_marker(s->avctx, &s->gb, "after bit rate extension");
1417  s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1418 
1419  s->low_delay = get_bits1(&s->gb);
1420  if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1421  s->low_delay = 1;
1422 
1423  s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1424  s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1425 
1426  ff_dlog(s->avctx, "sequence extension\n");
1427  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1428 
1429  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1430  av_log(s->avctx, AV_LOG_DEBUG,
1431  "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n",
1432  s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1433  s->avctx->rc_buffer_size, s->bit_rate);
1434 }
1435 
1436 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1437 {
1438  MpegEncContext *s = &s1->mpeg_enc_ctx;
1439  int color_description, w, h;
1440 
1441  skip_bits(&s->gb, 3); /* video format */
1442  color_description = get_bits1(&s->gb);
1443  if (color_description) {
1444  s->avctx->color_primaries = get_bits(&s->gb, 8);
1445  s->avctx->color_trc = get_bits(&s->gb, 8);
1446  s->avctx->colorspace = get_bits(&s->gb, 8);
1447  }
1448  w = get_bits(&s->gb, 14);
1449  skip_bits(&s->gb, 1); // marker
1450  h = get_bits(&s->gb, 14);
1451  // remaining 3 bits are zero padding
1452 
1453  s1->pan_scan.width = 16 * w;
1454  s1->pan_scan.height = 16 * h;
1455 
1456  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1457  av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1458 }
1459 
1460 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1461 {
1462  MpegEncContext *s = &s1->mpeg_enc_ctx;
1463  int i, nofco;
1464 
1465  nofco = 1;
1466  if (s->progressive_sequence) {
1467  if (s->repeat_first_field) {
1468  nofco++;
1469  if (s->top_field_first)
1470  nofco++;
1471  }
1472  } else {
1473  if (s->picture_structure == PICT_FRAME) {
1474  nofco++;
1475  if (s->repeat_first_field)
1476  nofco++;
1477  }
1478  }
1479  for (i = 0; i < nofco; i++) {
1480  s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1481  skip_bits(&s->gb, 1); // marker
1482  s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1483  skip_bits(&s->gb, 1); // marker
1484  }
1485 
1486  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1487  av_log(s->avctx, AV_LOG_DEBUG,
1488  "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1489  s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1490  s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1491  s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1492 }
1493 
1494 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1495  uint16_t matrix1[64], int intra)
1496 {
1497  int i;
1498 
1499  for (i = 0; i < 64; i++) {
1500  int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1501  int v = get_bits(&s->gb, 8);
1502  if (v == 0) {
1503  av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1504  return AVERROR_INVALIDDATA;
1505  }
1506  if (intra && i == 0 && v != 8) {
1507  av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1508  v = 8; // needed by pink.mpg / issue1046
1509  }
1510  matrix0[j] = v;
1511  if (matrix1)
1512  matrix1[j] = v;
1513  }
1514  return 0;
1515 }
1516 
1517 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1518 {
1519  ff_dlog(s->avctx, "matrix extension\n");
1520 
1521  if (get_bits1(&s->gb))
1522  load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1523  if (get_bits1(&s->gb))
1524  load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1525  if (get_bits1(&s->gb))
1526  load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1527  if (get_bits1(&s->gb))
1528  load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1529 }
1530 
1531 static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1532 {
1533  MpegEncContext *s = &s1->mpeg_enc_ctx;
1534 
1535  s->full_pel[0] = s->full_pel[1] = 0;
1536  s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1537  s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1538  s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1539  s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1540  s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1541  s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1542  s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1543  s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1544  if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1545  av_log(s->avctx, AV_LOG_ERROR,
1546  "Missing picture start code, guessing missing values\n");
1547  if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1548  if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1549  s->pict_type = AV_PICTURE_TYPE_I;
1550  else
1551  s->pict_type = AV_PICTURE_TYPE_P;
1552  } else
1553  s->pict_type = AV_PICTURE_TYPE_B;
1554  s->current_picture.f->pict_type = s->pict_type;
1555  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1556  }
1557 
1558  s->intra_dc_precision = get_bits(&s->gb, 2);
1559  s->picture_structure = get_bits(&s->gb, 2);
1560  s->top_field_first = get_bits1(&s->gb);
1561  s->frame_pred_frame_dct = get_bits1(&s->gb);
1562  s->concealment_motion_vectors = get_bits1(&s->gb);
1563  s->q_scale_type = get_bits1(&s->gb);
1564  s->intra_vlc_format = get_bits1(&s->gb);
1565  s->alternate_scan = get_bits1(&s->gb);
1566  s->repeat_first_field = get_bits1(&s->gb);
1567  s->chroma_420_type = get_bits1(&s->gb);
1568  s->progressive_frame = get_bits1(&s->gb);
1569 
1570  if (s->alternate_scan) {
1571  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1572  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1573  } else {
1574  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1575  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1576  }
1577 
1578  /* composite display not parsed */
1579  ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1580  ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1581  ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1582  ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1583  ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1584  ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1585  ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1586  ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1587  ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1588 }
1589 
1590 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1591 {
1592  AVCodecContext *avctx = s->avctx;
1593  Mpeg1Context *s1 = (Mpeg1Context *) s;
1594  int ret;
1595 
1596  /* start frame decoding */
1597  if (s->first_field || s->picture_structure == PICT_FRAME) {
1598  AVFrameSideData *pan_scan;
1599 
1600  if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1601  return ret;
1602 
1603  ff_mpeg_er_frame_start(s);
1604 
1605  /* first check if we must repeat the frame */
1606  s->current_picture_ptr->f->repeat_pict = 0;
1607  if (s->repeat_first_field) {
1608  if (s->progressive_sequence) {
1609  if (s->top_field_first)
1610  s->current_picture_ptr->f->repeat_pict = 4;
1611  else
1612  s->current_picture_ptr->f->repeat_pict = 2;
1613  } else if (s->progressive_frame) {
1614  s->current_picture_ptr->f->repeat_pict = 1;
1615  }
1616  }
1617 
1618  pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
1619  AV_FRAME_DATA_PANSCAN,
1620  sizeof(s1->pan_scan));
1621  if (!pan_scan)
1622  return AVERROR(ENOMEM);
1623  memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1624 
1625  if (s1->a53_caption) {
1626  AVFrameSideData *sd = av_frame_new_side_data(
1627  s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1628  s1->a53_caption_size);
1629  if (sd)
1630  memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1631  av_freep(&s1->a53_caption);
1632  }
1633 
1634  if (s1->has_stereo3d) {
1635  AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
1636  if (!stereo)
1637  return AVERROR(ENOMEM);
1638 
1639  *stereo = s1->stereo3d;
1640  s1->has_stereo3d = 0;
1641  }
1642 
1643  if (s1->has_afd) {
1644  AVFrameSideData *sd =
1645  av_frame_new_side_data(s->current_picture_ptr->f,
1646  AV_FRAME_DATA_AFD, 1);
1647  if (!sd)
1648  return AVERROR(ENOMEM);
1649 
1650  *sd->data = s1->afd;
1651  s1->has_afd = 0;
1652  }
1653 
1654  if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1655  ff_thread_finish_setup(avctx);
1656  } else { // second field
1657  int i;
1658 
1659  if (!s->current_picture_ptr) {
1660  av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1661  return AVERROR_INVALIDDATA;
1662  }
1663 
1664  if (s->avctx->hwaccel &&
1665  (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
1666  if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
1667  av_log(avctx, AV_LOG_ERROR,
1668  "hardware accelerator failed to decode first field\n");
1669  return ret;
1670  }
1671  }
1672 
1673  for (i = 0; i < 4; i++) {
1674  s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1675  if (s->picture_structure == PICT_BOTTOM_FIELD)
1676  s->current_picture.f->data[i] +=
1677  s->current_picture_ptr->f->linesize[i];
1678  }
1679  }
1680 
1681  if (avctx->hwaccel) {
1682  if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1683  return ret;
1684  }
1685 
1686  return 0;
1687 }
1688 
1689 #define DECODE_SLICE_ERROR -1
1690 #define DECODE_SLICE_OK 0
1691 
1692 /**
1693  * Decode a slice.
1694  * MpegEncContext.mb_y must be set to the MB row from the startcode.
1695  * @return DECODE_SLICE_ERROR if the slice is damaged,
1696  * DECODE_SLICE_OK if this slice is OK
1697  */
1698 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1699  const uint8_t **buf, int buf_size)
1700 {
1701  AVCodecContext *avctx = s->avctx;
1702  const int lowres = s->avctx->lowres;
1703  const int field_pic = s->picture_structure != PICT_FRAME;
1704  int ret;
1705 
1706  s->resync_mb_x =
1707  s->resync_mb_y = -1;
1708 
1709  av_assert0(mb_y < s->mb_height);
1710 
1711  init_get_bits(&s->gb, *buf, buf_size * 8);
1712  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1713  skip_bits(&s->gb, 3);
1714 
1715  ff_mpeg1_clean_buffers(s);
1716  s->interlaced_dct = 0;
1717 
1718  s->qscale = mpeg_get_qscale(s);
1719 
1720  if (s->qscale == 0) {
1721  av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1722  return AVERROR_INVALIDDATA;
1723  }
1724 
1725  /* extra slice info */
1726  if (skip_1stop_8data_bits(&s->gb) < 0)
1727  return AVERROR_INVALIDDATA;
1728 
1729  s->mb_x = 0;
1730 
1731  if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1732  skip_bits1(&s->gb);
1733  } else {
1734  while (get_bits_left(&s->gb) > 0) {
1735  int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1736  MBINCR_VLC_BITS, 2);
1737  if (code < 0) {
1738  av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1739  return AVERROR_INVALIDDATA;
1740  }
1741  if (code >= 33) {
1742  if (code == 33)
1743  s->mb_x += 33;
1744  /* otherwise, stuffing, nothing to do */
1745  } else {
1746  s->mb_x += code;
1747  break;
1748  }
1749  }
1750  }
1751 
1752  if (s->mb_x >= (unsigned) s->mb_width) {
1753  av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1754  return AVERROR_INVALIDDATA;
1755  }
1756 
1757  if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1758  const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1759  int start_code = -1;
1760  buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1761  if (buf_end < *buf + buf_size)
1762  buf_end -= 4;
1763  s->mb_y = mb_y;
1764  if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1765  return DECODE_SLICE_ERROR;
1766  *buf = buf_end;
1767  return DECODE_SLICE_OK;
1768  }
1769 
1770  s->resync_mb_x = s->mb_x;
1771  s->resync_mb_y = s->mb_y = mb_y;
1772  s->mb_skip_run = 0;
1773  ff_init_block_index(s);
1774 
1775  if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1776  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1777  av_log(s->avctx, AV_LOG_DEBUG,
1778  "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",
1779  s->qscale,
1780  s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1781  s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1782  s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1783  (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1784  (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1785  s->progressive_sequence ? "ps" : "",
1786  s->progressive_frame ? "pf" : "",
1787  s->alternate_scan ? "alt" : "",
1788  s->top_field_first ? "top" : "",
1789  s->intra_dc_precision, s->picture_structure,
1790  s->frame_pred_frame_dct, s->concealment_motion_vectors,
1791  s->q_scale_type, s->intra_vlc_format,
1792  s->repeat_first_field, s->chroma_420_type ? "420" : "");
1793  }
1794  }
1795 
1796  for (;;) {
1797  // If 1, we memcpy blocks in xvmcvideo.
1798  if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1799  ff_xvmc_init_block(s); // set s->block
1800 
1801  if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1802  return ret;
1803 
1804  // Note motion_val is normally NULL unless we want to extract the MVs.
1805  if (s->current_picture.motion_val[0] && !s->encoding) {
1806  const int wrap = s->b8_stride;
1807  int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1808  int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1809  int motion_x, motion_y, dir, i;
1810 
1811  for (i = 0; i < 2; i++) {
1812  for (dir = 0; dir < 2; dir++) {
1813  if (s->mb_intra ||
1814  (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1815  motion_x = motion_y = 0;
1816  } else if (s->mv_type == MV_TYPE_16X16 ||
1817  (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1818  motion_x = s->mv[dir][0][0];
1819  motion_y = s->mv[dir][0][1];
1820  } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1821  motion_x = s->mv[dir][i][0];
1822  motion_y = s->mv[dir][i][1];
1823  }
1824 
1825  s->current_picture.motion_val[dir][xy][0] = motion_x;
1826  s->current_picture.motion_val[dir][xy][1] = motion_y;
1827  s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1828  s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1829  s->current_picture.ref_index [dir][b8_xy] =
1830  s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1831  av_assert2(s->field_select[dir][i] == 0 ||
1832  s->field_select[dir][i] == 1);
1833  }
1834  xy += wrap;
1835  b8_xy += 2;
1836  }
1837  }
1838 
1839  s->dest[0] += 16 >> lowres;
1840  s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1841  s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1842 
1843  ff_mpv_reconstruct_mb(s, s->block);
1844 
1845  if (++s->mb_x >= s->mb_width) {
1846  const int mb_size = 16 >> s->avctx->lowres;
1847  int left;
1848 
1849  ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1850  ff_mpv_report_decode_progress(s);
1851 
1852  s->mb_x = 0;
1853  s->mb_y += 1 << field_pic;
1854 
1855  if (s->mb_y >= s->mb_height) {
1856  int left = get_bits_left(&s->gb);
1857  int is_d10 = s->chroma_format == 2 &&
1858  s->pict_type == AV_PICTURE_TYPE_I &&
1859  avctx->profile == 0 && avctx->level == 5 &&
1860  s->intra_dc_precision == 2 &&
1861  s->q_scale_type == 1 && s->alternate_scan == 0 &&
1862  s->progressive_frame == 0
1863  /* vbv_delay == 0xBBB || 0xE10 */;
1864 
1865  if (left >= 32 && !is_d10) {
1866  GetBitContext gb = s->gb;
1867  align_get_bits(&gb);
1868  if (show_bits(&gb, 24) == 0x060E2B) {
1869  av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1870  is_d10 = 1;
1871  }
1872  if (left > 32 && show_bits_long(&gb, 32) == 0x201) {
1873  av_log(avctx, AV_LOG_DEBUG, "skipping m704 alpha (unsupported)\n");
1874  goto eos;
1875  }
1876  }
1877 
1878  if (left < 0 ||
1879  (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1880  ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1881  av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X at %d %d\n",
1882  left, left>0 ? show_bits(&s->gb, FFMIN(left, 23)) : 0, s->mb_x, s->mb_y);
1883  return AVERROR_INVALIDDATA;
1884  } else
1885  goto eos;
1886  }
1887  // There are some files out there which are missing the last slice
1888  // in cases where the slice is completely outside the visible
1889  // area, we detect this here instead of running into the end expecting
1890  // more data
1891  left = get_bits_left(&s->gb);
1892  if (s->mb_y >= ((s->height + 15) >> 4) &&
1893  !s->progressive_sequence &&
1894  left <= 25 &&
1895  left >= 0 &&
1896  s->mb_skip_run == -1 &&
1897  (!left || show_bits(&s->gb, left) == 0))
1898  goto eos;
1899 
1900  ff_init_block_index(s);
1901  }
1902 
1903  /* skip mb handling */
1904  if (s->mb_skip_run == -1) {
1905  /* read increment again */
1906  s->mb_skip_run = 0;
1907  for (;;) {
1908  int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1909  MBINCR_VLC_BITS, 2);
1910  if (code < 0) {
1911  av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1912  return AVERROR_INVALIDDATA;
1913  }
1914  if (code >= 33) {
1915  if (code == 33) {
1916  s->mb_skip_run += 33;
1917  } else if (code == 35) {
1918  if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1919  av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1920  return AVERROR_INVALIDDATA;
1921  }
1922  goto eos; /* end of slice */
1923  }
1924  /* otherwise, stuffing, nothing to do */
1925  } else {
1926  s->mb_skip_run += code;
1927  break;
1928  }
1929  }
1930  if (s->mb_skip_run) {
1931  int i;
1932  if (s->pict_type == AV_PICTURE_TYPE_I) {
1933  av_log(s->avctx, AV_LOG_ERROR,
1934  "skipped MB in I-frame at %d %d\n", s->mb_x, s->mb_y);
1935  return AVERROR_INVALIDDATA;
1936  }
1937 
1938  /* skip mb */
1939  s->mb_intra = 0;
1940  for (i = 0; i < 12; i++)
1941  s->block_last_index[i] = -1;
1942  if (s->picture_structure == PICT_FRAME)
1943  s->mv_type = MV_TYPE_16X16;
1944  else
1945  s->mv_type = MV_TYPE_FIELD;
1946  if (s->pict_type == AV_PICTURE_TYPE_P) {
1947  /* if P type, zero motion vector is implied */
1948  s->mv_dir = MV_DIR_FORWARD;
1949  s->mv[0][0][0] = s->mv[0][0][1] = 0;
1950  s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1951  s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1952  s->field_select[0][0] = (s->picture_structure - 1) & 1;
1953  } else {
1954  /* if B type, reuse previous vectors and directions */
1955  s->mv[0][0][0] = s->last_mv[0][0][0];
1956  s->mv[0][0][1] = s->last_mv[0][0][1];
1957  s->mv[1][0][0] = s->last_mv[1][0][0];
1958  s->mv[1][0][1] = s->last_mv[1][0][1];
1959  s->field_select[0][0] = (s->picture_structure - 1) & 1;
1960  s->field_select[1][0] = (s->picture_structure - 1) & 1;
1961  }
1962  }
1963  }
1964  }
1965 eos: // end of slice
1966  if (get_bits_left(&s->gb) < 0) {
1967  av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
1968  return AVERROR_INVALIDDATA;
1969  }
1970  *buf += (get_bits_count(&s->gb) - 1) / 8;
1971  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);
1972  return 0;
1973 }
1974 
1975 static int slice_decode_thread(AVCodecContext *c, void *arg)
1976 {
1977  MpegEncContext *s = *(void **) arg;
1978  const uint8_t *buf = s->gb.buffer;
1979  int mb_y = s->start_mb_y;
1980  const int field_pic = s->picture_structure != PICT_FRAME;
1981 
1982  s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
1983 
1984  for (;;) {
1985  uint32_t start_code;
1986  int ret;
1987 
1988  ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
1989  emms_c();
1990  ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
1991  ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
1992  s->start_mb_y, s->end_mb_y, s->er.error_count);
1993  if (ret < 0) {
1994  if (c->err_recognition & AV_EF_EXPLODE)
1995  return ret;
1996  if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
1997  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
1998  s->mb_x, s->mb_y,
1999  ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2000  } else {
2001  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2002  s->mb_x - 1, s->mb_y,
2003  ER_AC_END | ER_DC_END | ER_MV_END);
2004  }
2005 
2006  if (s->mb_y == s->end_mb_y)
2007  return 0;
2008 
2009  start_code = -1;
2010  buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2011  mb_y = start_code - SLICE_MIN_START_CODE;
2012  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2013  mb_y += (*buf&0xE0)<<2;
2014  mb_y <<= field_pic;
2015  if (s->picture_structure == PICT_BOTTOM_FIELD)
2016  mb_y++;
2017  if (mb_y < 0 || mb_y >= s->end_mb_y)
2018  return AVERROR_INVALIDDATA;
2019  }
2020 }
2021 
2022 /**
2023  * Handle slice ends.
2024  * @return 1 if it seems to be the last slice
2025  */
2026 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2027 {
2028  Mpeg1Context *s1 = avctx->priv_data;
2029  MpegEncContext *s = &s1->mpeg_enc_ctx;
2030 
2031  if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2032  return 0;
2033 
2034  if (s->avctx->hwaccel) {
2035  int ret = s->avctx->hwaccel->end_frame(s->avctx);
2036  if (ret < 0) {
2037  av_log(avctx, AV_LOG_ERROR,
2038  "hardware accelerator failed to decode picture\n");
2039  return ret;
2040  }
2041  }
2042 
2043  /* end of slice reached */
2044  if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2045  /* end of image */
2046 
2047  ff_er_frame_end(&s->er);
2048 
2049  ff_mpv_frame_end(s);
2050 
2051  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2052  int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2053  if (ret < 0)
2054  return ret;
2055  ff_print_debug_info(s, s->current_picture_ptr, pict);
2056  ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2057  } else {
2058  if (avctx->active_thread_type & FF_THREAD_FRAME)
2059  s->picture_number++;
2060  /* latency of 1 frame for I- and P-frames */
2061  /* XXX: use another variable than picture_number */
2062  if (s->last_picture_ptr) {
2063  int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2064  if (ret < 0)
2065  return ret;
2066  ff_print_debug_info(s, s->last_picture_ptr, pict);
2067  ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2068  }
2069  }
2070 
2071  return 1;
2072  } else {
2073  return 0;
2074  }
2075 }
2076 
2077 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2078  const uint8_t *buf, int buf_size)
2079 {
2080  Mpeg1Context *s1 = avctx->priv_data;
2081  MpegEncContext *s = &s1->mpeg_enc_ctx;
2082  int width, height;
2083  int i, v, j;
2084 
2085  init_get_bits(&s->gb, buf, buf_size * 8);
2086 
2087  width = get_bits(&s->gb, 12);
2088  height = get_bits(&s->gb, 12);
2089  if (width == 0 || height == 0) {
2090  av_log(avctx, AV_LOG_WARNING,
2091  "Invalid horizontal or vertical size value.\n");
2092  if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2093  return AVERROR_INVALIDDATA;
2094  }
2095  s->aspect_ratio_info = get_bits(&s->gb, 4);
2096  if (s->aspect_ratio_info == 0) {
2097  av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2098  if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2099  return AVERROR_INVALIDDATA;
2100  }
2101  s->frame_rate_index = get_bits(&s->gb, 4);
2102  if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2103  av_log(avctx, AV_LOG_WARNING,
2104  "frame_rate_index %d is invalid\n", s->frame_rate_index);
2105  s->frame_rate_index = 1;
2106  }
2107  s->bit_rate = get_bits(&s->gb, 18) * 400LL;
2108  if (check_marker(s->avctx, &s->gb, "in sequence header") == 0) {
2109  return AVERROR_INVALIDDATA;
2110  }
2111 
2112  s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2113  skip_bits(&s->gb, 1);
2114 
2115  /* get matrix */
2116  if (get_bits1(&s->gb)) {
2117  load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2118  } else {
2119  for (i = 0; i < 64; i++) {
2120  j = s->idsp.idct_permutation[i];
2121  v = ff_mpeg1_default_intra_matrix[i];
2122  s->intra_matrix[j] = v;
2123  s->chroma_intra_matrix[j] = v;
2124  }
2125  }
2126  if (get_bits1(&s->gb)) {
2127  load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2128  } else {
2129  for (i = 0; i < 64; i++) {
2130  int j = s->idsp.idct_permutation[i];
2131  v = ff_mpeg1_default_non_intra_matrix[i];
2132  s->inter_matrix[j] = v;
2133  s->chroma_inter_matrix[j] = v;
2134  }
2135  }
2136 
2137  if (show_bits(&s->gb, 23) != 0) {
2138  av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2139  return AVERROR_INVALIDDATA;
2140  }
2141 
2142  s->width = width;
2143  s->height = height;
2144 
2145  /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2146  s->progressive_sequence = 1;
2147  s->progressive_frame = 1;
2148  s->picture_structure = PICT_FRAME;
2149  s->first_field = 0;
2150  s->frame_pred_frame_dct = 1;
2151  s->chroma_format = 1;
2152  s->codec_id =
2153  s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2154  s->out_format = FMT_MPEG1;
2155  s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2156  if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
2157  s->low_delay = 1;
2158 
2159  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2160  av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
2161  s->avctx->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
2162 
2163  return 0;
2164 }
2165 
2166 static int vcr2_init_sequence(AVCodecContext *avctx)
2167 {
2168  Mpeg1Context *s1 = avctx->priv_data;
2169  MpegEncContext *s = &s1->mpeg_enc_ctx;
2170  int i, v, ret;
2171 
2172  /* start new MPEG-1 context decoding */
2173  s->out_format = FMT_MPEG1;
2174  if (s1->mpeg_enc_ctx_allocated) {
2175  ff_mpv_common_end(s);
2176  s1->mpeg_enc_ctx_allocated = 0;
2177  }
2178  s->width = avctx->coded_width;
2179  s->height = avctx->coded_height;
2180  avctx->has_b_frames = 0; // true?
2181  s->low_delay = 1;
2182 
2183  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2184  setup_hwaccel_for_pixfmt(avctx);
2185 
2186  ff_mpv_idct_init(s);
2187  if ((ret = ff_mpv_common_init(s)) < 0)
2188  return ret;
2189  s1->mpeg_enc_ctx_allocated = 1;
2190 
2191  for (i = 0; i < 64; i++) {
2192  int j = s->idsp.idct_permutation[i];
2193  v = ff_mpeg1_default_intra_matrix[i];
2194  s->intra_matrix[j] = v;
2195  s->chroma_intra_matrix[j] = v;
2196 
2197  v = ff_mpeg1_default_non_intra_matrix[i];
2198  s->inter_matrix[j] = v;
2199  s->chroma_inter_matrix[j] = v;
2200  }
2201 
2202  s->progressive_sequence = 1;
2203  s->progressive_frame = 1;
2204  s->picture_structure = PICT_FRAME;
2205  s->first_field = 0;
2206  s->frame_pred_frame_dct = 1;
2207  s->chroma_format = 1;
2208  if (s->codec_tag == AV_RL32("BW10")) {
2209  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2210  } else {
2211  s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2212  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2213  }
2214  s1->save_width = s->width;
2215  s1->save_height = s->height;
2216  s1->save_progressive_seq = s->progressive_sequence;
2217  return 0;
2218 }
2219 
2220 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
2221  const uint8_t *p, int buf_size)
2222 {
2223  Mpeg1Context *s1 = avctx->priv_data;
2224 
2225  if (buf_size >= 6 &&
2226  p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2227  p[4] == 3 && (p[5] & 0x40)) {
2228  /* extract A53 Part 4 CC data */
2229  int cc_count = p[5] & 0x1f;
2230  if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2231  av_freep(&s1->a53_caption);
2232  s1->a53_caption_size = cc_count * 3;
2233  s1->a53_caption = av_malloc(s1->a53_caption_size);
2234  if (!s1->a53_caption) {
2235  s1->a53_caption_size = 0;
2236  } else {
2237  memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2238  }
2239  avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2240  }
2241  return 1;
2242  } else if (buf_size >= 2 &&
2243  p[0] == 0x03 && (p[1]&0x7f) == 0x01) {
2244  /* extract SCTE-20 CC data */
2245  GetBitContext gb;
2246  int cc_count = 0;
2247  int i;
2248 
2249  init_get_bits(&gb, p + 2, buf_size - 2);
2250  cc_count = get_bits(&gb, 5);
2251  if (cc_count > 0) {
2252  av_freep(&s1->a53_caption);
2253  s1->a53_caption_size = cc_count * 3;
2254  s1->a53_caption = av_mallocz(s1->a53_caption_size);
2255  if (!s1->a53_caption) {
2256  s1->a53_caption_size = 0;
2257  } else {
2258  uint8_t field, cc1, cc2;
2259  uint8_t *cap = s1->a53_caption;
2260  for (i = 0; i < cc_count && get_bits_left(&gb) >= 26; i++) {
2261  skip_bits(&gb, 2); // priority
2262  field = get_bits(&gb, 2);
2263  skip_bits(&gb, 5); // line_offset
2264  cc1 = get_bits(&gb, 8);
2265  cc2 = get_bits(&gb, 8);
2266  skip_bits(&gb, 1); // marker
2267 
2268  if (!field) { // forbidden
2269  cap[0] = cap[1] = cap[2] = 0x00;
2270  } else {
2271  field = (field == 2 ? 1 : 0);
2272  if (!s1->mpeg_enc_ctx.top_field_first) field = !field;
2273  cap[0] = 0x04 | field;
2274  cap[1] = ff_reverse[cc1];
2275  cap[2] = ff_reverse[cc2];
2276  }
2277  cap += 3;
2278  }
2279  }
2280  avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2281  }
2282  return 1;
2283  } else if (buf_size >= 11 &&
2284  p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2285  /* extract DVD CC data
2286  *
2287  * uint32_t user_data_start_code 0x000001B2 (big endian)
2288  * uint16_t user_identifier 0x4343 "CC"
2289  * uint8_t user_data_type_code 0x01
2290  * uint8_t caption_block_size 0xF8
2291  * uint8_t
2292  * bit 7 caption_odd_field_first 1=odd field (CC1/CC2) first 0=even field (CC3/CC4) first
2293  * bit 6 caption_filler 0
2294  * bit 5:1 caption_block_count number of caption blocks (pairs of caption words = frames). Most DVDs use 15 per start of GOP.
2295  * bit 0 caption_extra_field_added 1=one additional caption word
2296  *
2297  * struct caption_field_block {
2298  * uint8_t
2299  * bit 7:1 caption_filler 0x7F (all 1s)
2300  * bit 0 caption_field_odd 1=odd field (this is CC1/CC2) 0=even field (this is CC3/CC4)
2301  * uint8_t caption_first_byte
2302  * uint8_t caption_second_byte
2303  * } caption_block[(caption_block_count * 2) + caption_extra_field_added];
2304  *
2305  * Some DVDs encode caption data for both fields with caption_field_odd=1. The only way to decode the fields
2306  * correctly is to start on the field indicated by caption_odd_field_first and count between odd/even fields.
2307  * Don't assume that the first caption word is the odd field. There do exist MPEG files in the wild that start
2308  * on the even field. There also exist DVDs in the wild that encode an odd field count and the
2309  * caption_extra_field_added/caption_odd_field_first bits change per packet to allow that. */
2310  int cc_count = 0;
2311  int i;
2312  // There is a caption count field in the data, but it is often
2313  // incorrect. So count the number of captions present.
2314  for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2315  cc_count++;
2316  // Transform the DVD format into A53 Part 4 format
2317  if (cc_count > 0) {
2318  av_freep(&s1->a53_caption);
2319  s1->a53_caption_size = cc_count * 6;
2320  s1->a53_caption = av_malloc(s1->a53_caption_size);
2321  if (!s1->a53_caption) {
2322  s1->a53_caption_size = 0;
2323  } else {
2324  uint8_t field1 = !!(p[4] & 0x80);
2325  uint8_t *cap = s1->a53_caption;
2326  p += 5;
2327  for (i = 0; i < cc_count; i++) {
2328  cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2329  cap[1] = p[1];
2330  cap[2] = p[2];
2331  cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2332  cap[4] = p[4];
2333  cap[5] = p[5];
2334  cap += 6;
2335  p += 6;
2336  }
2337  }
2338  avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
2339  }
2340  return 1;
2341  }
2342  return 0;
2343 }
2344 
2345 static void mpeg_decode_user_data(AVCodecContext *avctx,
2346  const uint8_t *p, int buf_size)
2347 {
2348  Mpeg1Context *s = avctx->priv_data;
2349  const uint8_t *buf_end = p + buf_size;
2350  Mpeg1Context *s1 = avctx->priv_data;
2351 
2352 #if 0
2353  int i;
2354  for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2355  av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2356  }
2357  av_log(avctx, AV_LOG_ERROR, "\n");
2358 #endif
2359 
2360  if (buf_size > 29){
2361  int i;
2362  for(i=0; i<20; i++)
2363  if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2364  s->tmpgexs= 1;
2365  }
2366  }
2367  /* we parse the DTG active format information */
2368  if (buf_end - p >= 5 &&
2369  p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2370  int flags = p[4];
2371  p += 5;
2372  if (flags & 0x80) {
2373  /* skip event id */
2374  p += 2;
2375  }
2376  if (flags & 0x40) {
2377  if (buf_end - p < 1)
2378  return;
2379  s1->has_afd = 1;
2380  s1->afd = p[0] & 0x0f;
2381  }
2382  } else if (buf_end - p >= 6 &&
2383  p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2384  p[4] == 0x03) { // S3D_video_format_length
2385  // the 0x7F mask ignores the reserved_bit value
2386  const uint8_t S3D_video_format_type = p[5] & 0x7F;
2387 
2388  if (S3D_video_format_type == 0x03 ||
2389  S3D_video_format_type == 0x04 ||
2390  S3D_video_format_type == 0x08 ||
2391  S3D_video_format_type == 0x23) {
2392 
2393  s1->has_stereo3d = 1;
2394 
2395  switch (S3D_video_format_type) {
2396  case 0x03:
2397  s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
2398  break;
2399  case 0x04:
2400  s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
2401  break;
2402  case 0x08:
2403  s1->stereo3d.type = AV_STEREO3D_2D;
2404  break;
2405  case 0x23:
2406  s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2407  break;
2408  }
2409  }
2410  } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2411  return;
2412  }
2413 }
2414 
2415 static void mpeg_decode_gop(AVCodecContext *avctx,
2416  const uint8_t *buf, int buf_size)
2417 {
2418  Mpeg1Context *s1 = avctx->priv_data;
2419  MpegEncContext *s = &s1->mpeg_enc_ctx;
2420  int broken_link;
2421  int64_t tc;
2422 
2423  init_get_bits(&s->gb, buf, buf_size * 8);
2424 
2425  tc = s-> timecode_frame_start = get_bits(&s->gb, 25);
2426 
2427 #if FF_API_PRIVATE_OPT
2428 FF_DISABLE_DEPRECATION_WARNINGS
2429  avctx->timecode_frame_start = tc;
2430 FF_ENABLE_DEPRECATION_WARNINGS
2431 #endif
2432 
2433  s->closed_gop = get_bits1(&s->gb);
2434  /* broken_link indicates that after editing the
2435  * reference frames of the first B-Frames after GOP I-Frame
2436  * are missing (open gop) */
2437  broken_link = get_bits1(&s->gb);
2438 
2439  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2440  char tcbuf[AV_TIMECODE_STR_SIZE];
2441  av_timecode_make_mpeg_tc_string(tcbuf, tc);
2442  av_log(s->avctx, AV_LOG_DEBUG,
2443  "GOP (%s) closed_gop=%d broken_link=%d\n",
2444  tcbuf, s->closed_gop, broken_link);
2445  }
2446 }
2447 
2448 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2449  int *got_output, const uint8_t *buf, int buf_size)
2450 {
2451  Mpeg1Context *s = avctx->priv_data;
2452  MpegEncContext *s2 = &s->mpeg_enc_ctx;
2453  const uint8_t *buf_ptr = buf;
2454  const uint8_t *buf_end = buf + buf_size;
2455  int ret, input_size;
2456  int last_code = 0, skip_frame = 0;
2457  int picture_start_code_seen = 0;
2458 
2459  for (;;) {
2460  /* find next start code */
2461  uint32_t start_code = -1;
2462  buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2463  if (start_code > 0x1ff) {
2464  if (!skip_frame) {
2465  if (HAVE_THREADS &&
2466  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2467  !avctx->hwaccel) {
2468  int i;
2469  av_assert0(avctx->thread_count > 1);
2470 
2471  avctx->execute(avctx, slice_decode_thread,
2472  &s2->thread_context[0], NULL,
2473  s->slice_count, sizeof(void *));
2474  for (i = 0; i < s->slice_count; i++)
2475  s2->er.error_count += s2->thread_context[i]->er.error_count;
2476  }
2477 
2478  ret = slice_end(avctx, picture);
2479  if (ret < 0)
2480  return ret;
2481  else if (ret) {
2482  // FIXME: merge with the stuff in mpeg_decode_slice
2483  if (s2->last_picture_ptr || s2->low_delay || s2->pict_type == AV_PICTURE_TYPE_B)
2484  *got_output = 1;
2485  }
2486  }
2487  s2->pict_type = 0;
2488 
2489  if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2490  return AVERROR_INVALIDDATA;
2491 
2492  return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2493  }
2494 
2495  input_size = buf_end - buf_ptr;
2496 
2497  if (avctx->debug & FF_DEBUG_STARTCODE)
2498  av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2499  start_code, buf_ptr - buf, input_size);
2500 
2501  /* prepare data for next start code */
2502  switch (start_code) {
2503  case SEQ_START_CODE:
2504  if (last_code == 0) {
2505  mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2506  if (buf != avctx->extradata)
2507  s->sync = 1;
2508  } else {
2509  av_log(avctx, AV_LOG_ERROR,
2510  "ignoring SEQ_START_CODE after %X\n", last_code);
2511  if (avctx->err_recognition & AV_EF_EXPLODE)
2512  return AVERROR_INVALIDDATA;
2513  }
2514  break;
2515 
2516  case PICTURE_START_CODE:
2517  if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2518  /* If it's a frame picture, there can't be more than one picture header.
2519  Yet, it does happen and we need to handle it. */
2520  av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2521  break;
2522  }
2523  picture_start_code_seen = 1;
2524 
2525  if (s2->width <= 0 || s2->height <= 0) {
2526  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2527  s2->width, s2->height);
2528  return AVERROR_INVALIDDATA;
2529  }
2530 
2531  if (s->tmpgexs){
2532  s2->intra_dc_precision= 3;
2533  s2->intra_matrix[0]= 1;
2534  }
2535  if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2536  !avctx->hwaccel && s->slice_count) {
2537  int i;
2538 
2539  avctx->execute(avctx, slice_decode_thread,
2540  s2->thread_context, NULL,
2541  s->slice_count, sizeof(void *));
2542  for (i = 0; i < s->slice_count; i++)
2543  s2->er.error_count += s2->thread_context[i]->er.error_count;
2544  s->slice_count = 0;
2545  }
2546  if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2547  ret = mpeg_decode_postinit(avctx);
2548  if (ret < 0) {
2549  av_log(avctx, AV_LOG_ERROR,
2550  "mpeg_decode_postinit() failure\n");
2551  return ret;
2552  }
2553 
2554  /* We have a complete image: we try to decompress it. */
2555  if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2556  s2->pict_type = 0;
2557  s->first_slice = 1;
2558  last_code = PICTURE_START_CODE;
2559  } else {
2560  av_log(avctx, AV_LOG_ERROR,
2561  "ignoring pic after %X\n", last_code);
2562  if (avctx->err_recognition & AV_EF_EXPLODE)
2563  return AVERROR_INVALIDDATA;
2564  }
2565  break;
2566  case EXT_START_CODE:
2567  init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2568 
2569  switch (get_bits(&s2->gb, 4)) {
2570  case 0x1:
2571  if (last_code == 0) {
2572  mpeg_decode_sequence_extension(s);
2573  } else {
2574  av_log(avctx, AV_LOG_ERROR,
2575  "ignoring seq ext after %X\n", last_code);
2576  if (avctx->err_recognition & AV_EF_EXPLODE)
2577  return AVERROR_INVALIDDATA;
2578  }
2579  break;
2580  case 0x2:
2581  mpeg_decode_sequence_display_extension(s);
2582  break;
2583  case 0x3:
2584  mpeg_decode_quant_matrix_extension(s2);
2585  break;
2586  case 0x7:
2587  mpeg_decode_picture_display_extension(s);
2588  break;
2589  case 0x8:
2590  if (last_code == PICTURE_START_CODE) {
2591  mpeg_decode_picture_coding_extension(s);
2592  } else {
2593  av_log(avctx, AV_LOG_ERROR,
2594  "ignoring pic cod ext after %X\n", last_code);
2595  if (avctx->err_recognition & AV_EF_EXPLODE)
2596  return AVERROR_INVALIDDATA;
2597  }
2598  break;
2599  }
2600  break;
2601  case USER_START_CODE:
2602  mpeg_decode_user_data(avctx, buf_ptr, input_size);
2603  break;
2604  case GOP_START_CODE:
2605  if (last_code == 0) {
2606  s2->first_field = 0;
2607  mpeg_decode_gop(avctx, buf_ptr, input_size);
2608  s->sync = 1;
2609  } else {
2610  av_log(avctx, AV_LOG_ERROR,
2611  "ignoring GOP_START_CODE after %X\n", last_code);
2612  if (avctx->err_recognition & AV_EF_EXPLODE)
2613  return AVERROR_INVALIDDATA;
2614  }
2615  break;
2616  default:
2617  if (start_code >= SLICE_MIN_START_CODE &&
2618  start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2619  if (s2->progressive_sequence && !s2->progressive_frame) {
2620  s2->progressive_frame = 1;
2621  av_log(s2->avctx, AV_LOG_ERROR,
2622  "interlaced frame in progressive sequence, ignoring\n");
2623  }
2624 
2625  if (s2->picture_structure == 0 ||
2626  (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2627  av_log(s2->avctx, AV_LOG_ERROR,
2628  "picture_structure %d invalid, ignoring\n",
2629  s2->picture_structure);
2630  s2->picture_structure = PICT_FRAME;
2631  }
2632 
2633  if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2634  av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2635 
2636  if (s2->picture_structure == PICT_FRAME) {
2637  s2->first_field = 0;
2638  s2->v_edge_pos = 16 * s2->mb_height;
2639  } else {
2640  s2->first_field ^= 1;
2641  s2->v_edge_pos = 8 * s2->mb_height;
2642  memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2643  }
2644  }
2645  if (start_code >= SLICE_MIN_START_CODE &&
2646  start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2647  const int field_pic = s2->picture_structure != PICT_FRAME;
2648  int mb_y = start_code - SLICE_MIN_START_CODE;
2649  last_code = SLICE_MIN_START_CODE;
2650  if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2651  mb_y += (*buf_ptr&0xE0)<<2;
2652 
2653  mb_y <<= field_pic;
2654  if (s2->picture_structure == PICT_BOTTOM_FIELD)
2655  mb_y++;
2656 
2657  if (buf_end - buf_ptr < 2) {
2658  av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2659  return AVERROR_INVALIDDATA;
2660  }
2661 
2662  if (mb_y >= s2->mb_height) {
2663  av_log(s2->avctx, AV_LOG_ERROR,
2664  "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2665  return AVERROR_INVALIDDATA;
2666  }
2667 
2668  if (!s2->last_picture_ptr) {
2669  /* Skip B-frames if we do not have reference frames and
2670  * GOP is not closed. */
2671  if (s2->pict_type == AV_PICTURE_TYPE_B) {
2672  if (!s2->closed_gop) {
2673  skip_frame = 1;
2674  av_log(s2->avctx, AV_LOG_DEBUG,
2675  "Skipping B slice due to open GOP\n");
2676  break;
2677  }
2678  }
2679  }
2680  if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2681  s->sync = 1;
2682  if (!s2->next_picture_ptr) {
2683  /* Skip P-frames if we do not have a reference frame or
2684  * we have an invalid header. */
2685  if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2686  skip_frame = 1;
2687  av_log(s2->avctx, AV_LOG_DEBUG,
2688  "Skipping P slice due to !sync\n");
2689  break;
2690  }
2691  }
2692  if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2693  s2->pict_type == AV_PICTURE_TYPE_B) ||
2694  (avctx->skip_frame >= AVDISCARD_NONKEY &&
2695  s2->pict_type != AV_PICTURE_TYPE_I) ||
2696  avctx->skip_frame >= AVDISCARD_ALL) {
2697  skip_frame = 1;
2698  break;
2699  }
2700 
2701  if (!s->mpeg_enc_ctx_allocated)
2702  break;
2703 
2704  if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2705  if (mb_y < avctx->skip_top ||
2706  mb_y >= s2->mb_height - avctx->skip_bottom)
2707  break;
2708  }
2709 
2710  if (!s2->pict_type) {
2711  av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2712  if (avctx->err_recognition & AV_EF_EXPLODE)
2713  return AVERROR_INVALIDDATA;
2714  break;
2715  }
2716 
2717  if (s->first_slice) {
2718  skip_frame = 0;
2719  s->first_slice = 0;
2720  if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2721  return ret;
2722  }
2723  if (!s2->current_picture_ptr) {
2724  av_log(avctx, AV_LOG_ERROR,
2725  "current_picture not initialized\n");
2726  return AVERROR_INVALIDDATA;
2727  }
2728 
2729  if (HAVE_THREADS &&
2730  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2731  !avctx->hwaccel) {
2732  int threshold = (s2->mb_height * s->slice_count +
2733  s2->slice_context_count / 2) /
2734  s2->slice_context_count;
2735  av_assert0(avctx->thread_count > 1);
2736  if (threshold <= mb_y) {
2737  MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2738 
2739  thread_context->start_mb_y = mb_y;
2740  thread_context->end_mb_y = s2->mb_height;
2741  if (s->slice_count) {
2742  s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2743  ret = ff_update_duplicate_context(thread_context, s2);
2744  if (ret < 0)
2745  return ret;
2746  }
2747  init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2748  s->slice_count++;
2749  }
2750  buf_ptr += 2; // FIXME add minimum number of bytes per slice
2751  } else {
2752  ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2753  emms_c();
2754 
2755  if (ret < 0) {
2756  if (avctx->err_recognition & AV_EF_EXPLODE)
2757  return ret;
2758  if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2759  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2760  s2->resync_mb_y, s2->mb_x, s2->mb_y,
2761  ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2762  } else {
2763  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2764  s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2765  ER_AC_END | ER_DC_END | ER_MV_END);
2766  }
2767  }
2768  }
2769  break;
2770  }
2771  }
2772 }
2773 
2774 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2775  int *got_output, AVPacket *avpkt)
2776 {
2777  const uint8_t *buf = avpkt->data;
2778  int ret;
2779  int buf_size = avpkt->size;
2780  Mpeg1Context *s = avctx->priv_data;
2781  AVFrame *picture = data;
2782  MpegEncContext *s2 = &s->mpeg_enc_ctx;
2783 
2784  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2785  /* special case for last picture */
2786  if (s2->low_delay == 0 && s2->next_picture_ptr) {
2787  int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2788  if (ret < 0)
2789  return ret;
2790 
2791  s2->next_picture_ptr = NULL;
2792 
2793  *got_output = 1;
2794  }
2795  return buf_size;
2796  }
2797 
2798  if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2799  int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2800  buf_size, NULL);
2801 
2802  if (ff_combine_frame(&s2->parse_context, next,
2803  (const uint8_t **) &buf, &buf_size) < 0)
2804  return buf_size;
2805  }
2806 
2807  s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2808  if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2809  || s2->codec_tag == AV_RL32("BW10")
2810  ))
2811  vcr2_init_sequence(avctx);
2812 
2813  s->slice_count = 0;
2814 
2815  if (avctx->extradata && !s->extradata_decoded) {
2816  ret = decode_chunks(avctx, picture, got_output,
2817  avctx->extradata, avctx->extradata_size);
2818  if (*got_output) {
2819  av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2820  av_frame_unref(picture);
2821  *got_output = 0;
2822  }
2823  s->extradata_decoded = 1;
2824  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2825  s2->current_picture_ptr = NULL;
2826  return ret;
2827  }
2828  }
2829 
2830  ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2831  if (ret<0 || *got_output) {
2832  s2->current_picture_ptr = NULL;
2833 
2834  if (s2->timecode_frame_start != -1 && *got_output) {
2835  AVFrameSideData *tcside = av_frame_new_side_data(picture,
2836  AV_FRAME_DATA_GOP_TIMECODE,
2837  sizeof(int64_t));
2838  if (!tcside)
2839  return AVERROR(ENOMEM);
2840  memcpy(tcside->data, &s2->timecode_frame_start, sizeof(int64_t));
2841 
2842  s2->timecode_frame_start = -1;
2843  }
2844  }
2845 
2846  return ret;
2847 }
2848 
2849 static void flush(AVCodecContext *avctx)
2850 {
2851  Mpeg1Context *s = avctx->priv_data;
2852 
2853  s->sync = 0;
2854 
2855  ff_mpeg_flush(avctx);
2856 }
2857 
2858 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2859 {
2860  Mpeg1Context *s = avctx->priv_data;
2861 
2862  if (s->mpeg_enc_ctx_allocated)
2863  ff_mpv_common_end(&s->mpeg_enc_ctx);
2864  av_freep(&s->a53_caption);
2865  return 0;
2866 }
2867 
2868 AVCodec ff_mpeg1video_decoder = {
2869  .name = "mpeg1video",
2870  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2871  .type = AVMEDIA_TYPE_VIDEO,
2872  .id = AV_CODEC_ID_MPEG1VIDEO,
2873  .priv_data_size = sizeof(Mpeg1Context),
2874  .init = mpeg_decode_init,
2875  .close = mpeg_decode_end,
2876  .decode = mpeg_decode_frame,
2877  .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2878  AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2879  AV_CODEC_CAP_SLICE_THREADS,
2880  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2881  .flush = flush,
2882  .max_lowres = 3,
2883  .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context),
2884  .hw_configs = (const AVCodecHWConfigInternal*[]) {
2885 #if CONFIG_MPEG1_NVDEC_HWACCEL
2886  HWACCEL_NVDEC(mpeg1),
2887 #endif
2888 #if CONFIG_MPEG1_VDPAU_HWACCEL
2889  HWACCEL_VDPAU(mpeg1),
2890 #endif
2891 #if CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL
2892  HWACCEL_VIDEOTOOLBOX(mpeg1),
2893 #endif
2894 #if CONFIG_MPEG1_XVMC_HWACCEL
2895  HWACCEL_XVMC(mpeg1),
2896 #endif
2897  NULL
2898  },
2899 };
2900 
2901 AVCodec ff_mpeg2video_decoder = {
2902  .name = "mpeg2video",
2903  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2904  .type = AVMEDIA_TYPE_VIDEO,
2905  .id = AV_CODEC_ID_MPEG2VIDEO,
2906  .priv_data_size = sizeof(Mpeg1Context),
2907  .init = mpeg_decode_init,
2908  .close = mpeg_decode_end,
2909  .decode = mpeg_decode_frame,
2910  .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 |
2911  AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY |
2912  AV_CODEC_CAP_SLICE_THREADS,
2913  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2914  .flush = flush,
2915  .max_lowres = 3,
2916  .profiles = NULL_IF_CONFIG_SMALL(ff_mpeg2_video_profiles),
2917  .hw_configs = (const AVCodecHWConfigInternal*[]) {
2918 #if CONFIG_MPEG2_DXVA2_HWACCEL
2919  HWACCEL_DXVA2(mpeg2),
2920 #endif
2921 #if CONFIG_MPEG2_D3D11VA_HWACCEL
2922  HWACCEL_D3D11VA(mpeg2),
2923 #endif
2924 #if CONFIG_MPEG2_D3D11VA2_HWACCEL
2925  HWACCEL_D3D11VA2(mpeg2),
2926 #endif
2927 #if CONFIG_MPEG2_NVDEC_HWACCEL
2928  HWACCEL_NVDEC(mpeg2),
2929 #endif
2930 #if CONFIG_MPEG2_VAAPI_HWACCEL
2931  HWACCEL_VAAPI(mpeg2),
2932 #endif
2933 #if CONFIG_MPEG2_VDPAU_HWACCEL
2934  HWACCEL_VDPAU(mpeg2),
2935 #endif
2936 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
2937  HWACCEL_VIDEOTOOLBOX(mpeg2),
2938 #endif
2939 #if CONFIG_MPEG2_XVMC_HWACCEL
2940  HWACCEL_XVMC(mpeg2),
2941 #endif
2942  NULL
2943  },
2944 };
2945 
2946 //legacy decoder
2947 AVCodec ff_mpegvideo_decoder = {
2948  .name = "mpegvideo",
2949  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2950  .type = AVMEDIA_TYPE_VIDEO,
2951  .id = AV_CODEC_ID_MPEG2VIDEO,
2952  .priv_data_size = sizeof(Mpeg1Context),
2953  .init = mpeg_decode_init,
2954  .close = mpeg_decode_end,
2955  .decode = mpeg_decode_frame,
2956  .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS,
2957  .caps_internal = FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
2958  .flush = flush,
2959  .max_lowres = 3,
2960 };
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:39
vcr2_init_sequence
static int vcr2_init_sequence(AVCodecContext *avctx)
Definition: mpeg12dec.c:2166
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:894
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwaccel.h:71
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2729
AVCodec
AVCodec.
Definition: avcodec.h:3481
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
ff_rl_mpeg2
RLTable ff_rl_mpeg2
Definition: mpeg12data.c:174
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:67
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
Mpeg1Context::has_afd
int has_afd
Definition: mpeg12dec.c:63
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:235
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:207
ff_mpeg2_aspect
const AVRational ff_mpeg2_aspect[16]
Definition: mpeg12data.c:395
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
mpeg_decode_a53_cc
static int mpeg_decode_a53_cc(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition: mpeg12dec.c:2220
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
FMT_MPEG1
@ FMT_MPEG1
Definition: mpegutils.h:124
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AV_STEREO3D_SIDEBYSIDE_QUINCUNX
@ AV_STEREO3D_SIDEBYSIDE_QUINCUNX
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:117
MpegEncContext::gb
GetBitContext gb
Definition: mpegvideo.h:448
mpeg_decode_frame
static int mpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_output, AVPacket *avpkt)
Definition: mpeg12dec.c:2774
n
int n
Definition: avisynth_c.h:760
check_scantable_index
#define check_scantable_index(ctx, x)
Definition: mpeg12dec.c:128
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
MT_FIELD
#define MT_FIELD
Definition: mpeg12dec.c:650
EXT_START_CODE
#define EXT_START_CODE
Definition: cavs.h:33
MV_TYPE_16X8
#define MV_TYPE_16X8
2 vectors, one per 16x8 block
Definition: mpegvideo.h:268
ff_mbincr_vlc
VLC ff_mbincr_vlc
Definition: mpeg12.c:132
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
mpeg_get_qscale
static int mpeg_get_qscale(MpegEncContext *s)
Definition: mpegvideo.h:761
AVPanScan
Pan Scan area.
Definition: avcodec.h:1099
SLICE_FLAG_ALLOW_FIELD
#define SLICE_FLAG_ALLOW_FIELD
allow draw_horiz_band() with field slices (MPEG-2 field pics)
Definition: avcodec.h:2045
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2694
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
Definition: frame.c:722
MB_TYPE_16x8
#define MB_TYPE_16x8
Definition: mpegutils.h:55
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
SEQ_START_CODE
#define SEQ_START_CODE
Definition: mpegvideo.h:68
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition: hwaccel.h:79
AV_CODEC_CAP_TRUNCATED
#define AV_CODEC_CAP_TRUNCATED
Definition: avcodec.h:982
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
start_code
static const uint8_t start_code[]
Definition: videotoolboxenc.c:173
ff_mpeg12_common_init
av_cold void ff_mpeg12_common_init(MpegEncContext *s)
Definition: mpeg12.c:107
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:1853
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
mpeg_decode_mb
static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpeg12dec.c:655
mpeg2_decode_block_intra
static int mpeg2_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:473
ff_reverse
const uint8_t ff_reverse[256]
Definition: reverse.c:23
data
const char data[16]
Definition: mxf.c:91
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:54
AV_PIX_FMT_D3D11VA_VLD
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:229
mpeg2_fast_decode_block_intra
static int mpeg2_fast_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
Changing this would eat up any speed benefits it has.
Definition: mpeg12dec.c:562
version.h
get_vlc2
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
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
Mpeg1Context::a53_caption_size
int a53_caption_size
Definition: mpeg12dec.c:61
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition: error_resilience.c:830
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2281
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:75
mpegvideo.h
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:2709
MB_TYPE_L1
#define MB_TYPE_L1
Definition: mpegutils.h:68
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
Mpeg1Context::first_slice
int first_slice
Definition: mpeg12dec.c:70
ER_DC_END
#define ER_DC_END
Definition: error_resilience.h:35
mpeg_decode_postinit
static int mpeg_decode_postinit(AVCodecContext *avctx)
Definition: mpeg12dec.c:1209
mpegutils.h
FF_IDCT_AUTO
#define FF_IDCT_AUTO
Definition: avcodec.h:2769
ER_MV_ERROR
#define ER_MV_ERROR
Definition: error_resilience.h:33
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
thread.h
ff_mb_pat_vlc
VLC ff_mb_pat_vlc
Definition: mpeg12.c:135
SLICE_MAX_START_CODE
#define SLICE_MAX_START_CODE
Definition: avs2_parser.c:24
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2651
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
MV_TYPE_DMV
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition: mpegvideo.h:270
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
FF_IDCT_NONE
#define FF_IDCT_NONE
Definition: avcodec.h:2781
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
Mpeg1Context::save_aspect
AVRational save_aspect
Definition: mpeg12dec.c:65
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:3105
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:67
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
MB_TYPE_ZERO_MV
#define MB_TYPE_ZERO_MV
Definition: mpeg12dec.c:74
MT_DMV
#define MT_DMV
Definition: mpeg12dec.c:653
ParseContext
Definition: parser.h:28
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:1574
decode_chunks
static int decode_chunks(AVCodecContext *avctx, AVFrame *picture, int *got_output, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2448
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:3040
ff_mpeg1_decode_block_intra
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
mpeg_decode_quant_matrix_extension
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
Definition: mpeg12dec.c:1517
ff_xvmc_init_block
void ff_xvmc_init_block(MpegEncContext *s)
Initialize the block field of the MpegEncContext pointer passed as parameter after making sure that t...
Definition: mpegvideo_xvmc.c:43
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:2824
AV_STEREO3D_2D
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:55
wrap
#define wrap(func)
Definition: neontest.h:65
PICTURE_START_CODE
#define PICTURE_START_CODE
Definition: mpegvideo.h:70
RLTable
RLTable.
Definition: rl.h:39
GetBitContext
Definition: get_bits.h:61
USES_LIST
#define USES_LIST(a, list)
Definition: mpegutils.h:99
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo.c:2274
slice_decode_thread
static int slice_decode_thread(AVCodecContext *c, void *arg)
Definition: mpeg12dec.c:1975
ff_xvmc_pack_pblocks
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...
Definition: mpegvideo_xvmc.c:64
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
MB_TYPE_CBP
#define MB_TYPE_CBP
Definition: mpegutils.h:71
Mpeg1Context::tmpgexs
int tmpgexs
Definition: mpeg12dec.c:69
AV_CODEC_FLAG_LOW_DELAY
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:900
mpeg12_pixfmt_list_444
static enum AVPixelFormat mpeg12_pixfmt_list_444[]
Definition: mpeg12dec.c:1166
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:1753
mpeg1_decode_sequence
static int mpeg1_decode_sequence(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2077
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
HAS_CBP
#define HAS_CBP(a)
Definition: mpegutils.h:101
AVRational::num
int num
Numerator.
Definition: rational.h:59
Mpeg1Context::a53_caption
uint8_t * a53_caption
Definition: mpeg12dec.c:60
HWACCEL_VIDEOTOOLBOX
@ HWACCEL_VIDEOTOOLBOX
Definition: ffmpeg.h:62
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: internal.h:60
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: avcodec.h:2703
mpeg1_hwaccel_pixfmt_list_420
static enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[]
Definition: mpeg12dec.c:1120
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1140
mpeg12.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
ER_DC_ERROR
#define ER_DC_ERROR
Definition: error_resilience.h:32
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
mpeg2_hwaccel_pixfmt_list_420
static enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[]
Definition: mpeg12dec.c:1134
ff_mpeg2video_decoder
AVCodec ff_mpeg2video_decoder
Definition: mpeg12dec.c:2901
mpeg1_decode_picture
static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:1346
flush
static void flush(AVCodecContext *avctx)
Definition: mpeg12dec.c:2849
Mpeg1Context::save_progressive_seq
int save_progressive_seq
Definition: mpeg12dec.c:66
ff_rl_mpeg1
RLTable ff_rl_mpeg1
Definition: mpeg12data.c:166
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
hwaccel.h
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:1667
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1855
Mpeg1Context::repeat_field
int repeat_field
Definition: mpeg12dec.c:56
width
#define width
stereo3d.h
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:137
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_mpeg1_aspect
const float ff_mpeg1_aspect[16]
Definition: mpeg12data.c:374
FF_QSCALE_TYPE_MPEG2
#define FF_QSCALE_TYPE_MPEG2
Definition: internal.h:82
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1697
s1
#define s1
Definition: regdef.h:38
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2026
Mpeg1Context::mpeg_enc_ctx_allocated
int mpeg_enc_ctx_allocated
Definition: mpeg12dec.c:55
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:212
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
mpeg_decode_sequence_display_extension
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1436
Mpeg1Context::pan_scan
AVPanScan pan_scan
Definition: mpeg12dec.c:57
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ctx
AVFormatContext * ctx
Definition: movenc.c:48
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
mpeg12_pixfmt_list_422
static enum AVPixelFormat mpeg12_pixfmt_list_422[]
Definition: mpeg12dec.c:1161
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
IS_INTRA
#define IS_INTRA(x, y)
field
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
Definition: writing_filters.txt:78
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:2443
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:1575
int32_t
int32_t
Definition: audio_convert.c:194
arg
const char * arg
Definition: jacosubdec.c:66
if
if(ret)
Definition: filter_design.txt:179
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:811
MB_PTYPE_VLC_BITS
#define MB_PTYPE_VLC_BITS
Definition: mpeg12vlc.h:39
Mpeg1Context::save_width
int save_width
Definition: mpeg12dec.c:66
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:263
NULL
#define NULL
Definition: coverity.c:32
HWACCEL_DXVA2
#define HWACCEL_DXVA2(codec)
Definition: hwaccel.h:67
run
uint8_t run
Definition: svq3.c:206
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2200
ER_AC_ERROR
#define ER_AC_ERROR
Definition: error_resilience.h:31
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:330
Mpeg1Context::sync
int sync
Definition: mpeg12dec.c:68
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:543
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:545
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1615
mpeg_decode_picture_display_extension
static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1460
AV_CODEC_FLAG2_FAST
#define AV_CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
Definition: avcodec.h:923
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
SEQ_END_CODE
#define SEQ_END_CODE
Definition: mpegvideo.h:67
profiles.h
AV_CODEC_FLAG_TRUNCATED
#define AV_CODEC_FLAG_TRUNCATED
Input bitstream might be truncated at a random location instead of only at frame boundaries.
Definition: avcodec.h:892
AV_PIX_FMT_XVMC
@ AV_PIX_FMT_XVMC
XVideo Motion Acceleration via common packet passing.
Definition: pixfmt.h:273
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
MB_TYPE_QUANT
#define MB_TYPE_QUANT
Definition: mpegutils.h:70
lowres
static int lowres
Definition: ffplay.c:335
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:227
MB_BTYPE_VLC_BITS
#define MB_BTYPE_VLC_BITS
Definition: mpeg12vlc.h:40
xvmc_internal.h
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
update_thread_context
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have update_thread_context() run it in the next thread. If the codec allocates writable tables in its init()
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2705
AV_FRAME_DATA_AFD
@ AV_FRAME_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:89
AVCodecContext::level
int level
level
Definition: avcodec.h:3018
Mpeg1Context::save_height
int save_height
Definition: mpeg12dec.c:66
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: avcodec.h:219
ff_mb_ptype_vlc
VLC ff_mb_ptype_vlc
Definition: mpeg12.c:133
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
quant_matrix_rebuild
static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm, const uint8_t *new_perm)
Definition: mpeg12dec.c:1108
ff_mpeg1_find_frame_end
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
s2
#define s2
Definition: regdef.h:39
HWACCEL_XVMC
#define HWACCEL_XVMC(codec)
Definition: hwaccel.h:81
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: avcodec.h:810
MV_VLC_BITS
#define MV_VLC_BITS
Definition: ituh263dec.c:54
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:883
AVPacket::size
int size
Definition: avcodec.h:1478
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
AV_FRAME_DATA_PANSCAN
@ AV_FRAME_DATA_PANSCAN
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:52
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
MT_FRAME
#define MT_FRAME
Definition: mpeg12dec.c:651
SLICE_MIN_START_CODE
#define SLICE_MIN_START_CODE
Definition: mpegvideo.h:71
ff_mpeg1_clean_buffers
void ff_mpeg1_clean_buffers(MpegEncContext *s)
Definition: mpeg12.c:115
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
GOP_START_CODE
#define GOP_START_CODE
Definition: mpegvideo.h:69
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:92
AVFrameSideData::data
uint8_t * data
Definition: frame.h:203
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:62
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:2836
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2314
USER_START_CODE
#define USER_START_CODE
Definition: cavs.h:34
AVCodecContext::skip_bottom
int skip_bottom
Number of macroblock rows at the bottom which are skipped.
Definition: avcodec.h:2105
AVCodecHWConfigInternal
Definition: hwaccel.h:29
val
const char const char void * val
Definition: avisynth_c.h:863
ff_mpeg1_default_intra_matrix
const uint16_t ff_mpeg1_default_intra_matrix[256]
Definition: mpeg12data.c:30
MB_TYPE_INTERLACED
#define MB_TYPE_INTERLACED
Definition: mpegutils.h:58
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
height
#define height
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
ff_mpeg_update_thread_context
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo.c:495
Mpeg1Context::has_stereo3d
int has_stereo3d
Definition: mpeg12dec.c:59
mpeg_decode_init
static av_cold int mpeg_decode_init(AVCodecContext *avctx)
Definition: mpeg12dec.c:1052
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1041
mpegvideodata.h
attributes.h
MV_TYPE_FIELD
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:269
ff_mpv_export_qp_table
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:1453
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:313
ff_print_debug_info
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1446
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Definition: pixfmt.h:122
ff_combine_frame
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
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2835
AVCodec::id
enum AVCodecID id
Definition: avcodec.h:3495
ff_mpeg2_video_profiles
const AVProfile ff_mpeg2_video_profiles[]
Definition: profiles.c:94
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:197
MB_TYPE_L0L1
#define MB_TYPE_L0L1
Definition: mpegutils.h:69
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:282
mpeg_decode_gop
static void mpeg_decode_gop(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2415
setup_hwaccel_for_pixfmt
static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
Definition: mpeg12dec.c:1192
AVCodecContext::timecode_frame_start
attribute_deprecated int64_t timecode_frame_start
Definition: avcodec.h:2527
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
AV_CODEC_FLAG2_SHOW_ALL
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition: avcodec.h:951
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:3227
ff_alternate_vertical_scan
const uint8_t ff_alternate_vertical_scan[64]
Definition: mpegvideodata.c:100
btype2mb_type
static const uint32_t btype2mb_type[11]
Definition: mpeg12dec.c:86
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
AVHWAccel::decode_slice
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:3739
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
internal.h
AV_STEREO3D_TOPBOTTOM
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition: stereo3d.h:79
IS_QUANT
#define IS_QUANT(a)
Definition: mpegutils.h:95
ff_mpeg12_init_vlcs
av_cold void ff_mpeg12_init_vlcs(void)
Definition: mpeg12.c:137
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: dv.h:96
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:2664
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
MB_PAT_VLC_BITS
#define MB_PAT_VLC_BITS
Definition: mpeg12vlc.h:38
mpeg1_decode_block_inter
static int mpeg1_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:137
ff_mpegvideo_decoder
AVCodec ff_mpegvideo_decoder
Definition: mpeg12dec.c:2947
uint8_t
uint8_t
Definition: audio_convert.c:194
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
AVCodecContext::idct_algo
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:2768
ptype2mb_type
static const uint32_t ptype2mb_type[7]
Definition: mpeg12dec.c:76
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2207
MAX_INDEX
#define MAX_INDEX
Definition: mpeg12dec.c:127
ff_mpv_decode_defaults
void ff_mpv_decode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for decoding.
Definition: mpegvideo.c:671
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1438
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:521
Mpeg1Context::stereo3d
AVStereo3D stereo3d
Definition: mpeg12dec.c:58
idctdsp.h
avcodec.h
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:738
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ff_mpeg12_frame_rate_tab
const AVRational ff_mpeg12_frame_rate_tab[]
Definition: mpeg12framerate.c:24
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition: frame.h:124
ff_mpeg1_default_non_intra_matrix
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
Definition: mpeg12data.c:41
mpeg1_fast_decode_block_inter
static int mpeg1_fast_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
Changing this would eat up any speed benefits it has.
Definition: mpeg12dec.c:226
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
ff_mpv_frame_start
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1214
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
mpeg_get_pixelformat
static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
Definition: mpeg12dec.c:1171
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:88
mpeg12data.h
mpeg2_fast_decode_block_non_intra
static int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, int16_t *block, int n)
Changing this would eat up any speed benefits it has.
Definition: mpeg12dec.c:401
mpeg_field_start
static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:1590
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:854
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2843
av_timecode_make_mpeg_tc_string
char * av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)
Get the timecode string from the 25-bit timecode format (MPEG GOP format).
Definition: timecode.c:130
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwaccel.h:73
decode_dc
static int decode_dc(GetBitContext *gb, int component)
Definition: mpeg12.h:41
AVCodecContext::execute
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2864
ff_update_duplicate_context
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
Definition: mpegvideo.c:467
mpeg_decode_picture_coding_extension
static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1531
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
ff_mpeg1video_decoder
AVCodec ff_mpeg1video_decoder
Definition: mpeg12dec.c:2868
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:544
AVRational::den
int den
Denominator.
Definition: rational.h:60
error_resilience.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:2898
ff_mb_btype_vlc
VLC ff_mb_btype_vlc
Definition: mpeg12.c:134
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2262
Mpeg1Context::slice_count
int slice_count
Definition: mpeg12dec.c:64
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:426
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:1006
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:3229
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:2650
AV_EF_AGGRESSIVE
#define AV_EF_AGGRESSIVE
consider things that a sane encoder should not do as an error
Definition: avcodec.h:2710
AVHWAccel::start_frame
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:3711
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
shift
static int shift(int a, int b)
Definition: sonic.c:82
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1753
get_dmv
static int get_dmv(MpegEncContext *s)
Definition: mpeg12dec.c:641
tc
#define tc
Definition: regdef.h:69
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mpeg_decode_end
static av_cold int mpeg_decode_end(AVCodecContext *avctx)
Definition: mpeg12dec.c:2858
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:104
av_stereo3d_create_side_data
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition: stereo3d.c:33
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:201
ff_thread_get_format
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: pthread_frame.c:938
check_marker
static int check_marker(void *logctx, GetBitContext *s, const char *msg)
Definition: get_bits.h:612
ER_MV_END
#define ER_MV_END
Definition: error_resilience.h:36
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
ff_mv_vlc
VLC ff_mv_vlc
Definition: mpeg12.c:127
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1590
Mpeg1Context::mpeg_enc_ctx
MpegEncContext mpeg_enc_ctx
Definition: mpeg12dec.c:54
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
ff_er_frame_end
void ff_er_frame_end(ERContext *s)
Definition: error_resilience.c:900
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
mpeg_decode_sequence_extension
static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1393
mpeg_er.h
bytestream.h
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:565
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: avcodec.h:975
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
Mpeg1Context::frame_rate_ext
AVRational frame_rate_ext
Definition: mpeg12dec.c:67
mpeg_decode_motion
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
Definition: mpeg12dec.c:101
ff_mpv_report_decode_progress
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo.c:2359
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
mpeg_decode_user_data
static void mpeg_decode_user_data(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition: mpeg12dec.c:2345
h
h
Definition: vp9dsp_template.c:2038
MpegEncContext::end_mb_y
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
Definition: mpegvideo.h:154
ER_AC_END
#define ER_AC_END
Definition: error_resilience.h:34
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:176
av_image_check_sar
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
Definition: imgutils.c:287
MpegEncContext::start_mb_y
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
Definition: mpegvideo.h:153
ff_mpv_decode_init
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Definition: mpegvideo.c:676
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: avcodec.h:807
DECODE_SLICE_OK
#define DECODE_SLICE_OK
Definition: mpeg12dec.c:1690
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
DECODE_SLICE_ERROR
#define DECODE_SLICE_ERROR
Definition: mpeg12dec.c:1689
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:81
load_matrix
static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1[64], int intra)
Definition: mpeg12dec.c:1494
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:1944
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwaccel.h:75
Mpeg1Context::afd
uint8_t afd
Definition: mpeg12dec.c:62
Mpeg1Context
Definition: mpeg12dec.c:53
RLTable::rl_vlc
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
Mpeg1Context::extradata_decoded
int extradata_decoded
Definition: mpeg12dec.c:71
mpeg2_decode_block_non_intra
static int mpeg2_decode_block_non_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:311
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:73
MBINCR_VLC_BITS
#define MBINCR_VLC_BITS
Definition: mpeg12vlc.h:37
mpeg_decode_slice
static int mpeg_decode_slice(MpegEncContext *s, int mb_y, const uint8_t **buf, int buf_size)
Decode a slice.
Definition: mpeg12dec.c:1698
re
float re
Definition: fft.c:82
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwaccel.h:69
Generated on Wed Aug 24 2022 21:26:51 for FFmpeg by   doxygen 1.8.17