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