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