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