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) * 400LL;
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:%"PRId64"\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) * 400LL;
2179  if (check_marker(&s->gb, "in sequence header") == 0) {
2180  return AVERROR_INVALIDDATA;
2181  }
2182 
2183  s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2184  skip_bits(&s->gb, 1);
2185 
2186  /* get matrix */
2187  if (get_bits1(&s->gb)) {
2189  } else {
2190  for (i = 0; i < 64; i++) {
2191  j = s->idsp.idct_permutation[i];
2193  s->intra_matrix[j] = v;
2194  s->chroma_intra_matrix[j] = v;
2195  }
2196  }
2197  if (get_bits1(&s->gb)) {
2199  } else {
2200  for (i = 0; i < 64; i++) {
2201  int j = s->idsp.idct_permutation[i];
2203  s->inter_matrix[j] = v;
2204  s->chroma_inter_matrix[j] = v;
2205  }
2206  }
2207 
2208  if (show_bits(&s->gb, 23) != 0) {
2209  av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2210  return AVERROR_INVALIDDATA;
2211  }
2212 
2213  s->width = width;
2214  s->height = height;
2215 
2216  /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2217  s->progressive_sequence = 1;
2218  s->progressive_frame = 1;
2220  s->first_field = 0;
2221  s->frame_pred_frame_dct = 1;
2222  s->chroma_format = 1;
2223  s->codec_id =
2225  s->out_format = FMT_MPEG1;
2226  s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2228  s->low_delay = 1;
2229 
2230  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2231  av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
2233 
2234  return 0;
2235 }
2236 
2238 {
2239  Mpeg1Context *s1 = avctx->priv_data;
2240  MpegEncContext *s = &s1->mpeg_enc_ctx;
2241  int i, v, ret;
2242 
2243  /* start new MPEG-1 context decoding */
2244  s->out_format = FMT_MPEG1;
2245  if (s1->mpeg_enc_ctx_allocated) {
2246  ff_mpv_common_end(s);
2247  s1->mpeg_enc_ctx_allocated = 0;
2248  }
2249  s->width = avctx->coded_width;
2250  s->height = avctx->coded_height;
2251  avctx->has_b_frames = 0; // true?
2252  s->low_delay = 1;
2253 
2254  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2255  setup_hwaccel_for_pixfmt(avctx);
2256 
2257  ff_mpv_idct_init(s);
2258  if ((ret = ff_mpv_common_init(s)) < 0)
2259  return ret;
2260  s1->mpeg_enc_ctx_allocated = 1;
2261 
2262  for (i = 0; i < 64; i++) {
2263  int j = s->idsp.idct_permutation[i];
2265  s->intra_matrix[j] = v;
2266  s->chroma_intra_matrix[j] = v;
2267 
2269  s->inter_matrix[j] = v;
2270  s->chroma_inter_matrix[j] = v;
2271  }
2272 
2273  s->progressive_sequence = 1;
2274  s->progressive_frame = 1;
2276  s->first_field = 0;
2277  s->frame_pred_frame_dct = 1;
2278  s->chroma_format = 1;
2279  if (s->codec_tag == AV_RL32("BW10")) {
2281  } else {
2282  s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2284  }
2285  s1->save_width = s->width;
2286  s1->save_height = s->height;
2288  return 0;
2289 }
2290 
2292  const uint8_t *p, int buf_size)
2293 {
2294  Mpeg1Context *s1 = avctx->priv_data;
2295 
2296  if (buf_size >= 6 &&
2297  p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2298  p[4] == 3 && (p[5] & 0x40)) {
2299  /* extract A53 Part 4 CC data */
2300  int cc_count = p[5] & 0x1f;
2301  if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2302  av_freep(&s1->a53_caption);
2303  s1->a53_caption_size = cc_count * 3;
2305  if (s1->a53_caption)
2306  memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2307  }
2308  return 1;
2309  } else if (buf_size >= 11 &&
2310  p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2311  /* extract DVD CC data */
2312  int cc_count = 0;
2313  int i;
2314  // There is a caption count field in the data, but it is often
2315  // incorect. So count the number of captions present.
2316  for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2317  cc_count++;
2318  // Transform the DVD format into A53 Part 4 format
2319  if (cc_count > 0) {
2320  av_freep(&s1->a53_caption);
2321  s1->a53_caption_size = cc_count * 6;
2323  if (s1->a53_caption) {
2324  uint8_t field1 = !!(p[4] & 0x80);
2325  uint8_t *cap = s1->a53_caption;
2326  p += 5;
2327  for (i = 0; i < cc_count; i++) {
2328  cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2329  cap[1] = p[1];
2330  cap[2] = p[2];
2331  cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2332  cap[4] = p[4];
2333  cap[5] = p[5];
2334  cap += 6;
2335  p += 6;
2336  }
2337  }
2338  }
2339  return 1;
2340  }
2341  return 0;
2342 }
2343 
2345  const uint8_t *p, int buf_size)
2346 {
2347  Mpeg1Context *s = avctx->priv_data;
2348  const uint8_t *buf_end = p + buf_size;
2349  Mpeg1Context *s1 = avctx->priv_data;
2350 
2351 #if 0
2352  int i;
2353  for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2354  av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2355  }
2356  av_log(avctx, AV_LOG_ERROR, "\n");
2357 #endif
2358 
2359  if (buf_size > 29){
2360  int i;
2361  for(i=0; i<20; i++)
2362  if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2363  s->tmpgexs= 1;
2364  }
2365  }
2366  /* we parse the DTG active format information */
2367  if (buf_end - p >= 5 &&
2368  p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2369  int flags = p[4];
2370  p += 5;
2371  if (flags & 0x80) {
2372  /* skip event id */
2373  p += 2;
2374  }
2375  if (flags & 0x40) {
2376  if (buf_end - p < 1)
2377  return;
2378 #if FF_API_AFD
2380  avctx->dtg_active_format = p[0] & 0x0f;
2382 #endif /* FF_API_AFD */
2383  s1->has_afd = 1;
2384  s1->afd = p[0] & 0x0f;
2385  }
2386  } else if (buf_end - p >= 6 &&
2387  p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2388  p[4] == 0x03) { // S3D_video_format_length
2389  // the 0x7F mask ignores the reserved_bit value
2390  const uint8_t S3D_video_format_type = p[5] & 0x7F;
2391 
2392  if (S3D_video_format_type == 0x03 ||
2393  S3D_video_format_type == 0x04 ||
2394  S3D_video_format_type == 0x08 ||
2395  S3D_video_format_type == 0x23) {
2396 
2397  s1->has_stereo3d = 1;
2398 
2399  switch (S3D_video_format_type) {
2400  case 0x03:
2402  break;
2403  case 0x04:
2405  break;
2406  case 0x08:
2408  break;
2409  case 0x23:
2411  break;
2412  }
2413  }
2414  } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2415  return;
2416  }
2417 }
2418 
2419 static void mpeg_decode_gop(AVCodecContext *avctx,
2420  const uint8_t *buf, int buf_size)
2421 {
2422  Mpeg1Context *s1 = avctx->priv_data;
2423  MpegEncContext *s = &s1->mpeg_enc_ctx;
2424  int broken_link;
2425  int64_t tc;
2426 
2427  init_get_bits(&s->gb, buf, buf_size * 8);
2428 
2429  tc = avctx->timecode_frame_start = get_bits(&s->gb, 25);
2430 
2431  s->closed_gop = get_bits1(&s->gb);
2432  /* broken_link indicate that after editing the
2433  * reference frames of the first B-Frames after GOP I-Frame
2434  * are missing (open gop) */
2435  broken_link = get_bits1(&s->gb);
2436 
2437  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2438  char tcbuf[AV_TIMECODE_STR_SIZE];
2441  "GOP (%s) closed_gop=%d broken_link=%d\n",
2442  tcbuf, s->closed_gop, broken_link);
2443  }
2444 }
2445 
2446 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2447  int *got_output, const uint8_t *buf, int buf_size)
2448 {
2449  Mpeg1Context *s = avctx->priv_data;
2451  const uint8_t *buf_ptr = buf;
2452  const uint8_t *buf_end = buf + buf_size;
2453  int ret, input_size;
2454  int last_code = 0, skip_frame = 0;
2455  int picture_start_code_seen = 0;
2456 
2457  for (;;) {
2458  /* find next start code */
2459  uint32_t start_code = -1;
2460  buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2461  if (start_code > 0x1ff) {
2462  if (!skip_frame) {
2463  if (HAVE_THREADS &&
2464  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2465  !avctx->hwaccel) {
2466  int i;
2467  av_assert0(avctx->thread_count > 1);
2468 
2469  avctx->execute(avctx, slice_decode_thread,
2470  &s2->thread_context[0], NULL,
2471  s->slice_count, sizeof(void *));
2472  for (i = 0; i < s->slice_count; i++)
2473  s2->er.error_count += s2->thread_context[i]->er.error_count;
2474  }
2475 
2476 #if FF_API_VDPAU
2477  if ((CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER)
2478  && uses_vdpau(avctx))
2479  ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2480 #endif
2481 
2482  ret = slice_end(avctx, picture);
2483  if (ret < 0)
2484  return ret;
2485  else if (ret) {
2486  // FIXME: merge with the stuff in mpeg_decode_slice
2487  if (s2->last_picture_ptr || s2->low_delay)
2488  *got_output = 1;
2489  }
2490  }
2491  s2->pict_type = 0;
2492 
2493  if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2494  return AVERROR_INVALIDDATA;
2495 
2496  return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2497  }
2498 
2499  input_size = buf_end - buf_ptr;
2500 
2501  if (avctx->debug & FF_DEBUG_STARTCODE)
2502  av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2503  start_code, buf_ptr - buf, input_size);
2504 
2505  /* prepare data for next start code */
2506  switch (start_code) {
2507  case SEQ_START_CODE:
2508  if (last_code == 0) {
2509  mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2510  if (buf != avctx->extradata)
2511  s->sync = 1;
2512  } else {
2513  av_log(avctx, AV_LOG_ERROR,
2514  "ignoring SEQ_START_CODE after %X\n", last_code);
2515  if (avctx->err_recognition & AV_EF_EXPLODE)
2516  return AVERROR_INVALIDDATA;
2517  }
2518  break;
2519 
2520  case PICTURE_START_CODE:
2521  if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2522  /* If it's a frame picture, there can't be more than one picture header.
2523  Yet, it does happen and we need to handle it. */
2524  av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2525  break;
2526  }
2527  picture_start_code_seen = 1;
2528 
2529  if (s2->width <= 0 || s2->height <= 0) {
2530  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2531  s2->width, s2->height);
2532  return AVERROR_INVALIDDATA;
2533  }
2534 
2535  if (s->tmpgexs){
2536  s2->intra_dc_precision= 3;
2537  s2->intra_matrix[0]= 1;
2538  }
2539  if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2540  !avctx->hwaccel && s->slice_count) {
2541  int i;
2542 
2543  avctx->execute(avctx, slice_decode_thread,
2544  s2->thread_context, NULL,
2545  s->slice_count, sizeof(void *));
2546  for (i = 0; i < s->slice_count; i++)
2547  s2->er.error_count += s2->thread_context[i]->er.error_count;
2548  s->slice_count = 0;
2549  }
2550  if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2551  ret = mpeg_decode_postinit(avctx);
2552  if (ret < 0) {
2553  av_log(avctx, AV_LOG_ERROR,
2554  "mpeg_decode_postinit() failure\n");
2555  return ret;
2556  }
2557 
2558  /* We have a complete image: we try to decompress it. */
2559  if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2560  s2->pict_type = 0;
2561  s->first_slice = 1;
2562  last_code = PICTURE_START_CODE;
2563  } else {
2564  av_log(avctx, AV_LOG_ERROR,
2565  "ignoring pic after %X\n", last_code);
2566  if (avctx->err_recognition & AV_EF_EXPLODE)
2567  return AVERROR_INVALIDDATA;
2568  }
2569  break;
2570  case EXT_START_CODE:
2571  init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2572 
2573  switch (get_bits(&s2->gb, 4)) {
2574  case 0x1:
2575  if (last_code == 0) {
2577  } else {
2578  av_log(avctx, AV_LOG_ERROR,
2579  "ignoring seq ext after %X\n", last_code);
2580  if (avctx->err_recognition & AV_EF_EXPLODE)
2581  return AVERROR_INVALIDDATA;
2582  }
2583  break;
2584  case 0x2:
2586  break;
2587  case 0x3:
2589  break;
2590  case 0x7:
2592  break;
2593  case 0x8:
2594  if (last_code == PICTURE_START_CODE) {
2596  } else {
2597  av_log(avctx, AV_LOG_ERROR,
2598  "ignoring pic cod ext after %X\n", last_code);
2599  if (avctx->err_recognition & AV_EF_EXPLODE)
2600  return AVERROR_INVALIDDATA;
2601  }
2602  break;
2603  }
2604  break;
2605  case USER_START_CODE:
2606  mpeg_decode_user_data(avctx, buf_ptr, input_size);
2607  break;
2608  case GOP_START_CODE:
2609  if (last_code == 0) {
2610  s2->first_field = 0;
2611  mpeg_decode_gop(avctx, buf_ptr, input_size);
2612  s->sync = 1;
2613  } else {
2614  av_log(avctx, AV_LOG_ERROR,
2615  "ignoring GOP_START_CODE after %X\n", last_code);
2616  if (avctx->err_recognition & AV_EF_EXPLODE)
2617  return AVERROR_INVALIDDATA;
2618  }
2619  break;
2620  default:
2621  if (start_code >= SLICE_MIN_START_CODE &&
2622  start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2623  if (s2->progressive_sequence && !s2->progressive_frame) {
2624  s2->progressive_frame = 1;
2625  av_log(s2->avctx, AV_LOG_ERROR,
2626  "interlaced frame in progressive sequence, ignoring\n");
2627  }
2628 
2629  if (s2->picture_structure == 0 ||
2631  av_log(s2->avctx, AV_LOG_ERROR,
2632  "picture_structure %d invalid, ignoring\n",
2633  s2->picture_structure);
2635  }
2636 
2638  av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2639 
2640  if (s2->picture_structure == PICT_FRAME) {
2641  s2->first_field = 0;
2642  s2->v_edge_pos = 16 * s2->mb_height;
2643  } else {
2644  s2->first_field ^= 1;
2645  s2->v_edge_pos = 8 * s2->mb_height;
2646  memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2647  }
2648  }
2649  if (start_code >= SLICE_MIN_START_CODE &&
2650  start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2651  const int field_pic = s2->picture_structure != PICT_FRAME;
2652  int mb_y = start_code - SLICE_MIN_START_CODE;
2653  last_code = SLICE_MIN_START_CODE;
2654  if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2655  mb_y += (*buf_ptr&0xE0)<<2;
2656 
2657  mb_y <<= field_pic;
2659  mb_y++;
2660 
2661  if (buf_end - buf_ptr < 2) {
2662  av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2663  return AVERROR_INVALIDDATA;
2664  }
2665 
2666  if (mb_y >= s2->mb_height) {
2667  av_log(s2->avctx, AV_LOG_ERROR,
2668  "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2669  return AVERROR_INVALIDDATA;
2670  }
2671 
2672  if (!s2->last_picture_ptr) {
2673  /* Skip B-frames if we do not have reference frames and
2674  * GOP is not closed. */
2675  if (s2->pict_type == AV_PICTURE_TYPE_B) {
2676  if (!s2->closed_gop) {
2677  skip_frame = 1;
2678  break;
2679  }
2680  }
2681  }
2683  s->sync = 1;
2684  if (!s2->next_picture_ptr) {
2685  /* Skip P-frames if we do not have a reference frame or
2686  * we have an invalid header. */
2687  if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2688  skip_frame = 1;
2689  break;
2690  }
2691  }
2692  if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2693  s2->pict_type == AV_PICTURE_TYPE_B) ||
2694  (avctx->skip_frame >= AVDISCARD_NONKEY &&
2695  s2->pict_type != AV_PICTURE_TYPE_I) ||
2696  avctx->skip_frame >= AVDISCARD_ALL) {
2697  skip_frame = 1;
2698  break;
2699  }
2700 
2701  if (!s->mpeg_enc_ctx_allocated)
2702  break;
2703 
2704  if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2705  if (mb_y < avctx->skip_top ||
2706  mb_y >= s2->mb_height - avctx->skip_bottom)
2707  break;
2708  }
2709 
2710  if (!s2->pict_type) {
2711  av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2712  if (avctx->err_recognition & AV_EF_EXPLODE)
2713  return AVERROR_INVALIDDATA;
2714  break;
2715  }
2716 
2717  if (s->first_slice) {
2718  skip_frame = 0;
2719  s->first_slice = 0;
2720  if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2721  return ret;
2722  }
2723  if (!s2->current_picture_ptr) {
2724  av_log(avctx, AV_LOG_ERROR,
2725  "current_picture not initialized\n");
2726  return AVERROR_INVALIDDATA;
2727  }
2728 
2729 #if FF_API_VDPAU
2730  if (uses_vdpau(avctx)) {
2731  s->slice_count++;
2732  break;
2733  }
2734 #endif
2735 
2736  if (HAVE_THREADS &&
2737  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2738  !avctx->hwaccel) {
2739  int threshold = (s2->mb_height * s->slice_count +
2740  s2->slice_context_count / 2) /
2741  s2->slice_context_count;
2742  av_assert0(avctx->thread_count > 1);
2743  if (threshold <= mb_y) {
2744  MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2745 
2746  thread_context->start_mb_y = mb_y;
2747  thread_context->end_mb_y = s2->mb_height;
2748  if (s->slice_count) {
2749  s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2750  ret = ff_update_duplicate_context(thread_context, s2);
2751  if (ret < 0)
2752  return ret;
2753  }
2754  init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2755  s->slice_count++;
2756  }
2757  buf_ptr += 2; // FIXME add minimum number of bytes per slice
2758  } else {
2759  ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2760  emms_c();
2761 
2762  if (ret < 0) {
2763  if (avctx->err_recognition & AV_EF_EXPLODE)
2764  return ret;
2765  if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2766  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2767  s2->resync_mb_y, s2->mb_x, s2->mb_y,
2769  } else {
2770  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2771  s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2773  }
2774  }
2775  }
2776  break;
2777  }
2778  }
2779 }
2780 
2781 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2782  int *got_output, AVPacket *avpkt)
2783 {
2784  const uint8_t *buf = avpkt->data;
2785  int ret;
2786  int buf_size = avpkt->size;
2787  Mpeg1Context *s = avctx->priv_data;
2788  AVFrame *picture = data;
2790 
2791  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2792  /* special case for last picture */
2793  if (s2->low_delay == 0 && s2->next_picture_ptr) {
2794  int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2795  if (ret < 0)
2796  return ret;
2797 
2798  s2->next_picture_ptr = NULL;
2799 
2800  *got_output = 1;
2801  }
2802  return buf_size;
2803  }
2804 
2805  if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2806  int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2807  buf_size, NULL);
2808 
2809  if (ff_combine_frame(&s2->parse_context, next,
2810  (const uint8_t **) &buf, &buf_size) < 0)
2811  return buf_size;
2812  }
2813 
2814  s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2815  if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2816  || s2->codec_tag == AV_RL32("BW10")
2817  ))
2818  vcr2_init_sequence(avctx);
2819 
2820  s->slice_count = 0;
2821 
2822  if (avctx->extradata && !s->extradata_decoded) {
2823  ret = decode_chunks(avctx, picture, got_output,
2824  avctx->extradata, avctx->extradata_size);
2825  if (*got_output) {
2826  av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2827  *got_output = 0;
2828  }
2829  s->extradata_decoded = 1;
2830  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2831  s2->current_picture_ptr = NULL;
2832  return ret;
2833  }
2834  }
2835 
2836  ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2837  if (ret<0 || *got_output)
2838  s2->current_picture_ptr = NULL;
2839 
2840  return ret;
2841 }
2842 
2843 static void flush(AVCodecContext *avctx)
2844 {
2845  Mpeg1Context *s = avctx->priv_data;
2846 
2847  s->sync = 0;
2848 
2849  ff_mpeg_flush(avctx);
2850 }
2851 
2853 {
2854  Mpeg1Context *s = avctx->priv_data;
2855 
2856  if (s->mpeg_enc_ctx_allocated)
2858  av_freep(&s->a53_caption);
2859  return 0;
2860 }
2861 
2863  { FF_PROFILE_MPEG2_422, "4:2:2" },
2864  { FF_PROFILE_MPEG2_HIGH, "High" },
2865  { FF_PROFILE_MPEG2_SS, "Spatially Scalable" },
2866  { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable" },
2867  { FF_PROFILE_MPEG2_MAIN, "Main" },
2868  { FF_PROFILE_MPEG2_SIMPLE, "Simple" },
2869  { FF_PROFILE_RESERVED, "Reserved" },
2870  { FF_PROFILE_RESERVED, "Reserved" },
2871  { FF_PROFILE_UNKNOWN },
2872 };
2873 
2875  .name = "mpeg1video",
2876  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2877  .type = AVMEDIA_TYPE_VIDEO,
2878  .id = AV_CODEC_ID_MPEG1VIDEO,
2879  .priv_data_size = sizeof(Mpeg1Context),
2881  .close = mpeg_decode_end,
2886  .flush = flush,
2887  .max_lowres = 3,
2889 };
2890 
2892  .name = "mpeg2video",
2893  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2894  .type = AVMEDIA_TYPE_VIDEO,
2895  .id = AV_CODEC_ID_MPEG2VIDEO,
2896  .priv_data_size = sizeof(Mpeg1Context),
2898  .close = mpeg_decode_end,
2903  .flush = flush,
2904  .max_lowres = 3,
2905  .profiles = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2906 };
2907 
2908 //legacy decoder
2910  .name = "mpegvideo",
2911  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2912  .type = AVMEDIA_TYPE_VIDEO,
2913  .id = AV_CODEC_ID_MPEG2VIDEO,
2914  .priv_data_size = sizeof(Mpeg1Context),
2916  .close = mpeg_decode_end,
2919  .flush = flush,
2920  .max_lowres = 3,
2921 };
2922 
2923 #if FF_API_XVMC
2924 #if CONFIG_MPEG_XVMC_DECODER
2926 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2927 {
2928  if (avctx->active_thread_type & FF_THREAD_SLICE)
2929  return -1;
2930  if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2931  return -1;
2932  if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2933  ff_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2934  }
2935  mpeg_decode_init(avctx);
2936 
2938  avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2939 
2940  return 0;
2941 }
2942 
2943 AVCodec ff_mpeg_xvmc_decoder = {
2944  .name = "mpegvideo_xvmc",
2945  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2946  .type = AVMEDIA_TYPE_VIDEO,
2947  .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2948  .priv_data_size = sizeof(Mpeg1Context),
2949  .init = mpeg_mc_decode_init,
2950  .close = mpeg_decode_end,
2953  AV_CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL |
2955  .flush = flush,
2956 };
2958 #endif
2959 #endif /* FF_API_XVMC */
2960 
2961 #if CONFIG_MPEG_VDPAU_DECODER && FF_API_VDPAU
2962 AVCodec ff_mpeg_vdpau_decoder = {
2963  .name = "mpegvideo_vdpau",
2964  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2965  .type = AVMEDIA_TYPE_VIDEO,
2966  .id = AV_CODEC_ID_MPEG2VIDEO,
2967  .priv_data_size = sizeof(Mpeg1Context),
2969  .close = mpeg_decode_end,
2971  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2973  .flush = flush,
2974 };
2975 #endif
2976 
2977 #if CONFIG_MPEG1_VDPAU_DECODER && FF_API_VDPAU
2978 AVCodec ff_mpeg1_vdpau_decoder = {
2979  .name = "mpeg1video_vdpau",
2980  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
2981  .type = AVMEDIA_TYPE_VIDEO,
2982  .id = AV_CODEC_ID_MPEG1VIDEO,
2983  .priv_data_size = sizeof(Mpeg1Context),
2985  .close = mpeg_decode_end,
2987  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_TRUNCATED |
2989  .flush = flush,
2990 };
2991 #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:1511
#define MB_TYPE_SKIP
Definition: avcodec.h:1152
const char const char void * val
Definition: avisynth_c.h:634
discard all frames except keyframes
Definition: avcodec.h:688
int8_t * ref_index[2]
Definition: mpegpicture.h:62
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c: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:3640
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:3140
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:1696
static const AVProfile mpeg2_video_profiles[]
Definition: mpeg12dec.c:2862
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1514
#define FF_PROFILE_MPEG2_SS
Definition: avcodec.h:3139
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:1184
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:139
uint16_t chroma_inter_matrix[64]
Definition: mpegvideo.h:311
void ff_er_frame_end(ERContext *s)
static int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, int16_t *block, int n)
Note: this function can read out of range and crash for corrupt streams.
Definition: mpeg12dec.c:482
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2237
#define FF_PROFILE_RESERVED
Definition: avcodec.h:3117
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:1424
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:2906
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:1902
#define MB_TYPE_INTRA
Definition: mpegutils.h:69
AVCodec ff_mpeg1video_decoder
Definition: mpeg12dec.c:2874
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:1722
#define tc
Definition: regdef.h:69
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:66
static av_cold int mpeg_decode_init(AVCodecContext *avctx)
Definition: mpeg12dec.c:1120
#define MB_TYPE_QUANT
Definition: avcodec.h:1160
mpegvideo header.
#define HAS_CBP(a)
Definition: mpegutils.h:97
discard all
Definition: avcodec.h:689
uint8_t permutated[64]
Definition: idctdsp.h:31
uint8_t run
Definition: svq3.c:149
#define ER_MV_ERROR
static void mpeg_decode_gop(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2419
#define SLICE_MIN_START_CODE
Definition: mpegvideo.h:80
int profile
profile
Definition: avcodec.h:3115
AVCodec.
Definition: avcodec.h:3472
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:86
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:3226
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:2922
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:882
#define USES_LIST(a, list)
Definition: mpegutils.h:95
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo.c: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:780
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:365
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:3116
#define FF_PROFILE_MPEG2_MAIN
Definition: avcodec.h:3141
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:1617
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:1423
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:893
#define ER_MV_END
#define ff_dlog(a,...)
MPEG-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstr...
Definition: pixfmt.h:106
#define FF_PROFILE_MPEG2_HIGH
Definition: avcodec.h:3138
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:3013
int codec_tag
internal codec_tag upper case converted from avctx codec_tag
Definition: mpegvideo.h:127
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:763
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:89
VLC ff_mv_vlc
Definition: mpeg12.c:135
#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:3486
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:1812
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:2901
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:3142
#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:3052
AVCodec ff_mpegvideo_decoder
Definition: mpeg12dec.c:2909
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:1597
#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:3479
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
Definition: mpeg12dec.c:107
int width
width and height in 1/16 pel
Definition: avcodec.h:1183
int low_delay
no reordering needed / has no b-frames
Definition: mpegvideo.h:411
static void mpeg_decode_user_data(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition: mpeg12dec.c:2344
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:79
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:2581
static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: ffv1dec.c:1064
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:2856
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:851
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:2732
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:2890
#define FF_IDCT_SIMPLE
Definition: avcodec.h:2964
#define FFMIN(a, b)
Definition: common.h:81
int last_index
Definition: parser.h:31
static int vcr2_init_sequence(AVCodecContext *avctx)
Definition: mpeg12dec.c:2237
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:2961
#define MB_TYPE_INTERLACED
Definition: avcodec.h:1148
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:191
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
#define ER_DC_END
static int mpeg_decode_a53_cc(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition: mpeg12dec.c:2291
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:2216
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:1159
int level
level
Definition: avcodec.h:3204
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:194
static av_cold int mpeg_decode_end(AVCodecContext *avctx)
Definition: mpeg12dec.c:2852
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:1158
int mpeg_enc_ctx_allocated
Definition: mpeg12dec.c:54
#define check_scantable_index(ctx, x)
Definition: mpeg12dec.c:133
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo.c:474
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:107
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:47
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h: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:3033
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:2036
static const float pred[4]
Definition: siprdata.h:259
AVRational save_aspect
Definition: mpeg12dec.c:64
int first_field
is 1 for the first field of a field picture 0 otherwise
Definition: mpegvideo.h:485
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:924
int save_width
Definition: mpeg12dec.c:65
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:274
#define MV_VLC_BITS
Definition: ituh263dec.c:54
#define FF_IDCT_AUTO
Definition: avcodec.h:2962
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:3045
AVRational frame_rate_ext
Definition: mpeg12dec.c:66
enum AVCodecID codec_id
Definition: avcodec.h:1519
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:3437
#define AV_CODEC_FLAG2_FAST
Definition: avcodec.h:803
int debug
debug
Definition: avcodec.h:2842
#define MB_PTYPE_VLC_BITS
Definition: mpeg12vlc.h:39
main external API structure.
Definition: avcodec.h:1502
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:1534
#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:1618
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:3044
int slice_flags
slice flags
Definition: avcodec.h:2034
int coded_height
Definition: avcodec.h:1696
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:2230
rational number numerator/denominator
Definition: rational.h:43
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2223
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:1144
int save_progressive_seq
Definition: mpeg12dec.c:65
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
static int mpeg1_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:142
#define MT_DMV
Definition: mpeg12dec.c:732
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
#define s1
Definition: regdef.h:38
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c: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:1997
#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:2781
#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:2446
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
static const uint8_t start_code[]
Definition: h264.c:1292
av_cold void ff_mpeg12_common_init(MpegEncContext *s)
Definition: mpeg12.c:115
Views are on top of each other.
Definition: stereo3d.h:55
#define AV_CODEC_CAP_TRUNCATED
Definition: avcodec.h:858
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:138
int skip_bottom
Number of macroblock rows at the bottom which are skipped.
Definition: avcodec.h:2121
static int flags
Definition: cpu.c:47
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition: stereo3d.c:32
Pan Scan area.
Definition: avcodec.h:1170
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
uint8_t level
Definition: svq3.c:150
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2843
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:1161
#define AV_PIX_FMT_XVMC
Definition: pixfmt.h:81
discard all non reference
Definition: avcodec.h:685
const AVRational ff_mpeg2_aspect[16]
Definition: mpeg12data.c:415
volatile int error_count
static enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[]
Definition: mpeg12dec.c:1185
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
Y , 8bpp.
Definition: pixfmt.h:71
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h: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:2891
#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:2843
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:3460
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: avcodec.h:2899
static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:1424
unsigned properties
Definition: avcodec.h:3435
int den
denominator
Definition: rational.h:45
const uint8_t ff_alternate_vertical_scan[64]
Definition: mpegvideodata.c:93
#define MB_TYPE_16x8
Definition: avcodec.h:1145
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
Definition: mpegvideo.c:446
#define SLICE_FLAG_CODED_ORDER
draw_horiz_band() is called in coded order instead of display
Definition: avcodec.h:2035
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:1191
void * priv_data
Definition: avcodec.h:1544
#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:3073
#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:1196
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
int64_t bit_rate
wanted bit rate
Definition: mpegvideo.h:110
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:237
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:2905
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:449
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1604
MpegEncContext mpeg_enc_ctx
Definition: mpeg12dec.c:53
int slice_count
Definition: mpeg12dec.c:63
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
#define MB_TYPE_ZERO_MV
Definition: mpeg12dec.c:73
#define AV_CODEC_FLAG_TRUNCATED
Input bitstream might be truncated at a random location instead of only at frame boundaries.
Definition: avcodec.h:772
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition: avcodec.h:831
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
Definition: mpegvideo.h:308
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegpicture.h:56
#define av_freep(p)
ScanTable inter_scantable
if inter == intra then intra should be used to reduce tha cache usage
Definition: mpegvideo.h:97
#define PICTURE_START_CODE
Definition: mpegvideo.h:79
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h: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:3137
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:3654
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:3665
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:1400
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:857
#define MB_TYPE_L0
Definition: avcodec.h:1157
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