FFmpeg  2.8.17
 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  * Changing this would eat up any speed benefits it has.
312  * Do not use "fast" flag if you need the code to be robust.
313  */
315  int16_t *block, int n)
316 {
317  int level, i, j, run;
318  RLTable *rl = &ff_rl_mpeg1;
319  uint8_t *const scantable = s->intra_scantable.permutated;
320  const int qscale = s->qscale;
321 
322  {
323  OPEN_READER(re, &s->gb);
324  i = -1;
325  // Special case for first coefficient, no need to add second VLC table.
326  UPDATE_CACHE(re, &s->gb);
327  if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
328  level = (3 * qscale) >> 1;
329  level = (level - 1) | 1;
330  if (GET_CACHE(re, &s->gb) & 0x40000000)
331  level = -level;
332  block[0] = level;
333  i++;
334  SKIP_BITS(re, &s->gb, 2);
335  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
336  goto end;
337  }
338 
339  /* now quantify & encode AC coefficients */
340  for (;;) {
341  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
342  TEX_VLC_BITS, 2, 0);
343 
344  if (level != 0) {
345  i += run;
346  check_scantable_index(s, i);
347  j = scantable[i];
348  level = ((level * 2 + 1) * qscale) >> 1;
349  level = (level - 1) | 1;
350  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
351  SHOW_SBITS(re, &s->gb, 1);
352  SKIP_BITS(re, &s->gb, 1);
353  } else {
354  /* escape */
355  run = SHOW_UBITS(re, &s->gb, 6) + 1;
356  LAST_SKIP_BITS(re, &s->gb, 6);
357  UPDATE_CACHE(re, &s->gb);
358  level = SHOW_SBITS(re, &s->gb, 8);
359  SKIP_BITS(re, &s->gb, 8);
360  if (level == -128) {
361  level = SHOW_UBITS(re, &s->gb, 8) - 256;
362  SKIP_BITS(re, &s->gb, 8);
363  } else if (level == 0) {
364  level = SHOW_UBITS(re, &s->gb, 8);
365  SKIP_BITS(re, &s->gb, 8);
366  }
367  i += run;
368  check_scantable_index(s, i);
369  j = scantable[i];
370  if (level < 0) {
371  level = -level;
372  level = ((level * 2 + 1) * qscale) >> 1;
373  level = (level - 1) | 1;
374  level = -level;
375  } else {
376  level = ((level * 2 + 1) * qscale) >> 1;
377  level = (level - 1) | 1;
378  }
379  }
380 
381  block[j] = level;
382  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
383  break;
384  UPDATE_CACHE(re, &s->gb);
385  }
386 end:
387  LAST_SKIP_BITS(re, &s->gb, 2);
388  CLOSE_READER(re, &s->gb);
389  }
390  s->block_last_index[n] = i;
391  return 0;
392 }
393 
395  int16_t *block, int n)
396 {
397  int level, i, j, run;
398  RLTable *rl = &ff_rl_mpeg1;
399  uint8_t *const scantable = s->intra_scantable.permutated;
400  const uint16_t *quant_matrix;
401  const int qscale = s->qscale;
402  int mismatch;
403 
404  mismatch = 1;
405 
406  {
407  OPEN_READER(re, &s->gb);
408  i = -1;
409  if (n < 4)
410  quant_matrix = s->inter_matrix;
411  else
412  quant_matrix = s->chroma_inter_matrix;
413 
414  // Special case for first coefficient, no need to add second VLC table.
415  UPDATE_CACHE(re, &s->gb);
416  if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
417  level = (3 * qscale * quant_matrix[0]) >> 5;
418  if (GET_CACHE(re, &s->gb) & 0x40000000)
419  level = -level;
420  block[0] = level;
421  mismatch ^= level;
422  i++;
423  SKIP_BITS(re, &s->gb, 2);
424  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
425  goto end;
426  }
427 
428  /* now quantify & encode AC coefficients */
429  for (;;) {
430  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
431  TEX_VLC_BITS, 2, 0);
432 
433  if (level != 0) {
434  i += run;
435  check_scantable_index(s, i);
436  j = scantable[i];
437  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
438  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
439  SHOW_SBITS(re, &s->gb, 1);
440  SKIP_BITS(re, &s->gb, 1);
441  } else {
442  /* escape */
443  run = SHOW_UBITS(re, &s->gb, 6) + 1;
444  LAST_SKIP_BITS(re, &s->gb, 6);
445  UPDATE_CACHE(re, &s->gb);
446  level = SHOW_SBITS(re, &s->gb, 12);
447  SKIP_BITS(re, &s->gb, 12);
448 
449  i += run;
450  check_scantable_index(s, i);
451  j = scantable[i];
452  if (level < 0) {
453  level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
454  level = -level;
455  } else {
456  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
457  }
458  }
459 
460  mismatch ^= level;
461  block[j] = level;
462  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
463  break;
464  UPDATE_CACHE(re, &s->gb);
465  }
466 end:
467  LAST_SKIP_BITS(re, &s->gb, 2);
468  CLOSE_READER(re, &s->gb);
469  }
470  block[63] ^= (mismatch & 1);
471 
472  s->block_last_index[n] = i;
473  return 0;
474 }
475 
476 /**
477  * Changing this would eat up any speed benefits it has.
478  * Do not use "fast" flag if you need the code to be robust.
479  */
481  int16_t *block, int n)
482 {
483  int level, i, j, run;
484  RLTable *rl = &ff_rl_mpeg1;
485  uint8_t *const scantable = s->intra_scantable.permutated;
486  const int qscale = s->qscale;
487  OPEN_READER(re, &s->gb);
488  i = -1;
489 
490  // special case for first coefficient, no need to add second VLC table
491  UPDATE_CACHE(re, &s->gb);
492  if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
493  level = (3 * qscale) >> 1;
494  if (GET_CACHE(re, &s->gb) & 0x40000000)
495  level = -level;
496  block[0] = level;
497  i++;
498  SKIP_BITS(re, &s->gb, 2);
499  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
500  goto end;
501  }
502 
503  /* now quantify & encode AC coefficients */
504  for (;;) {
505  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
506 
507  if (level != 0) {
508  i += run;
509  j = scantable[i];
510  level = ((level * 2 + 1) * qscale) >> 1;
511  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
512  SHOW_SBITS(re, &s->gb, 1);
513  SKIP_BITS(re, &s->gb, 1);
514  } else {
515  /* escape */
516  run = SHOW_UBITS(re, &s->gb, 6) + 1;
517  LAST_SKIP_BITS(re, &s->gb, 6);
518  UPDATE_CACHE(re, &s->gb);
519  level = SHOW_SBITS(re, &s->gb, 12);
520  SKIP_BITS(re, &s->gb, 12);
521 
522  i += run;
523  j = scantable[i];
524  if (level < 0) {
525  level = ((-level * 2 + 1) * qscale) >> 1;
526  level = -level;
527  } else {
528  level = ((level * 2 + 1) * qscale) >> 1;
529  }
530  }
531 
532  block[j] = level;
533  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF || i > 63)
534  break;
535 
536  UPDATE_CACHE(re, &s->gb);
537  }
538 end:
539  LAST_SKIP_BITS(re, &s->gb, 2);
540  CLOSE_READER(re, &s->gb);
541  s->block_last_index[n] = i;
542  return 0;
543 }
544 
546  int16_t *block, int n)
547 {
548  int level, dc, diff, i, j, run;
549  int component;
550  RLTable *rl;
551  uint8_t *const scantable = s->intra_scantable.permutated;
552  const uint16_t *quant_matrix;
553  const int qscale = s->qscale;
554  int mismatch;
555 
556  /* DC coefficient */
557  if (n < 4) {
558  quant_matrix = s->intra_matrix;
559  component = 0;
560  } else {
561  quant_matrix = s->chroma_intra_matrix;
562  component = (n & 1) + 1;
563  }
564  diff = decode_dc(&s->gb, component);
565  if (diff >= 0xffff)
566  return AVERROR_INVALIDDATA;
567  dc = s->last_dc[component];
568  dc += diff;
569  s->last_dc[component] = dc;
570  block[0] = dc * (1 << (3 - s->intra_dc_precision));
571  ff_tlog(s->avctx, "dc=%d\n", block[0]);
572  mismatch = block[0] ^ 1;
573  i = 0;
574  if (s->intra_vlc_format)
575  rl = &ff_rl_mpeg2;
576  else
577  rl = &ff_rl_mpeg1;
578 
579  {
580  OPEN_READER(re, &s->gb);
581  /* now quantify & encode AC coefficients */
582  for (;;) {
583  UPDATE_CACHE(re, &s->gb);
584  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
585  TEX_VLC_BITS, 2, 0);
586 
587  if (level == 127) {
588  break;
589  } else if (level != 0) {
590  i += run;
591  check_scantable_index(s, i);
592  j = scantable[i];
593  level = (level * qscale * quant_matrix[j]) >> 4;
594  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
595  SHOW_SBITS(re, &s->gb, 1);
596  LAST_SKIP_BITS(re, &s->gb, 1);
597  } else {
598  /* escape */
599  run = SHOW_UBITS(re, &s->gb, 6) + 1;
600  LAST_SKIP_BITS(re, &s->gb, 6);
601  UPDATE_CACHE(re, &s->gb);
602  level = SHOW_SBITS(re, &s->gb, 12);
603  SKIP_BITS(re, &s->gb, 12);
604  i += run;
605  check_scantable_index(s, i);
606  j = scantable[i];
607  if (level < 0) {
608  level = (-level * qscale * quant_matrix[j]) >> 4;
609  level = -level;
610  } else {
611  level = (level * qscale * quant_matrix[j]) >> 4;
612  }
613  }
614 
615  mismatch ^= level;
616  block[j] = level;
617  }
618  CLOSE_READER(re, &s->gb);
619  }
620  block[63] ^= mismatch & 1;
621 
622  s->block_last_index[n] = i;
623  return 0;
624 }
625 
626 /**
627  * Changing this would eat up any speed benefits it has.
628  * Do not use "fast" flag if you need the code to be robust.
629  */
631  int16_t *block, int n)
632 {
633  int level, dc, diff, i, j, run;
634  int component;
635  RLTable *rl;
636  uint8_t *const scantable = s->intra_scantable.permutated;
637  const uint16_t *quant_matrix;
638  const int qscale = s->qscale;
639 
640  /* DC coefficient */
641  if (n < 4) {
642  quant_matrix = s->intra_matrix;
643  component = 0;
644  } else {
645  quant_matrix = s->chroma_intra_matrix;
646  component = (n & 1) + 1;
647  }
648  diff = decode_dc(&s->gb, component);
649  if (diff >= 0xffff)
650  return AVERROR_INVALIDDATA;
651  dc = s->last_dc[component];
652  dc += diff;
653  s->last_dc[component] = dc;
654  block[0] = dc * (1 << (3 - s->intra_dc_precision));
655  i = 0;
656  if (s->intra_vlc_format)
657  rl = &ff_rl_mpeg2;
658  else
659  rl = &ff_rl_mpeg1;
660 
661  {
662  OPEN_READER(re, &s->gb);
663  /* now quantify & encode AC coefficients */
664  for (;;) {
665  UPDATE_CACHE(re, &s->gb);
666  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
667  TEX_VLC_BITS, 2, 0);
668 
669  if (level >= 64 || i > 63) {
670  break;
671  } else if (level != 0) {
672  i += run;
673  j = scantable[i];
674  level = (level * qscale * quant_matrix[j]) >> 4;
675  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
676  SHOW_SBITS(re, &s->gb, 1);
677  LAST_SKIP_BITS(re, &s->gb, 1);
678  } else {
679  /* escape */
680  run = SHOW_UBITS(re, &s->gb, 6) + 1;
681  LAST_SKIP_BITS(re, &s->gb, 6);
682  UPDATE_CACHE(re, &s->gb);
683  level = SHOW_SBITS(re, &s->gb, 12);
684  SKIP_BITS(re, &s->gb, 12);
685  i += run;
686  j = scantable[i];
687  if (level < 0) {
688  level = (-level * qscale * quant_matrix[j]) >> 4;
689  level = -level;
690  } else {
691  level = (level * qscale * quant_matrix[j]) >> 4;
692  }
693  }
694 
695  block[j] = level;
696  }
697  CLOSE_READER(re, &s->gb);
698  }
699 
700  s->block_last_index[n] = i;
701  return 0;
702 }
703 
704 /******************************************/
705 /* decoding */
706 
707 static inline int get_dmv(MpegEncContext *s)
708 {
709  if (get_bits1(&s->gb))
710  return 1 - (get_bits1(&s->gb) << 1);
711  else
712  return 0;
713 }
714 
715 static inline int get_qscale(MpegEncContext *s)
716 {
717  int qscale = get_bits(&s->gb, 5);
718  if (s->q_scale_type)
719  return non_linear_qscale[qscale];
720  else
721  return qscale << 1;
722 }
723 
724 
725 /* motion type (for MPEG-2) */
726 #define MT_FIELD 1
727 #define MT_FRAME 2
728 #define MT_16X8 2
729 #define MT_DMV 3
730 
731 static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
732 {
733  int i, j, k, cbp, val, mb_type, motion_type;
734  const int mb_block_count = 4 + (1 << s->chroma_format);
735  int ret;
736 
737  ff_tlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
738 
739  av_assert2(s->mb_skipped == 0);
740 
741  if (s->mb_skip_run-- != 0) {
742  if (s->pict_type == AV_PICTURE_TYPE_P) {
743  s->mb_skipped = 1;
744  s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
746  } else {
747  int mb_type;
748 
749  if (s->mb_x)
750  mb_type = s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];
751  else
752  // FIXME not sure if this is allowed in MPEG at all
753  mb_type = s->current_picture.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1];
754  if (IS_INTRA(mb_type)) {
755  av_log(s->avctx, AV_LOG_ERROR, "skip with previntra\n");
756  return AVERROR_INVALIDDATA;
757  }
758  s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
759  mb_type | MB_TYPE_SKIP;
760 
761  if ((s->mv[0][0][0] | s->mv[0][0][1] | s->mv[1][0][0] | s->mv[1][0][1]) == 0)
762  s->mb_skipped = 1;
763  }
764 
765  return 0;
766  }
767 
768  switch (s->pict_type) {
769  default:
770  case AV_PICTURE_TYPE_I:
771  if (get_bits1(&s->gb) == 0) {
772  if (get_bits1(&s->gb) == 0) {
774  "invalid mb type in I Frame at %d %d\n",
775  s->mb_x, s->mb_y);
776  return AVERROR_INVALIDDATA;
777  }
778  mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
779  } else {
780  mb_type = MB_TYPE_INTRA;
781  }
782  break;
783  case AV_PICTURE_TYPE_P:
784  mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
785  if (mb_type < 0) {
787  "invalid mb type in P Frame at %d %d\n", s->mb_x, s->mb_y);
788  return AVERROR_INVALIDDATA;
789  }
790  mb_type = ptype2mb_type[mb_type];
791  break;
792  case AV_PICTURE_TYPE_B:
793  mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
794  if (mb_type < 0) {
796  "invalid mb type in B Frame at %d %d\n", s->mb_x, s->mb_y);
797  return AVERROR_INVALIDDATA;
798  }
799  mb_type = btype2mb_type[mb_type];
800  break;
801  }
802  ff_tlog(s->avctx, "mb_type=%x\n", mb_type);
803 // motion_type = 0; /* avoid warning */
804  if (IS_INTRA(mb_type)) {
805  s->bdsp.clear_blocks(s->block[0]);
806 
807  if (!s->chroma_y_shift)
808  s->bdsp.clear_blocks(s->block[6]);
809 
810  /* compute DCT type */
811  // FIXME: add an interlaced_dct coded var?
812  if (s->picture_structure == PICT_FRAME &&
814  s->interlaced_dct = get_bits1(&s->gb);
815 
816  if (IS_QUANT(mb_type))
817  s->qscale = get_qscale(s);
818 
820  /* just parse them */
821  if (s->picture_structure != PICT_FRAME)
822  skip_bits1(&s->gb); /* field select */
823 
824  s->mv[0][0][0] =
825  s->last_mv[0][0][0] =
826  s->last_mv[0][1][0] = mpeg_decode_motion(s, s->mpeg_f_code[0][0],
827  s->last_mv[0][0][0]);
828  s->mv[0][0][1] =
829  s->last_mv[0][0][1] =
830  s->last_mv[0][1][1] = mpeg_decode_motion(s, s->mpeg_f_code[0][1],
831  s->last_mv[0][0][1]);
832 
833  check_marker(&s->gb, "after concealment_motion_vectors");
834  } else {
835  /* reset mv prediction */
836  memset(s->last_mv, 0, sizeof(s->last_mv));
837  }
838  s->mb_intra = 1;
839  // if 1, we memcpy blocks in xvmcvideo
841  ff_xvmc_pack_pblocks(s, -1); // inter are always full blocks
842 
843  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
844  if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
845  for (i = 0; i < 6; i++)
847  } else {
848  for (i = 0; i < mb_block_count; i++)
849  if ((ret = mpeg2_decode_block_intra(s, *s->pblocks[i], i)) < 0)
850  return ret;
851  }
852  } else {
853  for (i = 0; i < 6; i++)
854  if ((ret = mpeg1_decode_block_intra(s, *s->pblocks[i], i)) < 0)
855  return ret;
856  }
857  } else {
858  if (mb_type & MB_TYPE_ZERO_MV) {
859  av_assert2(mb_type & MB_TYPE_CBP);
860 
861  s->mv_dir = MV_DIR_FORWARD;
862  if (s->picture_structure == PICT_FRAME) {
863  if (s->picture_structure == PICT_FRAME
864  && !s->frame_pred_frame_dct)
865  s->interlaced_dct = get_bits1(&s->gb);
866  s->mv_type = MV_TYPE_16X16;
867  } else {
868  s->mv_type = MV_TYPE_FIELD;
869  mb_type |= MB_TYPE_INTERLACED;
870  s->field_select[0][0] = s->picture_structure - 1;
871  }
872 
873  if (IS_QUANT(mb_type))
874  s->qscale = get_qscale(s);
875 
876  s->last_mv[0][0][0] = 0;
877  s->last_mv[0][0][1] = 0;
878  s->last_mv[0][1][0] = 0;
879  s->last_mv[0][1][1] = 0;
880  s->mv[0][0][0] = 0;
881  s->mv[0][0][1] = 0;
882  } else {
883  av_assert2(mb_type & MB_TYPE_L0L1);
884  // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
885  /* get additional motion vector type */
887  motion_type = MT_FRAME;
888  } else {
889  motion_type = get_bits(&s->gb, 2);
890  if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
891  s->interlaced_dct = get_bits1(&s->gb);
892  }
893 
894  if (IS_QUANT(mb_type))
895  s->qscale = get_qscale(s);
896 
897  /* motion vectors */
898  s->mv_dir = (mb_type >> 13) & 3;
899  ff_tlog(s->avctx, "motion_type=%d\n", motion_type);
900  switch (motion_type) {
901  case MT_FRAME: /* or MT_16X8 */
902  if (s->picture_structure == PICT_FRAME) {
903  mb_type |= MB_TYPE_16x16;
904  s->mv_type = MV_TYPE_16X16;
905  for (i = 0; i < 2; i++) {
906  if (USES_LIST(mb_type, i)) {
907  /* MT_FRAME */
908  s->mv[i][0][0] =
909  s->last_mv[i][0][0] =
910  s->last_mv[i][1][0] =
911  mpeg_decode_motion(s, s->mpeg_f_code[i][0],
912  s->last_mv[i][0][0]);
913  s->mv[i][0][1] =
914  s->last_mv[i][0][1] =
915  s->last_mv[i][1][1] =
916  mpeg_decode_motion(s, s->mpeg_f_code[i][1],
917  s->last_mv[i][0][1]);
918  /* full_pel: only for MPEG-1 */
919  if (s->full_pel[i]) {
920  s->mv[i][0][0] *= 2;
921  s->mv[i][0][1] *= 2;
922  }
923  }
924  }
925  } else {
926  mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
927  s->mv_type = MV_TYPE_16X8;
928  for (i = 0; i < 2; i++) {
929  if (USES_LIST(mb_type, i)) {
930  /* MT_16X8 */
931  for (j = 0; j < 2; j++) {
932  s->field_select[i][j] = get_bits1(&s->gb);
933  for (k = 0; k < 2; k++) {
934  val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
935  s->last_mv[i][j][k]);
936  s->last_mv[i][j][k] = val;
937  s->mv[i][j][k] = val;
938  }
939  }
940  }
941  }
942  }
943  break;
944  case MT_FIELD:
945  s->mv_type = MV_TYPE_FIELD;
946  if (s->picture_structure == PICT_FRAME) {
947  mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
948  for (i = 0; i < 2; i++) {
949  if (USES_LIST(mb_type, i)) {
950  for (j = 0; j < 2; j++) {
951  s->field_select[i][j] = get_bits1(&s->gb);
952  val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
953  s->last_mv[i][j][0]);
954  s->last_mv[i][j][0] = val;
955  s->mv[i][j][0] = val;
956  ff_tlog(s->avctx, "fmx=%d\n", val);
957  val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
958  s->last_mv[i][j][1] >> 1);
959  s->last_mv[i][j][1] = 2 * val;
960  s->mv[i][j][1] = val;
961  ff_tlog(s->avctx, "fmy=%d\n", val);
962  }
963  }
964  }
965  } else {
967  mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
968  for (i = 0; i < 2; i++) {
969  if (USES_LIST(mb_type, i)) {
970  s->field_select[i][0] = get_bits1(&s->gb);
971  for (k = 0; k < 2; k++) {
972  val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
973  s->last_mv[i][0][k]);
974  s->last_mv[i][0][k] = val;
975  s->last_mv[i][1][k] = val;
976  s->mv[i][0][k] = val;
977  }
978  }
979  }
980  }
981  break;
982  case MT_DMV:
983  if (s->progressive_sequence){
984  av_log(s->avctx, AV_LOG_ERROR, "MT_DMV in progressive_sequence\n");
985  return AVERROR_INVALIDDATA;
986  }
987  s->mv_type = MV_TYPE_DMV;
988  for (i = 0; i < 2; i++) {
989  if (USES_LIST(mb_type, i)) {
990  int dmx, dmy, mx, my, m;
991  const int my_shift = s->picture_structure == PICT_FRAME;
992 
993  mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
994  s->last_mv[i][0][0]);
995  s->last_mv[i][0][0] = mx;
996  s->last_mv[i][1][0] = mx;
997  dmx = get_dmv(s);
998  my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
999  s->last_mv[i][0][1] >> my_shift);
1000  dmy = get_dmv(s);
1001 
1002 
1003  s->last_mv[i][0][1] = my * (1 << my_shift);
1004  s->last_mv[i][1][1] = my * (1 << my_shift);
1005 
1006  s->mv[i][0][0] = mx;
1007  s->mv[i][0][1] = my;
1008  s->mv[i][1][0] = mx; // not used
1009  s->mv[i][1][1] = my; // not used
1010 
1011  if (s->picture_structure == PICT_FRAME) {
1012  mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
1013 
1014  // m = 1 + 2 * s->top_field_first;
1015  m = s->top_field_first ? 1 : 3;
1016 
1017  /* top -> top pred */
1018  s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1019  s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
1020  m = 4 - m;
1021  s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
1022  s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
1023  } else {
1024  mb_type |= MB_TYPE_16x16;
1025 
1026  s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
1027  s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
1029  s->mv[i][2][1]--;
1030  else
1031  s->mv[i][2][1]++;
1032  }
1033  }
1034  }
1035  break;
1036  default:
1038  "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
1039  return AVERROR_INVALIDDATA;
1040  }
1041  }
1042 
1043  s->mb_intra = 0;
1044  if (HAS_CBP(mb_type)) {
1045  s->bdsp.clear_blocks(s->block[0]);
1046 
1047  cbp = get_vlc2(&s->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
1048  if (mb_block_count > 6) {
1049  cbp *= 1 << mb_block_count - 6;
1050  cbp |= get_bits(&s->gb, mb_block_count - 6);
1051  s->bdsp.clear_blocks(s->block[6]);
1052  }
1053  if (cbp <= 0) {
1055  "invalid cbp %d at %d %d\n", cbp, s->mb_x, s->mb_y);
1056  return AVERROR_INVALIDDATA;
1057  }
1058 
1059  // if 1, we memcpy blocks in xvmcvideo
1061  ff_xvmc_pack_pblocks(s, cbp);
1062 
1063  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1064  if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1065  for (i = 0; i < 6; i++) {
1066  if (cbp & 32)
1068  else
1069  s->block_last_index[i] = -1;
1070  cbp += cbp;
1071  }
1072  } else {
1073  cbp <<= 12 - mb_block_count;
1074 
1075  for (i = 0; i < mb_block_count; i++) {
1076  if (cbp & (1 << 11)) {
1077  if ((ret = mpeg2_decode_block_non_intra(s, *s->pblocks[i], i)) < 0)
1078  return ret;
1079  } else {
1080  s->block_last_index[i] = -1;
1081  }
1082  cbp += cbp;
1083  }
1084  }
1085  } else {
1086  if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1087  for (i = 0; i < 6; i++) {
1088  if (cbp & 32)
1089  mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i);
1090  else
1091  s->block_last_index[i] = -1;
1092  cbp += cbp;
1093  }
1094  } else {
1095  for (i = 0; i < 6; i++) {
1096  if (cbp & 32) {
1097  if ((ret = mpeg1_decode_block_inter(s, *s->pblocks[i], i)) < 0)
1098  return ret;
1099  } else {
1100  s->block_last_index[i] = -1;
1101  }
1102  cbp += cbp;
1103  }
1104  }
1105  }
1106  } else {
1107  for (i = 0; i < 12; i++)
1108  s->block_last_index[i] = -1;
1109  }
1110  }
1111 
1112  s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;
1113 
1114  return 0;
1115 }
1116 
1118 {
1119  Mpeg1Context *s = avctx->priv_data;
1121 
1123 
1124  if ( avctx->codec_tag != AV_RL32("VCR2")
1125  && avctx->codec_tag != AV_RL32("BW10"))
1126  avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
1127  ff_mpv_decode_init(s2, avctx);
1128 
1129  s->mpeg_enc_ctx.avctx = avctx;
1130 
1131  /* we need some permutation to store matrices,
1132  * until the decoder sets the real permutation. */
1133  ff_mpv_idct_init(s2);
1136 
1137  s->mpeg_enc_ctx_allocated = 0;
1139  s->repeat_field = 0;
1140  s->mpeg_enc_ctx.codec_id = avctx->codec->id;
1141  avctx->color_range = AVCOL_RANGE_MPEG;
1142  return 0;
1143 }
1144 
1146  const AVCodecContext *avctx_from)
1147 {
1148  Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data;
1149  MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx;
1150  int err;
1151 
1152  if (avctx == avctx_from ||
1153  !ctx_from->mpeg_enc_ctx_allocated ||
1154  !s1->context_initialized)
1155  return 0;
1156 
1157  err = ff_mpeg_update_thread_context(avctx, avctx_from);
1158  if (err)
1159  return err;
1160 
1161  if (!ctx->mpeg_enc_ctx_allocated)
1162  memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext));
1163 
1164  if (!(s->pict_type == AV_PICTURE_TYPE_B || s->low_delay))
1165  s->picture_number++;
1166 
1167  return 0;
1168 }
1169 
1170 static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1171  const uint8_t *new_perm)
1172 {
1173  uint16_t temp_matrix[64];
1174  int i;
1175 
1176  memcpy(temp_matrix, matrix, 64 * sizeof(uint16_t));
1177 
1178  for (i = 0; i < 64; i++)
1179  matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1180 }
1181 
1183 #if CONFIG_MPEG1_XVMC_HWACCEL
1185 #endif
1186 #if CONFIG_MPEG1_VDPAU_DECODER && FF_API_VDPAU
1188 #endif
1189 #if CONFIG_MPEG1_VDPAU_HWACCEL
1191 #endif
1194 };
1195 
1197 #if CONFIG_MPEG2_XVMC_HWACCEL
1199 #endif
1200 #if CONFIG_MPEG_VDPAU_DECODER && FF_API_VDPAU
1202 #endif
1203 #if CONFIG_MPEG2_VDPAU_HWACCEL
1205 #endif
1206 #if CONFIG_MPEG2_DXVA2_HWACCEL
1208 #endif
1209 #if CONFIG_MPEG2_D3D11VA_HWACCEL
1211 #endif
1212 #if CONFIG_MPEG2_VAAPI_HWACCEL
1214 #endif
1215 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
1217 #endif
1220 };
1221 
1222 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
1225 };
1226 
1227 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
1230 };
1231 
1232 #if FF_API_VDPAU
1233 static inline int uses_vdpau(AVCodecContext *avctx) {
1234  return avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG1 || avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG2;
1235 }
1236 #endif
1237 
1239 {
1240  Mpeg1Context *s1 = avctx->priv_data;
1241  MpegEncContext *s = &s1->mpeg_enc_ctx;
1242  const enum AVPixelFormat *pix_fmts;
1243 
1244  if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
1245  return AV_PIX_FMT_GRAY8;
1246 
1247  if (s->chroma_format < 2)
1248  pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
1251  else if (s->chroma_format == 2)
1252  pix_fmts = mpeg12_pixfmt_list_422;
1253  else
1254  pix_fmts = mpeg12_pixfmt_list_444;
1255 
1256  return ff_thread_get_format(avctx, pix_fmts);
1257 }
1258 
1260 {
1261  // until then pix_fmt may be changed right after codec init
1262  if (avctx->hwaccel
1263 #if FF_API_VDPAU
1264  || uses_vdpau(avctx)
1265 #endif
1266  )
1267  if (avctx->idct_algo == FF_IDCT_AUTO)
1268  avctx->idct_algo = FF_IDCT_SIMPLE;
1269 
1270  if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
1271  Mpeg1Context *s1 = avctx->priv_data;
1272  MpegEncContext *s = &s1->mpeg_enc_ctx;
1273 
1274  s->pack_pblocks = 1;
1275 #if FF_API_XVMC
1277  avctx->xvmc_acceleration = 2;
1279 #endif /* FF_API_XVMC */
1280  }
1281 }
1282 
1283 /* Call this function when we know all parameters.
1284  * It may be called in different places for MPEG-1 and MPEG-2. */
1286 {
1287  Mpeg1Context *s1 = avctx->priv_data;
1288  MpegEncContext *s = &s1->mpeg_enc_ctx;
1289  uint8_t old_permutation[64];
1290  int ret;
1291 
1292  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1293  // MPEG-1 aspect
1294  AVRational aspect_inv = av_d2q(ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1295  avctx->sample_aspect_ratio = (AVRational) { aspect_inv.den, aspect_inv.num };
1296  } else { // MPEG-2
1297  // MPEG-2 aspect
1298  if (s->aspect_ratio_info > 1) {
1299  AVRational dar =
1301  (AVRational) { s1->pan_scan.width,
1302  s1->pan_scan.height }),
1303  (AVRational) { s->width, s->height });
1304 
1305  /* We ignore the spec here and guess a bit as reality does not
1306  * match the spec, see for example res_change_ffmpeg_aspect.ts
1307  * and sequence-display-aspect.mpg.
1308  * issue1613, 621, 562 */
1309  if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1310  (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
1311  av_cmp_q(dar, (AVRational) { 16, 9 }))) {
1314  (AVRational) { s->width, s->height });
1315  } else {
1318  (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
1319 // issue1613 4/3 16/9 -> 16/9
1320 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1321 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
1322 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1323  ff_dlog(avctx, "aspect A %d/%d\n",
1326  ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1328  }
1329  } else {
1332  }
1333  } // MPEG-2
1334 
1335  if (av_image_check_sar(s->width, s->height,
1336  avctx->sample_aspect_ratio) < 0) {
1337  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1338  avctx->sample_aspect_ratio.num,
1339  avctx->sample_aspect_ratio.den);
1340  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1341  }
1342 
1343  if ((s1->mpeg_enc_ctx_allocated == 0) ||
1344  avctx->coded_width != s->width ||
1345  avctx->coded_height != s->height ||
1346  s1->save_width != s->width ||
1347  s1->save_height != s->height ||
1349  (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
1350  0) {
1351  if (s1->mpeg_enc_ctx_allocated) {
1352  ParseContext pc = s->parse_context;
1353  s->parse_context.buffer = 0;
1354  ff_mpv_common_end(s);
1355  s->parse_context = pc;
1356  s1->mpeg_enc_ctx_allocated = 0;
1357  }
1358 
1359  ret = ff_set_dimensions(avctx, s->width, s->height);
1360  if (ret < 0)
1361  return ret;
1362 
1363  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
1364  avctx->rc_max_rate = s->bit_rate;
1365  } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
1366  (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
1367  avctx->bit_rate = s->bit_rate;
1368  }
1370  s1->save_width = s->width;
1371  s1->save_height = s->height;
1373 
1374  /* low_delay may be forced, in this case we will have B-frames
1375  * that behave like P-frames. */
1376  avctx->has_b_frames = !s->low_delay;
1377 
1378  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1379  // MPEG-1 fps
1381  avctx->ticks_per_frame = 1;
1382 
1384  } else { // MPEG-2
1385  // MPEG-2 fps
1387  &s->avctx->framerate.den,
1390  1 << 30);
1391  avctx->ticks_per_frame = 2;
1392 
1393  switch (s->chroma_format) {
1394  case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
1395  case 2:
1396  case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
1397  default: av_assert0(0);
1398  }
1399  } // MPEG-2
1400 
1401  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1402  setup_hwaccel_for_pixfmt(avctx);
1403 
1404  /* Quantization matrices may need reordering
1405  * if DCT permutation is changed. */
1406  memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1407 
1408  ff_mpv_idct_init(s);
1409  if ((ret = ff_mpv_common_init(s)) < 0)
1410  return ret;
1411 
1412  quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
1413  quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
1416 
1417  s1->mpeg_enc_ctx_allocated = 1;
1418  }
1419  return 0;
1420 }
1421 
1423  int buf_size)
1424 {
1425  Mpeg1Context *s1 = avctx->priv_data;
1426  MpegEncContext *s = &s1->mpeg_enc_ctx;
1427  int ref, f_code, vbv_delay;
1428 
1429  init_get_bits(&s->gb, buf, buf_size * 8);
1430 
1431  ref = get_bits(&s->gb, 10); /* temporal ref */
1432  s->pict_type = get_bits(&s->gb, 3);
1433  if (s->pict_type == 0 || s->pict_type > 3)
1434  return AVERROR_INVALIDDATA;
1435 
1436  vbv_delay = get_bits(&s->gb, 16);
1437  s->vbv_delay = vbv_delay;
1438  if (s->pict_type == AV_PICTURE_TYPE_P ||
1439  s->pict_type == AV_PICTURE_TYPE_B) {
1440  s->full_pel[0] = get_bits1(&s->gb);
1441  f_code = get_bits(&s->gb, 3);
1442  if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1443  return AVERROR_INVALIDDATA;
1444  f_code += !f_code;
1445  s->mpeg_f_code[0][0] = f_code;
1446  s->mpeg_f_code[0][1] = f_code;
1447  }
1448  if (s->pict_type == AV_PICTURE_TYPE_B) {
1449  s->full_pel[1] = get_bits1(&s->gb);
1450  f_code = get_bits(&s->gb, 3);
1451  if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1452  return AVERROR_INVALIDDATA;
1453  f_code += !f_code;
1454  s->mpeg_f_code[1][0] = f_code;
1455  s->mpeg_f_code[1][1] = f_code;
1456  }
1459 
1460  if (avctx->debug & FF_DEBUG_PICT_INFO)
1461  av_log(avctx, AV_LOG_DEBUG,
1462  "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1463 
1464  s->y_dc_scale = 8;
1465  s->c_dc_scale = 8;
1466  return 0;
1467 }
1468 
1470 {
1471  MpegEncContext *s = &s1->mpeg_enc_ctx;
1472  int horiz_size_ext, vert_size_ext;
1473  int bit_rate_ext;
1474 
1475  skip_bits(&s->gb, 1); /* profile and level esc*/
1476  s->avctx->profile = get_bits(&s->gb, 3);
1477  s->avctx->level = get_bits(&s->gb, 4);
1478  s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1479  s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1480 
1481  if (!s->chroma_format) {
1482  s->chroma_format = 1;
1483  av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1484  }
1485 
1486  horiz_size_ext = get_bits(&s->gb, 2);
1487  vert_size_ext = get_bits(&s->gb, 2);
1488  s->width |= (horiz_size_ext << 12);
1489  s->height |= (vert_size_ext << 12);
1490  bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1491  s->bit_rate += (bit_rate_ext << 18) * 400LL;
1492  check_marker(&s->gb, "after bit rate extension");
1493  s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1494 
1495  s->low_delay = get_bits1(&s->gb);
1497  s->low_delay = 1;
1498 
1499  s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1500  s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1501 
1502  ff_dlog(s->avctx, "sequence extension\n");
1504 
1505  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1507  "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n",
1509  s->avctx->rc_buffer_size, s->bit_rate);
1510 }
1511 
1513 {
1514  MpegEncContext *s = &s1->mpeg_enc_ctx;
1515  int color_description, w, h;
1516 
1517  skip_bits(&s->gb, 3); /* video format */
1518  color_description = get_bits1(&s->gb);
1519  if (color_description) {
1520  s->avctx->color_primaries = get_bits(&s->gb, 8);
1521  s->avctx->color_trc = get_bits(&s->gb, 8);
1522  s->avctx->colorspace = get_bits(&s->gb, 8);
1523  }
1524  w = get_bits(&s->gb, 14);
1525  skip_bits(&s->gb, 1); // marker
1526  h = get_bits(&s->gb, 14);
1527  // remaining 3 bits are zero padding
1528 
1529  s1->pan_scan.width = 16 * w;
1530  s1->pan_scan.height = 16 * h;
1531 
1532  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1533  av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1534 }
1535 
1537 {
1538  MpegEncContext *s = &s1->mpeg_enc_ctx;
1539  int i, nofco;
1540 
1541  nofco = 1;
1542  if (s->progressive_sequence) {
1543  if (s->repeat_first_field) {
1544  nofco++;
1545  if (s->top_field_first)
1546  nofco++;
1547  }
1548  } else {
1549  if (s->picture_structure == PICT_FRAME) {
1550  nofco++;
1551  if (s->repeat_first_field)
1552  nofco++;
1553  }
1554  }
1555  for (i = 0; i < nofco; i++) {
1556  s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1557  skip_bits(&s->gb, 1); // marker
1558  s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1559  skip_bits(&s->gb, 1); // marker
1560  }
1561 
1562  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1564  "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1565  s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1566  s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1567  s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1568 }
1569 
1570 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1571  uint16_t matrix1[64], int intra)
1572 {
1573  int i;
1574 
1575  for (i = 0; i < 64; i++) {
1576  int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1577  int v = get_bits(&s->gb, 8);
1578  if (v == 0) {
1579  av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1580  return AVERROR_INVALIDDATA;
1581  }
1582  if (intra && i == 0 && v != 8) {
1583  av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1584  v = 8; // needed by pink.mpg / issue1046
1585  }
1586  matrix0[j] = v;
1587  if (matrix1)
1588  matrix1[j] = v;
1589  }
1590  return 0;
1591 }
1592 
1594 {
1595  ff_dlog(s->avctx, "matrix extension\n");
1596 
1597  if (get_bits1(&s->gb))
1599  if (get_bits1(&s->gb))
1601  if (get_bits1(&s->gb))
1603  if (get_bits1(&s->gb))
1605 }
1606 
1608 {
1609  MpegEncContext *s = &s1->mpeg_enc_ctx;
1610 
1611  s->full_pel[0] = s->full_pel[1] = 0;
1612  s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1613  s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1614  s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1615  s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1616  if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1618  "Missing picture start code, guessing missing values\n");
1619  if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1620  if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1622  else
1624  } else
1628  }
1629  s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1630  s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1631  s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1632  s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1633 
1634  s->intra_dc_precision = get_bits(&s->gb, 2);
1635  s->picture_structure = get_bits(&s->gb, 2);
1636  s->top_field_first = get_bits1(&s->gb);
1637  s->frame_pred_frame_dct = get_bits1(&s->gb);
1639  s->q_scale_type = get_bits1(&s->gb);
1640  s->intra_vlc_format = get_bits1(&s->gb);
1641  s->alternate_scan = get_bits1(&s->gb);
1642  s->repeat_first_field = get_bits1(&s->gb);
1643  s->chroma_420_type = get_bits1(&s->gb);
1644  s->progressive_frame = get_bits1(&s->gb);
1645 
1646  if (s->alternate_scan) {
1649  } else {
1652  }
1653 
1654  /* composite display not parsed */
1655  ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1656  ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1657  ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1658  ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1659  ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1660  ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1661  ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1662  ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1663  ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1664 }
1665 
1666 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1667 {
1668  AVCodecContext *avctx = s->avctx;
1669  Mpeg1Context *s1 = (Mpeg1Context *) s;
1670  int ret;
1671 
1672  /* start frame decoding */
1673  if (s->first_field || s->picture_structure == PICT_FRAME) {
1674  AVFrameSideData *pan_scan;
1675 
1676  if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1677  return ret;
1678 
1680 
1681  /* first check if we must repeat the frame */
1683  if (s->repeat_first_field) {
1684  if (s->progressive_sequence) {
1685  if (s->top_field_first)
1687  else
1689  } else if (s->progressive_frame) {
1691  }
1692  }
1693 
1696  sizeof(s1->pan_scan));
1697  if (!pan_scan)
1698  return AVERROR(ENOMEM);
1699  memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1700 
1701  if (s1->a53_caption) {
1704  s1->a53_caption_size);
1705  if (sd)
1706  memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1707  av_freep(&s1->a53_caption);
1709  }
1710 
1711  if (s1->has_stereo3d) {
1713  if (!stereo)
1714  return AVERROR(ENOMEM);
1715 
1716  *stereo = s1->stereo3d;
1717  s1->has_stereo3d = 0;
1718  }
1719 
1720  if (s1->has_afd) {
1721  AVFrameSideData *sd =
1723  AV_FRAME_DATA_AFD, 1);
1724  if (!sd)
1725  return AVERROR(ENOMEM);
1726 
1727  *sd->data = s1->afd;
1728  s1->has_afd = 0;
1729  }
1730 
1732  ff_thread_finish_setup(avctx);
1733  } else { // second field
1734  int i;
1735 
1736  if (!s->current_picture_ptr) {
1737  av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1738  return AVERROR_INVALIDDATA;
1739  }
1740 
1741  if (s->avctx->hwaccel &&
1743  if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
1744  av_log(avctx, AV_LOG_ERROR,
1745  "hardware accelerator failed to decode first field\n");
1746  return ret;
1747  }
1748  }
1749 
1750  for (i = 0; i < 4; i++) {
1751  s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1753  s->current_picture.f->data[i] +=
1754  s->current_picture_ptr->f->linesize[i];
1755  }
1756  }
1757 
1758  if (avctx->hwaccel) {
1759  if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1760  return ret;
1761  }
1762 
1763  return 0;
1764 }
1765 
1766 #define DECODE_SLICE_ERROR -1
1767 #define DECODE_SLICE_OK 0
1768 
1769 /**
1770  * Decode a slice.
1771  * MpegEncContext.mb_y must be set to the MB row from the startcode.
1772  * @return DECODE_SLICE_ERROR if the slice is damaged,
1773  * DECODE_SLICE_OK if this slice is OK
1774  */
1775 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1776  const uint8_t **buf, int buf_size)
1777 {
1778  AVCodecContext *avctx = s->avctx;
1779  const int lowres = s->avctx->lowres;
1780  const int field_pic = s->picture_structure != PICT_FRAME;
1781  int ret;
1782 
1783  s->resync_mb_x =
1784  s->resync_mb_y = -1;
1785 
1786  av_assert0(mb_y < s->mb_height);
1787 
1788  init_get_bits(&s->gb, *buf, buf_size * 8);
1789  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1790  skip_bits(&s->gb, 3);
1791 
1793  s->interlaced_dct = 0;
1794 
1795  s->qscale = get_qscale(s);
1796 
1797  if (s->qscale == 0) {
1798  av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1799  return AVERROR_INVALIDDATA;
1800  }
1801 
1802  /* extra slice info */
1803  if (skip_1stop_8data_bits(&s->gb) < 0)
1804  return AVERROR_INVALIDDATA;
1805 
1806  s->mb_x = 0;
1807 
1808  if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1809  skip_bits1(&s->gb);
1810  } else {
1811  while (get_bits_left(&s->gb) > 0) {
1812  int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1813  MBINCR_VLC_BITS, 2);
1814  if (code < 0) {
1815  av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1816  return AVERROR_INVALIDDATA;
1817  }
1818  if (code >= 33) {
1819  if (code == 33)
1820  s->mb_x += 33;
1821  /* otherwise, stuffing, nothing to do */
1822  } else {
1823  s->mb_x += code;
1824  break;
1825  }
1826  }
1827  }
1828 
1829  if (s->mb_x >= (unsigned) s->mb_width) {
1830  av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1831  return AVERROR_INVALIDDATA;
1832  }
1833 
1834  if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1835  const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1836  int start_code = -1;
1837  buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1838  if (buf_end < *buf + buf_size)
1839  buf_end -= 4;
1840  s->mb_y = mb_y;
1841  if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1842  return DECODE_SLICE_ERROR;
1843  *buf = buf_end;
1844  return DECODE_SLICE_OK;
1845  }
1846 
1847  s->resync_mb_x = s->mb_x;
1848  s->resync_mb_y = s->mb_y = mb_y;
1849  s->mb_skip_run = 0;
1851 
1852  if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1853  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1855  "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",
1856  s->qscale,
1857  s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1858  s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1859  s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1860  (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1861  (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1862  s->progressive_sequence ? "ps" : "",
1863  s->progressive_frame ? "pf" : "",
1864  s->alternate_scan ? "alt" : "",
1865  s->top_field_first ? "top" : "",
1869  s->repeat_first_field, s->chroma_420_type ? "420" : "");
1870  }
1871  }
1872 
1873  for (;;) {
1874  // If 1, we memcpy blocks in xvmcvideo.
1876  ff_xvmc_init_block(s); // set s->block
1877 
1878  if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1879  return ret;
1880 
1881  // Note motion_val is normally NULL unless we want to extract the MVs.
1882  if (s->current_picture.motion_val[0] && !s->encoding) {
1883  const int wrap = s->b8_stride;
1884  int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1885  int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1886  int motion_x, motion_y, dir, i;
1887 
1888  for (i = 0; i < 2; i++) {
1889  for (dir = 0; dir < 2; dir++) {
1890  if (s->mb_intra ||
1891  (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1892  motion_x = motion_y = 0;
1893  } else if (s->mv_type == MV_TYPE_16X16 ||
1894  (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1895  motion_x = s->mv[dir][0][0];
1896  motion_y = s->mv[dir][0][1];
1897  } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1898  motion_x = s->mv[dir][i][0];
1899  motion_y = s->mv[dir][i][1];
1900  }
1901 
1902  s->current_picture.motion_val[dir][xy][0] = motion_x;
1903  s->current_picture.motion_val[dir][xy][1] = motion_y;
1904  s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1905  s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1906  s->current_picture.ref_index [dir][b8_xy] =
1907  s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1908  av_assert2(s->field_select[dir][i] == 0 ||
1909  s->field_select[dir][i] == 1);
1910  }
1911  xy += wrap;
1912  b8_xy += 2;
1913  }
1914  }
1915 
1916  s->dest[0] += 16 >> lowres;
1917  s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1918  s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1919 
1920  ff_mpv_decode_mb(s, s->block);
1921 
1922  if (++s->mb_x >= s->mb_width) {
1923  const int mb_size = 16 >> s->avctx->lowres;
1924 
1925  ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1927 
1928  s->mb_x = 0;
1929  s->mb_y += 1 << field_pic;
1930 
1931  if (s->mb_y >= s->mb_height) {
1932  int left = get_bits_left(&s->gb);
1933  int is_d10 = s->chroma_format == 2 &&
1934  s->pict_type == AV_PICTURE_TYPE_I &&
1935  avctx->profile == 0 && avctx->level == 5 &&
1936  s->intra_dc_precision == 2 &&
1937  s->q_scale_type == 1 && s->alternate_scan == 0 &&
1938  s->progressive_frame == 0
1939  /* vbv_delay == 0xBBB || 0xE10 */;
1940 
1941  if (left >= 32 && !is_d10) {
1942  GetBitContext gb = s->gb;
1943  align_get_bits(&gb);
1944  if (show_bits(&gb, 24) == 0x060E2B) {
1945  av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1946  is_d10 = 1;
1947  }
1948  }
1949 
1950  if (left < 0 ||
1951  (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1952  ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1953  av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n",
1954  left, left>0 ? show_bits(&s->gb, FFMIN(left, 23)) : 0);
1955  return AVERROR_INVALIDDATA;
1956  } else
1957  goto eos;
1958  }
1959  // There are some files out there which are missing the last slice
1960  // in cases where the slice is completely outside the visible
1961  // area, we detect this here instead of running into the end expecting
1962  // more data
1963  if (s->mb_y >= ((s->height + 15) >> 4) &&
1964  !s->progressive_sequence &&
1965  get_bits_left(&s->gb) <= 8 &&
1966  get_bits_left(&s->gb) >= 0 &&
1967  s->mb_skip_run == -1 &&
1968  show_bits(&s->gb, 8) == 0)
1969  goto eos;
1970 
1972  }
1973 
1974  /* skip mb handling */
1975  if (s->mb_skip_run == -1) {
1976  /* read increment again */
1977  s->mb_skip_run = 0;
1978  for (;;) {
1979  int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1980  MBINCR_VLC_BITS, 2);
1981  if (code < 0) {
1982  av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1983  return AVERROR_INVALIDDATA;
1984  }
1985  if (code >= 33) {
1986  if (code == 33) {
1987  s->mb_skip_run += 33;
1988  } else if (code == 35) {
1989  if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1990  av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1991  return AVERROR_INVALIDDATA;
1992  }
1993  goto eos; /* end of slice */
1994  }
1995  /* otherwise, stuffing, nothing to do */
1996  } else {
1997  s->mb_skip_run += code;
1998  break;
1999  }
2000  }
2001  if (s->mb_skip_run) {
2002  int i;
2003  if (s->pict_type == AV_PICTURE_TYPE_I) {
2005  "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
2006  return AVERROR_INVALIDDATA;
2007  }
2008 
2009  /* skip mb */
2010  s->mb_intra = 0;
2011  for (i = 0; i < 12; i++)
2012  s->block_last_index[i] = -1;
2014  s->mv_type = MV_TYPE_16X16;
2015  else
2016  s->mv_type = MV_TYPE_FIELD;
2017  if (s->pict_type == AV_PICTURE_TYPE_P) {
2018  /* if P type, zero motion vector is implied */
2019  s->mv_dir = MV_DIR_FORWARD;
2020  s->mv[0][0][0] = s->mv[0][0][1] = 0;
2021  s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
2022  s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
2023  s->field_select[0][0] = (s->picture_structure - 1) & 1;
2024  } else {
2025  /* if B type, reuse previous vectors and directions */
2026  s->mv[0][0][0] = s->last_mv[0][0][0];
2027  s->mv[0][0][1] = s->last_mv[0][0][1];
2028  s->mv[1][0][0] = s->last_mv[1][0][0];
2029  s->mv[1][0][1] = s->last_mv[1][0][1];
2030  }
2031  }
2032  }
2033  }
2034 eos: // end of slice
2035  if (get_bits_left(&s->gb) < 0) {
2036  av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
2037  return AVERROR_INVALIDDATA;
2038  }
2039  *buf += (get_bits_count(&s->gb) - 1) / 8;
2040  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);
2041  return 0;
2042 }
2043 
2045 {
2046  MpegEncContext *s = *(void **) arg;
2047  const uint8_t *buf = s->gb.buffer;
2048  int mb_y = s->start_mb_y;
2049  const int field_pic = s->picture_structure != PICT_FRAME;
2050 
2051  s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
2052 
2053  for (;;) {
2054  uint32_t start_code;
2055  int ret;
2056 
2057  ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2058  emms_c();
2059  ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2060  ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2061  s->start_mb_y, s->end_mb_y, s->er.error_count);
2062  if (ret < 0) {
2063  if (c->err_recognition & AV_EF_EXPLODE)
2064  return ret;
2065  if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2067  s->mb_x, s->mb_y,
2069  } else {
2071  s->mb_x - 1, s->mb_y,
2073  }
2074 
2075  if (s->mb_y == s->end_mb_y)
2076  return 0;
2077 
2078  start_code = -1;
2079  buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2080  mb_y = start_code - SLICE_MIN_START_CODE;
2081  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2082  mb_y += (*buf&0xE0)<<2;
2083  mb_y <<= field_pic;
2085  mb_y++;
2086  if (mb_y < 0 || mb_y >= s->end_mb_y)
2087  return AVERROR_INVALIDDATA;
2088  }
2089 }
2090 
2091 /**
2092  * Handle slice ends.
2093  * @return 1 if it seems to be the last slice
2094  */
2095 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2096 {
2097  Mpeg1Context *s1 = avctx->priv_data;
2098  MpegEncContext *s = &s1->mpeg_enc_ctx;
2099 
2101  return 0;
2102 
2103  if (s->avctx->hwaccel) {
2104  int ret = s->avctx->hwaccel->end_frame(s->avctx);
2105  if (ret < 0) {
2106  av_log(avctx, AV_LOG_ERROR,
2107  "hardware accelerator failed to decode picture\n");
2108  return ret;
2109  }
2110  }
2111 
2112  /* end of slice reached */
2113  if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2114  /* end of image */
2115 
2116  ff_er_frame_end(&s->er);
2117 
2118  ff_mpv_frame_end(s);
2119 
2120  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2121  int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2122  if (ret < 0)
2123  return ret;
2126  } else {
2127  if (avctx->active_thread_type & FF_THREAD_FRAME)
2128  s->picture_number++;
2129  /* latency of 1 frame for I- and P-frames */
2130  /* XXX: use another variable than picture_number */
2131  if (s->last_picture_ptr) {
2132  int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2133  if (ret < 0)
2134  return ret;
2137  }
2138  }
2139 
2140  return 1;
2141  } else {
2142  return 0;
2143  }
2144 }
2145 
2147  const uint8_t *buf, int buf_size)
2148 {
2149  Mpeg1Context *s1 = avctx->priv_data;
2150  MpegEncContext *s = &s1->mpeg_enc_ctx;
2151  int width, height;
2152  int i, v, j;
2153 
2154  init_get_bits(&s->gb, buf, buf_size * 8);
2155 
2156  width = get_bits(&s->gb, 12);
2157  height = get_bits(&s->gb, 12);
2158  if (width == 0 || height == 0) {
2159  av_log(avctx, AV_LOG_WARNING,
2160  "Invalid horizontal or vertical size value.\n");
2162  return AVERROR_INVALIDDATA;
2163  }
2164  s->aspect_ratio_info = get_bits(&s->gb, 4);
2165  if (s->aspect_ratio_info == 0) {
2166  av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2168  return AVERROR_INVALIDDATA;
2169  }
2170  s->frame_rate_index = get_bits(&s->gb, 4);
2171  if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2172  av_log(avctx, AV_LOG_WARNING,
2173  "frame_rate_index %d is invalid\n", s->frame_rate_index);
2174  s->frame_rate_index = 1;
2175  }
2176  s->bit_rate = get_bits(&s->gb, 18) * 400LL;
2177  if (check_marker(&s->gb, "in sequence header") == 0) {
2178  return AVERROR_INVALIDDATA;
2179  }
2180 
2181  s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2182  skip_bits(&s->gb, 1);
2183 
2184  /* get matrix */
2185  if (get_bits1(&s->gb)) {
2187  } else {
2188  for (i = 0; i < 64; i++) {
2189  j = s->idsp.idct_permutation[i];
2191  s->intra_matrix[j] = v;
2192  s->chroma_intra_matrix[j] = v;
2193  }
2194  }
2195  if (get_bits1(&s->gb)) {
2197  } else {
2198  for (i = 0; i < 64; i++) {
2199  int j = s->idsp.idct_permutation[i];
2201  s->inter_matrix[j] = v;
2202  s->chroma_inter_matrix[j] = v;
2203  }
2204  }
2205 
2206  if (show_bits(&s->gb, 23) != 0) {
2207  av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2208  return AVERROR_INVALIDDATA;
2209  }
2210 
2211  s->width = width;
2212  s->height = height;
2213 
2214  /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2215  s->progressive_sequence = 1;
2216  s->progressive_frame = 1;
2218  s->first_field = 0;
2219  s->frame_pred_frame_dct = 1;
2220  s->chroma_format = 1;
2221  s->codec_id =
2223  s->out_format = FMT_MPEG1;
2224  s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2226  s->low_delay = 1;
2227 
2228  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2229  av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
2231 
2232  return 0;
2233 }
2234 
2236 {
2237  Mpeg1Context *s1 = avctx->priv_data;
2238  MpegEncContext *s = &s1->mpeg_enc_ctx;
2239  int i, v, ret;
2240 
2241  /* start new MPEG-1 context decoding */
2242  s->out_format = FMT_MPEG1;
2243  if (s1->mpeg_enc_ctx_allocated) {
2244  ff_mpv_common_end(s);
2245  s1->mpeg_enc_ctx_allocated = 0;
2246  }
2247  s->width = avctx->coded_width;
2248  s->height = avctx->coded_height;
2249  avctx->has_b_frames = 0; // true?
2250  s->low_delay = 1;
2251 
2252  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2253  setup_hwaccel_for_pixfmt(avctx);
2254 
2255  ff_mpv_idct_init(s);
2256  if ((ret = ff_mpv_common_init(s)) < 0)
2257  return ret;
2258  s1->mpeg_enc_ctx_allocated = 1;
2259 
2260  for (i = 0; i < 64; i++) {
2261  int j = s->idsp.idct_permutation[i];
2263  s->intra_matrix[j] = v;
2264  s->chroma_intra_matrix[j] = v;
2265 
2267  s->inter_matrix[j] = v;
2268  s->chroma_inter_matrix[j] = v;
2269  }
2270 
2271  s->progressive_sequence = 1;
2272  s->progressive_frame = 1;
2274  s->first_field = 0;
2275  s->frame_pred_frame_dct = 1;
2276  s->chroma_format = 1;
2277  if (s->codec_tag == AV_RL32("BW10")) {
2279  } else {
2280  s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2282  }
2283  s1->save_width = s->width;
2284  s1->save_height = s->height;
2286  return 0;
2287 }
2288 
2290  const uint8_t *p, int buf_size)
2291 {
2292  Mpeg1Context *s1 = avctx->priv_data;
2293 
2294  if (buf_size >= 6 &&
2295  p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2296  p[4] == 3 && (p[5] & 0x40)) {
2297  /* extract A53 Part 4 CC data */
2298  int cc_count = p[5] & 0x1f;
2299  if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2300  av_freep(&s1->a53_caption);
2301  s1->a53_caption_size = cc_count * 3;
2303  if (s1->a53_caption)
2304  memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2305  }
2306  return 1;
2307  } else if (buf_size >= 11 &&
2308  p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2309  /* extract DVD CC data */
2310  int cc_count = 0;
2311  int i;
2312  // There is a caption count field in the data, but it is often
2313  // incorect. So count the number of captions present.
2314  for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2315  cc_count++;
2316  // Transform the DVD format into A53 Part 4 format
2317  if (cc_count > 0) {
2318  av_freep(&s1->a53_caption);
2319  s1->a53_caption_size = cc_count * 6;
2321  if (s1->a53_caption) {
2322  uint8_t field1 = !!(p[4] & 0x80);
2323  uint8_t *cap = s1->a53_caption;
2324  p += 5;
2325  for (i = 0; i < cc_count; i++) {
2326  cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2327  cap[1] = p[1];
2328  cap[2] = p[2];
2329  cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2330  cap[4] = p[4];
2331  cap[5] = p[5];
2332  cap += 6;
2333  p += 6;
2334  }
2335  }
2336  }
2337  return 1;
2338  }
2339  return 0;
2340 }
2341 
2343  const uint8_t *p, int buf_size)
2344 {
2345  Mpeg1Context *s = avctx->priv_data;
2346  const uint8_t *buf_end = p + buf_size;
2347  Mpeg1Context *s1 = avctx->priv_data;
2348 
2349 #if 0
2350  int i;
2351  for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2352  av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2353  }
2354  av_log(avctx, AV_LOG_ERROR, "\n");
2355 #endif
2356 
2357  if (buf_size > 29){
2358  int i;
2359  for(i=0; i<20; i++)
2360  if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2361  s->tmpgexs= 1;
2362  }
2363  }
2364  /* we parse the DTG active format information */
2365  if (buf_end - p >= 5 &&
2366  p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2367  int flags = p[4];
2368  p += 5;
2369  if (flags & 0x80) {
2370  /* skip event id */
2371  p += 2;
2372  }
2373  if (flags & 0x40) {
2374  if (buf_end - p < 1)
2375  return;
2376 #if FF_API_AFD
2378  avctx->dtg_active_format = p[0] & 0x0f;
2380 #endif /* FF_API_AFD */
2381  s1->has_afd = 1;
2382  s1->afd = p[0] & 0x0f;
2383  }
2384  } else if (buf_end - p >= 6 &&
2385  p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2386  p[4] == 0x03) { // S3D_video_format_length
2387  // the 0x7F mask ignores the reserved_bit value
2388  const uint8_t S3D_video_format_type = p[5] & 0x7F;
2389 
2390  if (S3D_video_format_type == 0x03 ||
2391  S3D_video_format_type == 0x04 ||
2392  S3D_video_format_type == 0x08 ||
2393  S3D_video_format_type == 0x23) {
2394 
2395  s1->has_stereo3d = 1;
2396 
2397  switch (S3D_video_format_type) {
2398  case 0x03:
2400  break;
2401  case 0x04:
2403  break;
2404  case 0x08:
2406  break;
2407  case 0x23:
2409  break;
2410  }
2411  }
2412  } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2413  return;
2414  }
2415 }
2416 
2417 static void mpeg_decode_gop(AVCodecContext *avctx,
2418  const uint8_t *buf, int buf_size)
2419 {
2420  Mpeg1Context *s1 = avctx->priv_data;
2421  MpegEncContext *s = &s1->mpeg_enc_ctx;
2422  int broken_link;
2423  int64_t tc;
2424 
2425  init_get_bits(&s->gb, buf, buf_size * 8);
2426 
2427  tc = avctx->timecode_frame_start = get_bits(&s->gb, 25);
2428 
2429  s->closed_gop = get_bits1(&s->gb);
2430  /* broken_link indicates that after editing the
2431  * reference frames of the first B-Frames after GOP I-Frame
2432  * are missing (open gop) */
2433  broken_link = get_bits1(&s->gb);
2434 
2435  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2436  char tcbuf[AV_TIMECODE_STR_SIZE];
2439  "GOP (%s) closed_gop=%d broken_link=%d\n",
2440  tcbuf, s->closed_gop, broken_link);
2441  }
2442 }
2443 
2444 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2445  int *got_output, const uint8_t *buf, int buf_size)
2446 {
2447  Mpeg1Context *s = avctx->priv_data;
2449  const uint8_t *buf_ptr = buf;
2450  const uint8_t *buf_end = buf + buf_size;
2451  int ret, input_size;
2452  int last_code = 0, skip_frame = 0;
2453  int picture_start_code_seen = 0;
2454 
2455  for (;;) {
2456  /* find next start code */
2457  uint32_t start_code = -1;
2458  buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2459  if (start_code > 0x1ff) {
2460  if (!skip_frame) {
2461  if (HAVE_THREADS &&
2462  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2463  !avctx->hwaccel) {
2464  int i;
2465  av_assert0(avctx->thread_count > 1);
2466 
2467  avctx->execute(avctx, slice_decode_thread,
2468  &s2->thread_context[0], NULL,
2469  s->slice_count, sizeof(void *));
2470  for (i = 0; i < s->slice_count; i++)
2471  s2->er.error_count += s2->thread_context[i]->er.error_count;
2472  }
2473 
2474 #if FF_API_VDPAU
2476  && uses_vdpau(avctx))
2477  ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2478 #endif
2479 
2480  ret = slice_end(avctx, picture);
2481  if (ret < 0)
2482  return ret;
2483  else if (ret) {
2484  // FIXME: merge with the stuff in mpeg_decode_slice
2485  if (s2->last_picture_ptr || s2->low_delay || s2->pict_type == AV_PICTURE_TYPE_B)
2486  *got_output = 1;
2487  }
2488  }
2489  s2->pict_type = 0;
2490 
2491  if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2492  return AVERROR_INVALIDDATA;
2493 
2494  return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2495  }
2496 
2497  input_size = buf_end - buf_ptr;
2498 
2499  if (avctx->debug & FF_DEBUG_STARTCODE)
2500  av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2501  start_code, buf_ptr - buf, input_size);
2502 
2503  /* prepare data for next start code */
2504  switch (start_code) {
2505  case SEQ_START_CODE:
2506  if (last_code == 0) {
2507  mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2508  if (buf != avctx->extradata)
2509  s->sync = 1;
2510  } else {
2511  av_log(avctx, AV_LOG_ERROR,
2512  "ignoring SEQ_START_CODE after %X\n", last_code);
2513  if (avctx->err_recognition & AV_EF_EXPLODE)
2514  return AVERROR_INVALIDDATA;
2515  }
2516  break;
2517 
2518  case PICTURE_START_CODE:
2519  if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2520  /* If it's a frame picture, there can't be more than one picture header.
2521  Yet, it does happen and we need to handle it. */
2522  av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2523  break;
2524  }
2525  picture_start_code_seen = 1;
2526 
2527  if (s2->width <= 0 || s2->height <= 0) {
2528  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2529  s2->width, s2->height);
2530  return AVERROR_INVALIDDATA;
2531  }
2532 
2533  if (s->tmpgexs){
2534  s2->intra_dc_precision= 3;
2535  s2->intra_matrix[0]= 1;
2536  }
2537  if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2538  !avctx->hwaccel && s->slice_count) {
2539  int i;
2540 
2541  avctx->execute(avctx, slice_decode_thread,
2542  s2->thread_context, NULL,
2543  s->slice_count, sizeof(void *));
2544  for (i = 0; i < s->slice_count; i++)
2545  s2->er.error_count += s2->thread_context[i]->er.error_count;
2546  s->slice_count = 0;
2547  }
2548  if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2549  ret = mpeg_decode_postinit(avctx);
2550  if (ret < 0) {
2551  av_log(avctx, AV_LOG_ERROR,
2552  "mpeg_decode_postinit() failure\n");
2553  return ret;
2554  }
2555 
2556  /* We have a complete image: we try to decompress it. */
2557  if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2558  s2->pict_type = 0;
2559  s->first_slice = 1;
2560  last_code = PICTURE_START_CODE;
2561  } else {
2562  av_log(avctx, AV_LOG_ERROR,
2563  "ignoring pic after %X\n", last_code);
2564  if (avctx->err_recognition & AV_EF_EXPLODE)
2565  return AVERROR_INVALIDDATA;
2566  }
2567  break;
2568  case EXT_START_CODE:
2569  init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2570 
2571  switch (get_bits(&s2->gb, 4)) {
2572  case 0x1:
2573  if (last_code == 0) {
2575  } else {
2576  av_log(avctx, AV_LOG_ERROR,
2577  "ignoring seq ext after %X\n", last_code);
2578  if (avctx->err_recognition & AV_EF_EXPLODE)
2579  return AVERROR_INVALIDDATA;
2580  }
2581  break;
2582  case 0x2:
2584  break;
2585  case 0x3:
2587  break;
2588  case 0x7:
2590  break;
2591  case 0x8:
2592  if (last_code == PICTURE_START_CODE) {
2594  } else {
2595  av_log(avctx, AV_LOG_ERROR,
2596  "ignoring pic cod ext after %X\n", last_code);
2597  if (avctx->err_recognition & AV_EF_EXPLODE)
2598  return AVERROR_INVALIDDATA;
2599  }
2600  break;
2601  }
2602  break;
2603  case USER_START_CODE:
2604  mpeg_decode_user_data(avctx, buf_ptr, input_size);
2605  break;
2606  case GOP_START_CODE:
2607  if (last_code == 0) {
2608  s2->first_field = 0;
2609  mpeg_decode_gop(avctx, buf_ptr, input_size);
2610  s->sync = 1;
2611  } else {
2612  av_log(avctx, AV_LOG_ERROR,
2613  "ignoring GOP_START_CODE after %X\n", last_code);
2614  if (avctx->err_recognition & AV_EF_EXPLODE)
2615  return AVERROR_INVALIDDATA;
2616  }
2617  break;
2618  default:
2619  if (start_code >= SLICE_MIN_START_CODE &&
2620  start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2621  if (s2->progressive_sequence && !s2->progressive_frame) {
2622  s2->progressive_frame = 1;
2623  av_log(s2->avctx, AV_LOG_ERROR,
2624  "interlaced frame in progressive sequence, ignoring\n");
2625  }
2626 
2627  if (s2->picture_structure == 0 ||
2629  av_log(s2->avctx, AV_LOG_ERROR,
2630  "picture_structure %d invalid, ignoring\n",
2631  s2->picture_structure);
2633  }
2634 
2636  av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2637 
2638  if (s2->picture_structure == PICT_FRAME) {
2639  s2->first_field = 0;
2640  s2->v_edge_pos = 16 * s2->mb_height;
2641  } else {
2642  s2->first_field ^= 1;
2643  s2->v_edge_pos = 8 * s2->mb_height;
2644  memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2645  }
2646  }
2647  if (start_code >= SLICE_MIN_START_CODE &&
2648  start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2649  const int field_pic = s2->picture_structure != PICT_FRAME;
2650  int mb_y = start_code - SLICE_MIN_START_CODE;
2651  last_code = SLICE_MIN_START_CODE;
2652  if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2653  mb_y += (*buf_ptr&0xE0)<<2;
2654 
2655  mb_y <<= field_pic;
2657  mb_y++;
2658 
2659  if (buf_end - buf_ptr < 2) {
2660  av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2661  return AVERROR_INVALIDDATA;
2662  }
2663 
2664  if (mb_y >= s2->mb_height) {
2665  av_log(s2->avctx, AV_LOG_ERROR,
2666  "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2667  return AVERROR_INVALIDDATA;
2668  }
2669 
2670  if (!s2->last_picture_ptr) {
2671  /* Skip B-frames if we do not have reference frames and
2672  * GOP is not closed. */
2673  if (s2->pict_type == AV_PICTURE_TYPE_B) {
2674  if (!s2->closed_gop) {
2675  skip_frame = 1;
2676  break;
2677  }
2678  }
2679  }
2681  s->sync = 1;
2682  if (!s2->next_picture_ptr) {
2683  /* Skip P-frames if we do not have a reference frame or
2684  * we have an invalid header. */
2685  if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2686  skip_frame = 1;
2687  break;
2688  }
2689  }
2690  if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2691  s2->pict_type == AV_PICTURE_TYPE_B) ||
2692  (avctx->skip_frame >= AVDISCARD_NONKEY &&
2693  s2->pict_type != AV_PICTURE_TYPE_I) ||
2694  avctx->skip_frame >= AVDISCARD_ALL) {
2695  skip_frame = 1;
2696  break;
2697  }
2698 
2699  if (!s->mpeg_enc_ctx_allocated)
2700  break;
2701 
2702  if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2703  if (mb_y < avctx->skip_top ||
2704  mb_y >= s2->mb_height - avctx->skip_bottom)
2705  break;
2706  }
2707 
2708  if (!s2->pict_type) {
2709  av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2710  if (avctx->err_recognition & AV_EF_EXPLODE)
2711  return AVERROR_INVALIDDATA;
2712  break;
2713  }
2714 
2715  if (s->first_slice) {
2716  skip_frame = 0;
2717  s->first_slice = 0;
2718  if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2719  return ret;
2720  }
2721  if (!s2->current_picture_ptr) {
2722  av_log(avctx, AV_LOG_ERROR,
2723  "current_picture not initialized\n");
2724  return AVERROR_INVALIDDATA;
2725  }
2726 
2727 #if FF_API_VDPAU
2728  if (uses_vdpau(avctx)) {
2729  s->slice_count++;
2730  break;
2731  }
2732 #endif
2733 
2734  if (HAVE_THREADS &&
2735  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2736  !avctx->hwaccel) {
2737  int threshold = (s2->mb_height * s->slice_count +
2738  s2->slice_context_count / 2) /
2739  s2->slice_context_count;
2740  av_assert0(avctx->thread_count > 1);
2741  if (threshold <= mb_y) {
2742  MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2743 
2744  thread_context->start_mb_y = mb_y;
2745  thread_context->end_mb_y = s2->mb_height;
2746  if (s->slice_count) {
2747  s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2748  ret = ff_update_duplicate_context(thread_context, s2);
2749  if (ret < 0)
2750  return ret;
2751  }
2752  init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2753  s->slice_count++;
2754  }
2755  buf_ptr += 2; // FIXME add minimum number of bytes per slice
2756  } else {
2757  ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2758  emms_c();
2759 
2760  if (ret < 0) {
2761  if (avctx->err_recognition & AV_EF_EXPLODE)
2762  return ret;
2763  if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2764  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2765  s2->resync_mb_y, s2->mb_x, s2->mb_y,
2767  } else {
2768  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2769  s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2771  }
2772  }
2773  }
2774  break;
2775  }
2776  }
2777 }
2778 
2779 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2780  int *got_output, AVPacket *avpkt)
2781 {
2782  const uint8_t *buf = avpkt->data;
2783  int ret;
2784  int buf_size = avpkt->size;
2785  Mpeg1Context *s = avctx->priv_data;
2786  AVFrame *picture = data;
2788 
2789  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2790  /* special case for last picture */
2791  if (s2->low_delay == 0 && s2->next_picture_ptr) {
2792  int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2793  if (ret < 0)
2794  return ret;
2795 
2796  s2->next_picture_ptr = NULL;
2797 
2798  *got_output = 1;
2799  }
2800  return buf_size;
2801  }
2802 
2803  if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2804  int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2805  buf_size, NULL);
2806 
2807  if (ff_combine_frame(&s2->parse_context, next,
2808  (const uint8_t **) &buf, &buf_size) < 0)
2809  return buf_size;
2810  }
2811 
2812  s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2813  if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2814  || s2->codec_tag == AV_RL32("BW10")
2815  ))
2816  vcr2_init_sequence(avctx);
2817 
2818  s->slice_count = 0;
2819 
2820  if (avctx->extradata && !s->extradata_decoded) {
2821  ret = decode_chunks(avctx, picture, got_output,
2822  avctx->extradata, avctx->extradata_size);
2823  if (*got_output) {
2824  av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2825  av_frame_unref(picture);
2826  *got_output = 0;
2827  }
2828  s->extradata_decoded = 1;
2829  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2830  s2->current_picture_ptr = NULL;
2831  return ret;
2832  }
2833  }
2834 
2835  ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2836  if (ret<0 || *got_output)
2837  s2->current_picture_ptr = NULL;
2838 
2839  return ret;
2840 }
2841 
2842 static void flush(AVCodecContext *avctx)
2843 {
2844  Mpeg1Context *s = avctx->priv_data;
2845 
2846  s->sync = 0;
2847 
2848  ff_mpeg_flush(avctx);
2849 }
2850 
2852 {
2853  Mpeg1Context *s = avctx->priv_data;
2854 
2855  if (s->mpeg_enc_ctx_allocated)
2857  av_freep(&s->a53_caption);
2858  return 0;
2859 }
2860 
2862  { FF_PROFILE_MPEG2_422, "4:2:2" },
2863  { FF_PROFILE_MPEG2_HIGH, "High" },
2864  { FF_PROFILE_MPEG2_SS, "Spatially Scalable" },
2865  { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable" },
2866  { FF_PROFILE_MPEG2_MAIN, "Main" },
2867  { FF_PROFILE_MPEG2_SIMPLE, "Simple" },
2868  { FF_PROFILE_RESERVED, "Reserved" },
2869  { FF_PROFILE_RESERVED, "Reserved" },
2870  { FF_PROFILE_UNKNOWN },
2871 };
2872 
2874  .name = "mpeg1video",
2875  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2876  .type = AVMEDIA_TYPE_VIDEO,
2877  .id = AV_CODEC_ID_MPEG1VIDEO,
2878  .priv_data_size = sizeof(Mpeg1Context),
2880  .close = mpeg_decode_end,
2885  .flush = flush,
2886  .max_lowres = 3,
2888 };
2889 
2891  .name = "mpeg2video",
2892  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2893  .type = AVMEDIA_TYPE_VIDEO,
2894  .id = AV_CODEC_ID_MPEG2VIDEO,
2895  .priv_data_size = sizeof(Mpeg1Context),
2897  .close = mpeg_decode_end,
2902  .flush = flush,
2903  .max_lowres = 3,
2904  .profiles = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2905 };
2906 
2907 //legacy decoder
2909  .name = "mpegvideo",
2910  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2911  .type = AVMEDIA_TYPE_VIDEO,
2912  .id = AV_CODEC_ID_MPEG2VIDEO,
2913  .priv_data_size = sizeof(Mpeg1Context),
2915  .close = mpeg_decode_end,
2918  .flush = flush,
2919  .max_lowres = 3,
2920 };
2921 
2922 #if FF_API_XVMC
2923 #if CONFIG_MPEG_XVMC_DECODER
2925 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2926 {
2927  if (avctx->active_thread_type & FF_THREAD_SLICE)
2928  return -1;
2929  if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2930  return -1;
2931  if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2932  ff_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2933  }
2934  mpeg_decode_init(avctx);
2935 
2937  avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2938 
2939  return 0;
2940 }
2941 
2942 AVCodec ff_mpeg_xvmc_decoder = {
2943  .name = "mpegvideo_xvmc",
2944  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2945  .type = AVMEDIA_TYPE_VIDEO,
2946  .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2947  .priv_data_size = sizeof(Mpeg1Context),
2948  .init = mpeg_mc_decode_init,
2949  .close = mpeg_decode_end,
2952  AV_CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL |
2954  .flush = flush,
2955 };
2957 #endif
2958 #endif /* FF_API_XVMC */
2959 
2960 #if CONFIG_MPEG_VDPAU_DECODER && FF_API_VDPAU
2961 AVCodec ff_mpeg_vdpau_decoder = {
2962  .name = "mpegvideo_vdpau",
2963  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2964  .type = AVMEDIA_TYPE_VIDEO,
2965  .id = AV_CODEC_ID_MPEG2VIDEO,
2966  .priv_data_size = sizeof(Mpeg1Context),
2968  .close = mpeg_decode_end,
2970  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2972  .flush = flush,
2973 };
2974 #endif
2975 
2976 #if CONFIG_MPEG1_VDPAU_DECODER && FF_API_VDPAU
2977 AVCodec ff_mpeg1_vdpau_decoder = {
2978  .name = "mpeg1video_vdpau",
2979  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
2980  .type = AVMEDIA_TYPE_VIDEO,
2981  .id = AV_CODEC_ID_MPEG1VIDEO,
2982  .priv_data_size = sizeof(Mpeg1Context),
2984  .close = mpeg_decode_end,
2986  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2988  .flush = flush,
2989 };
2990 #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:565
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:1170
#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:2861
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1512
#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:72
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:111
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:330
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)
Changing this would eat up any speed benefits it has.
Definition: mpeg12dec.c:480
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:1607
#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:2873
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:1117
#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:2417
#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:707
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:1145
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:1570
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:1238
static int mpeg1_fast_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
Changing this would eat up any speed benefits it has.
Definition: mpeg12dec.c:314
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:110
#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:1259
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:726
#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:1469
#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:2908
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:715
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:2342
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:1766
static int check_marker(GetBitContext *s, const char *msg)
Definition: get_bits.h:398
#define DECODE_SLICE_OK
Definition: mpeg12dec.c:1767
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:71
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:1666
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:394
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:2235
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:2289
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:567
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:2851
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:1593
#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:2146
#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:545
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:1196
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)
Changing this would eat up any speed benefits it has.
Definition: mpeg12dec.c:630
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:1775
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:3776
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:227
static enum AVPixelFormat mpeg12_pixfmt_list_422[]
Definition: mpeg12dec.c:1222
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:729
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:153
static int mpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_output, AVPacket *avpkt)
Definition: mpeg12dec.c:2779
#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:2444
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:1289
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:543
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:85
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:1182
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:67
Y , 8bpp.
Definition: pixfmt.h:75
#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:2890
#define TEX_VLC_BITS
Definition: dv.h:93
static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpeg12dec.c:731
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:2842
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:1422
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:2095
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:1285
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:727
#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:272
mpeg1 4:2:0, jpeg 4:2:0, h263 4:2:0
Definition: pixfmt.h:566
#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:2044
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:1227
AVPixelFormat
Pixel format.
Definition: pixfmt.h:65
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:1536
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