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 {
53  MpegEncContext mpeg_enc_ctx;
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 */
57  AVStereo3D stereo3d;
58  int has_stereo3d;
59  uint8_t *a53_caption;
60  int a53_caption_size;
61  uint8_t afd;
62  int has_afd;
63  int slice_count;
64  AVRational save_aspect;
65  int save_width, save_height, save_progressive_seq;
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;
69  int first_slice;
70  int extradata_decoded;
71 } Mpeg1Context;
72 
73 #define MB_TYPE_ZERO_MV 0x20000000
74 
75 static const uint32_t ptype2mb_type[7] = {
76  MB_TYPE_INTRA,
77  MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
78  MB_TYPE_L0,
79  MB_TYPE_L0 | MB_TYPE_CBP,
80  MB_TYPE_QUANT | MB_TYPE_INTRA,
81  MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP | MB_TYPE_ZERO_MV | MB_TYPE_16x16,
82  MB_TYPE_QUANT | MB_TYPE_L0 | MB_TYPE_CBP,
83 };
84 
85 static const uint32_t btype2mb_type[11] = {
86  MB_TYPE_INTRA,
87  MB_TYPE_L1,
88  MB_TYPE_L1 | MB_TYPE_CBP,
89  MB_TYPE_L0,
90  MB_TYPE_L0 | MB_TYPE_CBP,
91  MB_TYPE_L0L1,
92  MB_TYPE_L0L1 | MB_TYPE_CBP,
93  MB_TYPE_QUANT | MB_TYPE_INTRA,
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 
142 static inline int mpeg1_decode_block_intra(MpegEncContext *s,
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 
225 int ff_mpeg1_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
226 {
227  return mpeg1_decode_block_intra(s, block, n);
228 }
229 
230 static inline int mpeg1_decode_block_inter(MpegEncContext *s,
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  */
315 static inline int mpeg1_fast_decode_block_inter(MpegEncContext *s,
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 
395 static inline int mpeg2_decode_block_non_intra(MpegEncContext *s,
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  */
482 static inline int mpeg2_fast_decode_block_non_intra(MpegEncContext *s,
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 
547 static inline int mpeg2_decode_block_intra(MpegEncContext *s,
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  */
633 static inline int mpeg2_fast_decode_block_intra(MpegEncContext *s,
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] =
748  MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16;
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) {
776  av_log(s->avctx, AV_LOG_ERROR,
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) {
789  av_log(s->avctx, AV_LOG_ERROR,
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) {
798  av_log(s->avctx, AV_LOG_ERROR,
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 &&
816  !s->frame_pred_frame_dct)
817  s->interlaced_dct = get_bits1(&s->gb);
818 
819  if (IS_QUANT(mb_type))
820  s->qscale = get_qscale(s);
821 
822  if (s->concealment_motion_vectors) {
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 & CODEC_FLAG2_FAST) {
848  for (i = 0; i < 6; i++)
849  mpeg2_fast_decode_block_intra(s, *s->pblocks[i], 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 */
889  if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) {
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 {
969  av_assert0(!s->progressive_sequence);
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;
1031  if (s->picture_structure == PICT_TOP_FIELD)
1032  s->mv[i][2][1]--;
1033  else
1034  s->mv[i][2][1]++;
1035  }
1036  }
1037  }
1038  break;
1039  default:
1040  av_log(s->avctx, AV_LOG_ERROR,
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) {
1057  av_log(s->avctx, AV_LOG_ERROR,
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 & CODEC_FLAG2_FAST) {
1068  for (i = 0; i < 6; i++) {
1069  if (cbp & 32)
1070  mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i);
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 & 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 
1120 static av_cold int mpeg_decode_init(AVCodecContext *avctx)
1121 {
1122  Mpeg1Context *s = avctx->priv_data;
1123  MpegEncContext *s2 = &s->mpeg_enc_ctx;
1124 
1125  ff_mpv_decode_defaults(s2);
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);
1137  ff_mpeg12_common_init(&s->mpeg_enc_ctx);
1138  ff_mpeg12_init_vlcs();
1139 
1140  s->mpeg_enc_ctx_allocated = 0;
1141  s->mpeg_enc_ctx.picture_number = 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 
1148 static int mpeg_decode_update_thread_context(AVCodecContext *avctx,
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 
1185 static const enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[] = {
1186 #if CONFIG_MPEG1_XVMC_HWACCEL
1187  AV_PIX_FMT_XVMC,
1188 #endif
1189 #if CONFIG_MPEG1_VDPAU_HWACCEL
1190  AV_PIX_FMT_VDPAU_MPEG1,
1191  AV_PIX_FMT_VDPAU,
1192 #endif
1193  AV_PIX_FMT_YUV420P,
1194  AV_PIX_FMT_NONE
1195 };
1196 
1197 static const enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[] = {
1198 #if CONFIG_MPEG2_XVMC_HWACCEL
1199  AV_PIX_FMT_XVMC,
1200 #endif
1201 #if CONFIG_MPEG2_VDPAU_HWACCEL
1202  AV_PIX_FMT_VDPAU_MPEG2,
1203  AV_PIX_FMT_VDPAU,
1204 #endif
1205 #if CONFIG_MPEG2_DXVA2_HWACCEL
1206  AV_PIX_FMT_DXVA2_VLD,
1207 #endif
1208 #if CONFIG_MPEG2_D3D11VA_HWACCEL
1209  AV_PIX_FMT_D3D11VA_VLD,
1210 #endif
1211 #if CONFIG_MPEG2_VAAPI_HWACCEL
1212  AV_PIX_FMT_VAAPI_VLD,
1213 #endif
1214  AV_PIX_FMT_YUV420P,
1215  AV_PIX_FMT_NONE
1216 };
1217 
1218 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
1219  AV_PIX_FMT_YUV422P,
1220  AV_PIX_FMT_NONE
1221 };
1222 
1223 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
1224  AV_PIX_FMT_YUV444P,
1225  AV_PIX_FMT_NONE
1226 };
1227 
1228 static inline int uses_vdpau(AVCodecContext *avctx) {
1229  return avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG1 || avctx->pix_fmt == AV_PIX_FMT_VDPAU_MPEG2;
1230 }
1231 
1232 static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
1233 {
1234  Mpeg1Context *s1 = avctx->priv_data;
1235  MpegEncContext *s = &s1->mpeg_enc_ctx;
1236  const enum AVPixelFormat *pix_fmts;
1237 
1238  if (CONFIG_GRAY && (avctx->flags & CODEC_FLAG_GRAY))
1239  return AV_PIX_FMT_GRAY8;
1240 
1241  if (s->chroma_format < 2)
1242  pix_fmts = avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO ?
1243  mpeg1_hwaccel_pixfmt_list_420 :
1244  mpeg2_hwaccel_pixfmt_list_420;
1245  else if (s->chroma_format == 2)
1246  pix_fmts = mpeg12_pixfmt_list_422;
1247  else
1248  pix_fmts = mpeg12_pixfmt_list_444;
1249 
1250  return ff_thread_get_format(avctx, pix_fmts);
1251 }
1252 
1253 static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
1254 {
1255  // until then pix_fmt may be changed right after codec init
1256  if (avctx->hwaccel || uses_vdpau(avctx))
1257  if (avctx->idct_algo == FF_IDCT_AUTO)
1258  avctx->idct_algo = FF_IDCT_SIMPLE;
1259 
1260  if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
1261  Mpeg1Context *s1 = avctx->priv_data;
1262  MpegEncContext *s = &s1->mpeg_enc_ctx;
1263 
1264  s->pack_pblocks = 1;
1265 #if FF_API_XVMC
1266  avctx->xvmc_acceleration = 2;
1267 #endif /* FF_API_XVMC */
1268  }
1269 }
1270 
1271 /* Call this function when we know all parameters.
1272  * It may be called in different places for MPEG-1 and MPEG-2. */
1273 static int mpeg_decode_postinit(AVCodecContext *avctx)
1274 {
1275  Mpeg1Context *s1 = avctx->priv_data;
1276  MpegEncContext *s = &s1->mpeg_enc_ctx;
1277  uint8_t old_permutation[64];
1278  int ret;
1279 
1280  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1281  // MPEG-1 aspect
1282  avctx->sample_aspect_ratio = av_d2q(1.0 / ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1283  } else { // MPEG-2
1284  // MPEG-2 aspect
1285  if (s->aspect_ratio_info > 1) {
1286  AVRational dar =
1287  av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1288  (AVRational) { s1->pan_scan.width,
1289  s1->pan_scan.height }),
1290  (AVRational) { s->width, s->height });
1291 
1292  /* We ignore the spec here and guess a bit as reality does not
1293  * match the spec, see for example res_change_ffmpeg_aspect.ts
1294  * and sequence-display-aspect.mpg.
1295  * issue1613, 621, 562 */
1296  if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1297  (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
1298  av_cmp_q(dar, (AVRational) { 16, 9 }))) {
1299  s->avctx->sample_aspect_ratio =
1300  av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1301  (AVRational) { s->width, s->height });
1302  } else {
1303  s->avctx->sample_aspect_ratio =
1304  av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1305  (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
1306 // issue1613 4/3 16/9 -> 16/9
1307 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1308 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
1309 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1310  ff_dlog(avctx, "aspect A %d/%d\n",
1311  ff_mpeg2_aspect[s->aspect_ratio_info].num,
1312  ff_mpeg2_aspect[s->aspect_ratio_info].den);
1313  ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1314  s->avctx->sample_aspect_ratio.den);
1315  }
1316  } else {
1317  s->avctx->sample_aspect_ratio =
1318  ff_mpeg2_aspect[s->aspect_ratio_info];
1319  }
1320  } // MPEG-2
1321 
1322  if (av_image_check_sar(s->width, s->height,
1323  avctx->sample_aspect_ratio) < 0) {
1324  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1325  avctx->sample_aspect_ratio.num,
1326  avctx->sample_aspect_ratio.den);
1327  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1328  }
1329 
1330  if ((s1->mpeg_enc_ctx_allocated == 0) ||
1331  avctx->coded_width != s->width ||
1332  avctx->coded_height != s->height ||
1333  s1->save_width != s->width ||
1334  s1->save_height != s->height ||
1335  av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
1336  (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
1337  0) {
1338  if (s1->mpeg_enc_ctx_allocated) {
1339  ParseContext pc = s->parse_context;
1340  s->parse_context.buffer = 0;
1341  ff_mpv_common_end(s);
1342  s->parse_context = pc;
1343  s1->mpeg_enc_ctx_allocated = 0;
1344  }
1345 
1346  ret = ff_set_dimensions(avctx, s->width, s->height);
1347  if (ret < 0)
1348  return ret;
1349 
1350  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
1351  avctx->rc_max_rate = s->bit_rate;
1352  } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
1353  (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
1354  avctx->bit_rate = s->bit_rate;
1355  }
1356  s1->save_aspect = s->avctx->sample_aspect_ratio;
1357  s1->save_width = s->width;
1358  s1->save_height = s->height;
1359  s1->save_progressive_seq = s->progressive_sequence;
1360 
1361  /* low_delay may be forced, in this case we will have B-frames
1362  * that behave like P-frames. */
1363  avctx->has_b_frames = !s->low_delay;
1364 
1365  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1366  // MPEG-1 fps
1367  avctx->framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
1368  avctx->ticks_per_frame = 1;
1369 
1370  avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1371  } else { // MPEG-2
1372  // MPEG-2 fps
1373  av_reduce(&s->avctx->framerate.num,
1374  &s->avctx->framerate.den,
1375  ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1376  ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1377  1 << 30);
1378  avctx->ticks_per_frame = 2;
1379 
1380  switch (s->chroma_format) {
1381  case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
1382  case 2:
1383  case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
1384  }
1385  } // MPEG-2
1386 
1387  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1388  setup_hwaccel_for_pixfmt(avctx);
1389 
1390  /* Quantization matrices may need reordering
1391  * if DCT permutation is changed. */
1392  memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1393 
1394  ff_mpv_idct_init(s);
1395  if ((ret = ff_mpv_common_init(s)) < 0)
1396  return ret;
1397 
1398  quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
1399  quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
1400  quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
1401  quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
1402 
1403  s1->mpeg_enc_ctx_allocated = 1;
1404  }
1405  return 0;
1406 }
1407 
1408 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
1409  int buf_size)
1410 {
1411  Mpeg1Context *s1 = avctx->priv_data;
1412  MpegEncContext *s = &s1->mpeg_enc_ctx;
1413  int ref, f_code, vbv_delay;
1414 
1415  init_get_bits(&s->gb, buf, buf_size * 8);
1416 
1417  ref = get_bits(&s->gb, 10); /* temporal ref */
1418  s->pict_type = get_bits(&s->gb, 3);
1419  if (s->pict_type == 0 || s->pict_type > 3)
1420  return AVERROR_INVALIDDATA;
1421 
1422  vbv_delay = get_bits(&s->gb, 16);
1423  s->vbv_delay = vbv_delay;
1424  if (s->pict_type == AV_PICTURE_TYPE_P ||
1425  s->pict_type == AV_PICTURE_TYPE_B) {
1426  s->full_pel[0] = get_bits1(&s->gb);
1427  f_code = get_bits(&s->gb, 3);
1428  if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1429  return AVERROR_INVALIDDATA;
1430  f_code += !f_code;
1431  s->mpeg_f_code[0][0] = f_code;
1432  s->mpeg_f_code[0][1] = f_code;
1433  }
1434  if (s->pict_type == AV_PICTURE_TYPE_B) {
1435  s->full_pel[1] = get_bits1(&s->gb);
1436  f_code = get_bits(&s->gb, 3);
1437  if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1438  return AVERROR_INVALIDDATA;
1439  f_code += !f_code;
1440  s->mpeg_f_code[1][0] = f_code;
1441  s->mpeg_f_code[1][1] = f_code;
1442  }
1443  s->current_picture.f->pict_type = s->pict_type;
1444  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1445 
1446  if (avctx->debug & FF_DEBUG_PICT_INFO)
1447  av_log(avctx, AV_LOG_DEBUG,
1448  "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1449 
1450  s->y_dc_scale = 8;
1451  s->c_dc_scale = 8;
1452  return 0;
1453 }
1454 
1455 static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
1456 {
1457  MpegEncContext *s = &s1->mpeg_enc_ctx;
1458  int horiz_size_ext, vert_size_ext;
1459  int bit_rate_ext;
1460 
1461  skip_bits(&s->gb, 1); /* profile and level esc*/
1462  s->avctx->profile = get_bits(&s->gb, 3);
1463  s->avctx->level = get_bits(&s->gb, 4);
1464  s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1465  s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1466  horiz_size_ext = get_bits(&s->gb, 2);
1467  vert_size_ext = get_bits(&s->gb, 2);
1468  s->width |= (horiz_size_ext << 12);
1469  s->height |= (vert_size_ext << 12);
1470  bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1471  s->bit_rate += (bit_rate_ext << 18) * 400;
1472  check_marker(&s->gb, "after bit rate extension");
1473  s->avctx->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1474 
1475  s->low_delay = get_bits1(&s->gb);
1476  if (s->avctx->flags & CODEC_FLAG_LOW_DELAY)
1477  s->low_delay = 1;
1478 
1479  s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1480  s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1481 
1482  ff_dlog(s->avctx, "sequence extension\n");
1483  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1484 
1485  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1486  av_log(s->avctx, AV_LOG_DEBUG,
1487  "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%d\n",
1488  s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1489  s->avctx->rc_buffer_size, s->bit_rate);
1490 }
1491 
1492 static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
1493 {
1494  MpegEncContext *s = &s1->mpeg_enc_ctx;
1495  int color_description, w, h;
1496 
1497  skip_bits(&s->gb, 3); /* video format */
1498  color_description = get_bits1(&s->gb);
1499  if (color_description) {
1500  s->avctx->color_primaries = get_bits(&s->gb, 8);
1501  s->avctx->color_trc = get_bits(&s->gb, 8);
1502  s->avctx->colorspace = get_bits(&s->gb, 8);
1503  }
1504  w = get_bits(&s->gb, 14);
1505  skip_bits(&s->gb, 1); // marker
1506  h = get_bits(&s->gb, 14);
1507  // remaining 3 bits are zero padding
1508 
1509  s1->pan_scan.width = 16 * w;
1510  s1->pan_scan.height = 16 * h;
1511 
1512  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1513  av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1514 }
1515 
1516 static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
1517 {
1518  MpegEncContext *s = &s1->mpeg_enc_ctx;
1519  int i, nofco;
1520 
1521  nofco = 1;
1522  if (s->progressive_sequence) {
1523  if (s->repeat_first_field) {
1524  nofco++;
1525  if (s->top_field_first)
1526  nofco++;
1527  }
1528  } else {
1529  if (s->picture_structure == PICT_FRAME) {
1530  nofco++;
1531  if (s->repeat_first_field)
1532  nofco++;
1533  }
1534  }
1535  for (i = 0; i < nofco; i++) {
1536  s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1537  skip_bits(&s->gb, 1); // marker
1538  s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1539  skip_bits(&s->gb, 1); // marker
1540  }
1541 
1542  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1543  av_log(s->avctx, AV_LOG_DEBUG,
1544  "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1545  s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1546  s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1547  s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1548 }
1549 
1550 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1551  uint16_t matrix1[64], int intra)
1552 {
1553  int i;
1554 
1555  for (i = 0; i < 64; i++) {
1556  int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1557  int v = get_bits(&s->gb, 8);
1558  if (v == 0) {
1559  av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1560  return AVERROR_INVALIDDATA;
1561  }
1562  if (intra && i == 0 && v != 8) {
1563  av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1564  v = 8; // needed by pink.mpg / issue1046
1565  }
1566  matrix0[j] = v;
1567  if (matrix1)
1568  matrix1[j] = v;
1569  }
1570  return 0;
1571 }
1572 
1573 static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
1574 {
1575  ff_dlog(s->avctx, "matrix extension\n");
1576 
1577  if (get_bits1(&s->gb))
1578  load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1579  if (get_bits1(&s->gb))
1580  load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1581  if (get_bits1(&s->gb))
1582  load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1583  if (get_bits1(&s->gb))
1584  load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1585 }
1586 
1587 static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
1588 {
1589  MpegEncContext *s = &s1->mpeg_enc_ctx;
1590 
1591  s->full_pel[0] = s->full_pel[1] = 0;
1592  s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1593  s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1594  s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1595  s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1596  if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1597  av_log(s->avctx, AV_LOG_ERROR,
1598  "Missing picture start code, guessing missing values\n");
1599  if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1600  if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1601  s->pict_type = AV_PICTURE_TYPE_I;
1602  else
1603  s->pict_type = AV_PICTURE_TYPE_P;
1604  } else
1605  s->pict_type = AV_PICTURE_TYPE_B;
1606  s->current_picture.f->pict_type = s->pict_type;
1607  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1608  }
1609  s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1610  s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1611  s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1612  s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1613 
1614  s->intra_dc_precision = get_bits(&s->gb, 2);
1615  s->picture_structure = get_bits(&s->gb, 2);
1616  s->top_field_first = get_bits1(&s->gb);
1617  s->frame_pred_frame_dct = get_bits1(&s->gb);
1618  s->concealment_motion_vectors = get_bits1(&s->gb);
1619  s->q_scale_type = get_bits1(&s->gb);
1620  s->intra_vlc_format = get_bits1(&s->gb);
1621  s->alternate_scan = get_bits1(&s->gb);
1622  s->repeat_first_field = get_bits1(&s->gb);
1623  s->chroma_420_type = get_bits1(&s->gb);
1624  s->progressive_frame = get_bits1(&s->gb);
1625 
1626  if (s->alternate_scan) {
1627  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1628  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1629  } else {
1630  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1631  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1632  }
1633 
1634  /* composite display not parsed */
1635  ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1636  ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1637  ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1638  ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1639  ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1640  ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1641  ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1642  ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1643  ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1644 }
1645 
1646 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1647 {
1648  AVCodecContext *avctx = s->avctx;
1649  Mpeg1Context *s1 = (Mpeg1Context *) s;
1650  int ret;
1651 
1652  /* start frame decoding */
1653  if (s->first_field || s->picture_structure == PICT_FRAME) {
1654  AVFrameSideData *pan_scan;
1655 
1656  if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1657  return ret;
1658 
1659  ff_mpeg_er_frame_start(s);
1660 
1661  /* first check if we must repeat the frame */
1662  s->current_picture_ptr->f->repeat_pict = 0;
1663  if (s->repeat_first_field) {
1664  if (s->progressive_sequence) {
1665  if (s->top_field_first)
1666  s->current_picture_ptr->f->repeat_pict = 4;
1667  else
1668  s->current_picture_ptr->f->repeat_pict = 2;
1669  } else if (s->progressive_frame) {
1670  s->current_picture_ptr->f->repeat_pict = 1;
1671  }
1672  }
1673 
1674  pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
1675  AV_FRAME_DATA_PANSCAN,
1676  sizeof(s1->pan_scan));
1677  if (!pan_scan)
1678  return AVERROR(ENOMEM);
1679  memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1680 
1681  if (s1->a53_caption) {
1682  AVFrameSideData *sd = av_frame_new_side_data(
1683  s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1684  s1->a53_caption_size);
1685  if (sd)
1686  memcpy(sd->data, s1->a53_caption, s1->a53_caption_size);
1687  av_freep(&s1->a53_caption);
1688  }
1689 
1690  if (s1->has_stereo3d) {
1691  AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
1692  if (!stereo)
1693  return AVERROR(ENOMEM);
1694 
1695  *stereo = s1->stereo3d;
1696  s1->has_stereo3d = 0;
1697  }
1698 
1699  if (s1->has_afd) {
1700  AVFrameSideData *sd =
1701  av_frame_new_side_data(s->current_picture_ptr->f,
1702  AV_FRAME_DATA_AFD, 1);
1703  if (!sd)
1704  return AVERROR(ENOMEM);
1705 
1706  *sd->data = s1->afd;
1707  s1->has_afd = 0;
1708  }
1709 
1710  if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1711  ff_thread_finish_setup(avctx);
1712  } else { // second field
1713  int i;
1714 
1715  if (!s->current_picture_ptr) {
1716  av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1717  return AVERROR_INVALIDDATA;
1718  }
1719 
1720  if (s->avctx->hwaccel &&
1721  (s->avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
1722  if (s->avctx->hwaccel->end_frame(s->avctx) < 0)
1723  av_log(avctx, AV_LOG_ERROR,
1724  "hardware accelerator failed to decode first field\n");
1725  }
1726 
1727  for (i = 0; i < 4; i++) {
1728  s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1729  if (s->picture_structure == PICT_BOTTOM_FIELD)
1730  s->current_picture.f->data[i] +=
1731  s->current_picture_ptr->f->linesize[i];
1732  }
1733  }
1734 
1735  if (avctx->hwaccel) {
1736  if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1737  return ret;
1738  }
1739 
1740  return 0;
1741 }
1742 
1743 #define DECODE_SLICE_ERROR -1
1744 #define DECODE_SLICE_OK 0
1745 
1746 /**
1747  * Decode a slice.
1748  * MpegEncContext.mb_y must be set to the MB row from the startcode.
1749  * @return DECODE_SLICE_ERROR if the slice is damaged,
1750  * DECODE_SLICE_OK if this slice is OK
1751  */
1752 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1753  const uint8_t **buf, int buf_size)
1754 {
1755  AVCodecContext *avctx = s->avctx;
1756  const int lowres = s->avctx->lowres;
1757  const int field_pic = s->picture_structure != PICT_FRAME;
1758  int ret;
1759 
1760  s->resync_mb_x =
1761  s->resync_mb_y = -1;
1762 
1763  av_assert0(mb_y < s->mb_height);
1764 
1765  init_get_bits(&s->gb, *buf, buf_size * 8);
1766  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1767  skip_bits(&s->gb, 3);
1768 
1769  ff_mpeg1_clean_buffers(s);
1770  s->interlaced_dct = 0;
1771 
1772  s->qscale = get_qscale(s);
1773 
1774  if (s->qscale == 0) {
1775  av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1776  return AVERROR_INVALIDDATA;
1777  }
1778 
1779  /* extra slice info */
1780  if (skip_1stop_8data_bits(&s->gb) < 0)
1781  return AVERROR_INVALIDDATA;
1782 
1783  s->mb_x = 0;
1784 
1785  if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1786  skip_bits1(&s->gb);
1787  } else {
1788  while (get_bits_left(&s->gb) > 0) {
1789  int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1790  MBINCR_VLC_BITS, 2);
1791  if (code < 0) {
1792  av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1793  return AVERROR_INVALIDDATA;
1794  }
1795  if (code >= 33) {
1796  if (code == 33)
1797  s->mb_x += 33;
1798  /* otherwise, stuffing, nothing to do */
1799  } else {
1800  s->mb_x += code;
1801  break;
1802  }
1803  }
1804  }
1805 
1806  if (s->mb_x >= (unsigned) s->mb_width) {
1807  av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1808  return AVERROR_INVALIDDATA;
1809  }
1810 
1811  if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1812  const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1813  int start_code = -1;
1814  buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1815  if (buf_end < *buf + buf_size)
1816  buf_end -= 4;
1817  s->mb_y = mb_y;
1818  if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1819  return DECODE_SLICE_ERROR;
1820  *buf = buf_end;
1821  return DECODE_SLICE_OK;
1822  }
1823 
1824  s->resync_mb_x = s->mb_x;
1825  s->resync_mb_y = s->mb_y = mb_y;
1826  s->mb_skip_run = 0;
1827  ff_init_block_index(s);
1828 
1829  if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1830  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1831  av_log(s->avctx, AV_LOG_DEBUG,
1832  "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",
1833  s->qscale,
1834  s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1835  s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1836  s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1837  (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1838  (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1839  s->progressive_sequence ? "ps" : "",
1840  s->progressive_frame ? "pf" : "",
1841  s->alternate_scan ? "alt" : "",
1842  s->top_field_first ? "top" : "",
1843  s->intra_dc_precision, s->picture_structure,
1844  s->frame_pred_frame_dct, s->concealment_motion_vectors,
1845  s->q_scale_type, s->intra_vlc_format,
1846  s->repeat_first_field, s->chroma_420_type ? "420" : "");
1847  }
1848  }
1849 
1850  for (;;) {
1851  // If 1, we memcpy blocks in xvmcvideo.
1852  if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1853  ff_xvmc_init_block(s); // set s->block
1854 
1855  if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1856  return ret;
1857 
1858  // Note motion_val is normally NULL unless we want to extract the MVs.
1859  if (s->current_picture.motion_val[0] && !s->encoding) {
1860  const int wrap = s->b8_stride;
1861  int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1862  int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1863  int motion_x, motion_y, dir, i;
1864 
1865  for (i = 0; i < 2; i++) {
1866  for (dir = 0; dir < 2; dir++) {
1867  if (s->mb_intra ||
1868  (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1869  motion_x = motion_y = 0;
1870  } else if (s->mv_type == MV_TYPE_16X16 ||
1871  (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1872  motion_x = s->mv[dir][0][0];
1873  motion_y = s->mv[dir][0][1];
1874  } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1875  motion_x = s->mv[dir][i][0];
1876  motion_y = s->mv[dir][i][1];
1877  }
1878 
1879  s->current_picture.motion_val[dir][xy][0] = motion_x;
1880  s->current_picture.motion_val[dir][xy][1] = motion_y;
1881  s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1882  s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1883  s->current_picture.ref_index [dir][b8_xy] =
1884  s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1885  av_assert2(s->field_select[dir][i] == 0 ||
1886  s->field_select[dir][i] == 1);
1887  }
1888  xy += wrap;
1889  b8_xy += 2;
1890  }
1891  }
1892 
1893  s->dest[0] += 16 >> lowres;
1894  s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1895  s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1896 
1897  ff_mpv_decode_mb(s, s->block);
1898 
1899  if (++s->mb_x >= s->mb_width) {
1900  const int mb_size = 16 >> s->avctx->lowres;
1901 
1902  ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1903  ff_mpv_report_decode_progress(s);
1904 
1905  s->mb_x = 0;
1906  s->mb_y += 1 << field_pic;
1907 
1908  if (s->mb_y >= s->mb_height) {
1909  int left = get_bits_left(&s->gb);
1910  int is_d10 = s->chroma_format == 2 &&
1911  s->pict_type == AV_PICTURE_TYPE_I &&
1912  avctx->profile == 0 && avctx->level == 5 &&
1913  s->intra_dc_precision == 2 &&
1914  s->q_scale_type == 1 && s->alternate_scan == 0 &&
1915  s->progressive_frame == 0
1916  /* vbv_delay == 0xBBB || 0xE10 */;
1917 
1918  if (left >= 32 && !is_d10) {
1919  GetBitContext gb = s->gb;
1920  align_get_bits(&gb);
1921  if (show_bits(&gb, 24) == 0x060E2B) {
1922  av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1923  is_d10 = 1;
1924  }
1925  }
1926 
1927  if (left < 0 ||
1928  (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1929  ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1930  av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X\n",
1931  left, show_bits(&s->gb, FFMIN(left, 23)));
1932  return AVERROR_INVALIDDATA;
1933  } else
1934  goto eos;
1935  }
1936  // There are some files out there which are missing the last slice
1937  // in cases where the slice is completely outside the visible
1938  // area, we detect this here instead of running into the end expecting
1939  // more data
1940  if (s->mb_y >= ((s->height + 15) >> 4) &&
1941  s->progressive_frame &&
1942  !s->progressive_sequence &&
1943  get_bits_left(&s->gb) <= 8 &&
1944  get_bits_left(&s->gb) >= 0 &&
1945  s->mb_skip_run == -1 &&
1946  show_bits(&s->gb, 8) == 0)
1947  goto eos;
1948 
1949  ff_init_block_index(s);
1950  }
1951 
1952  /* skip mb handling */
1953  if (s->mb_skip_run == -1) {
1954  /* read increment again */
1955  s->mb_skip_run = 0;
1956  for (;;) {
1957  int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1958  MBINCR_VLC_BITS, 2);
1959  if (code < 0) {
1960  av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1961  return AVERROR_INVALIDDATA;
1962  }
1963  if (code >= 33) {
1964  if (code == 33) {
1965  s->mb_skip_run += 33;
1966  } else if (code == 35) {
1967  if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1968  av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1969  return AVERROR_INVALIDDATA;
1970  }
1971  goto eos; /* end of slice */
1972  }
1973  /* otherwise, stuffing, nothing to do */
1974  } else {
1975  s->mb_skip_run += code;
1976  break;
1977  }
1978  }
1979  if (s->mb_skip_run) {
1980  int i;
1981  if (s->pict_type == AV_PICTURE_TYPE_I) {
1982  av_log(s->avctx, AV_LOG_ERROR,
1983  "skipped MB in I frame at %d %d\n", s->mb_x, s->mb_y);
1984  return AVERROR_INVALIDDATA;
1985  }
1986 
1987  /* skip mb */
1988  s->mb_intra = 0;
1989  for (i = 0; i < 12; i++)
1990  s->block_last_index[i] = -1;
1991  if (s->picture_structure == PICT_FRAME)
1992  s->mv_type = MV_TYPE_16X16;
1993  else
1994  s->mv_type = MV_TYPE_FIELD;
1995  if (s->pict_type == AV_PICTURE_TYPE_P) {
1996  /* if P type, zero motion vector is implied */
1997  s->mv_dir = MV_DIR_FORWARD;
1998  s->mv[0][0][0] = s->mv[0][0][1] = 0;
1999  s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
2000  s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
2001  s->field_select[0][0] = (s->picture_structure - 1) & 1;
2002  } else {
2003  /* if B type, reuse previous vectors and directions */
2004  s->mv[0][0][0] = s->last_mv[0][0][0];
2005  s->mv[0][0][1] = s->last_mv[0][0][1];
2006  s->mv[1][0][0] = s->last_mv[1][0][0];
2007  s->mv[1][0][1] = s->last_mv[1][0][1];
2008  }
2009  }
2010  }
2011  }
2012 eos: // end of slice
2013  if (get_bits_left(&s->gb) < 0) {
2014  av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
2015  return AVERROR_INVALIDDATA;
2016  }
2017  *buf += (get_bits_count(&s->gb) - 1) / 8;
2018  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);
2019  return 0;
2020 }
2021 
2022 static int slice_decode_thread(AVCodecContext *c, void *arg)
2023 {
2024  MpegEncContext *s = *(void **) arg;
2025  const uint8_t *buf = s->gb.buffer;
2026  int mb_y = s->start_mb_y;
2027  const int field_pic = s->picture_structure != PICT_FRAME;
2028 
2029  s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
2030 
2031  for (;;) {
2032  uint32_t start_code;
2033  int ret;
2034 
2035  ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2036  emms_c();
2037  ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2038  ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2039  s->start_mb_y, s->end_mb_y, s->er.error_count);
2040  if (ret < 0) {
2041  if (c->err_recognition & AV_EF_EXPLODE)
2042  return ret;
2043  if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2044  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2045  s->mb_x, s->mb_y,
2046  ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2047  } else {
2048  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2049  s->mb_x - 1, s->mb_y,
2050  ER_AC_END | ER_DC_END | ER_MV_END);
2051  }
2052 
2053  if (s->mb_y == s->end_mb_y)
2054  return 0;
2055 
2056  start_code = -1;
2057  buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2058  mb_y = start_code - SLICE_MIN_START_CODE;
2059  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2060  mb_y += (*buf&0xE0)<<2;
2061  mb_y <<= field_pic;
2062  if (s->picture_structure == PICT_BOTTOM_FIELD)
2063  mb_y++;
2064  if (mb_y < 0 || mb_y >= s->end_mb_y)
2065  return AVERROR_INVALIDDATA;
2066  }
2067 }
2068 
2069 /**
2070  * Handle slice ends.
2071  * @return 1 if it seems to be the last slice
2072  */
2073 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2074 {
2075  Mpeg1Context *s1 = avctx->priv_data;
2076  MpegEncContext *s = &s1->mpeg_enc_ctx;
2077 
2078  if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2079  return 0;
2080 
2081  if (s->avctx->hwaccel) {
2082  if (s->avctx->hwaccel->end_frame(s->avctx) < 0)
2083  av_log(avctx, AV_LOG_ERROR,
2084  "hardware accelerator failed to decode picture\n");
2085  }
2086 
2087  /* end of slice reached */
2088  if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2089  /* end of image */
2090 
2091  ff_er_frame_end(&s->er);
2092 
2093  ff_mpv_frame_end(s);
2094 
2095  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2096  int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2097  if (ret < 0)
2098  return ret;
2099  ff_print_debug_info(s, s->current_picture_ptr, pict);
2100  ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2101  } else {
2102  if (avctx->active_thread_type & FF_THREAD_FRAME)
2103  s->picture_number++;
2104  /* latency of 1 frame for I- and P-frames */
2105  /* XXX: use another variable than picture_number */
2106  if (s->last_picture_ptr) {
2107  int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2108  if (ret < 0)
2109  return ret;
2110  ff_print_debug_info(s, s->last_picture_ptr, pict);
2111  ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2112  }
2113  }
2114 
2115  return 1;
2116  } else {
2117  return 0;
2118  }
2119 }
2120 
2121 static int mpeg1_decode_sequence(AVCodecContext *avctx,
2122  const uint8_t *buf, int buf_size)
2123 {
2124  Mpeg1Context *s1 = avctx->priv_data;
2125  MpegEncContext *s = &s1->mpeg_enc_ctx;
2126  int width, height;
2127  int i, v, j;
2128 
2129  init_get_bits(&s->gb, buf, buf_size * 8);
2130 
2131  width = get_bits(&s->gb, 12);
2132  height = get_bits(&s->gb, 12);
2133  if (width == 0 || height == 0) {
2134  av_log(avctx, AV_LOG_WARNING,
2135  "Invalid horizontal or vertical size value.\n");
2136  if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2137  return AVERROR_INVALIDDATA;
2138  }
2139  s->aspect_ratio_info = get_bits(&s->gb, 4);
2140  if (s->aspect_ratio_info == 0) {
2141  av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2142  if (avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_COMPLIANT))
2143  return AVERROR_INVALIDDATA;
2144  }
2145  s->frame_rate_index = get_bits(&s->gb, 4);
2146  if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2147  av_log(avctx, AV_LOG_WARNING,
2148  "frame_rate_index %d is invalid\n", s->frame_rate_index);
2149  s->frame_rate_index = 1;
2150  }
2151  s->bit_rate = get_bits(&s->gb, 18) * 400;
2152  if (check_marker(&s->gb, "in sequence header") == 0) {
2153  return AVERROR_INVALIDDATA;
2154  }
2155  s->width = width;
2156  s->height = height;
2157 
2158  s->avctx->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2159  skip_bits(&s->gb, 1);
2160 
2161  /* get matrix */
2162  if (get_bits1(&s->gb)) {
2163  load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2164  } else {
2165  for (i = 0; i < 64; i++) {
2166  j = s->idsp.idct_permutation[i];
2167  v = ff_mpeg1_default_intra_matrix[i];
2168  s->intra_matrix[j] = v;
2169  s->chroma_intra_matrix[j] = v;
2170  }
2171  }
2172  if (get_bits1(&s->gb)) {
2173  load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2174  } else {
2175  for (i = 0; i < 64; i++) {
2176  int j = s->idsp.idct_permutation[i];
2177  v = ff_mpeg1_default_non_intra_matrix[i];
2178  s->inter_matrix[j] = v;
2179  s->chroma_inter_matrix[j] = v;
2180  }
2181  }
2182 
2183  if (show_bits(&s->gb, 23) != 0) {
2184  av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2185  return AVERROR_INVALIDDATA;
2186  }
2187 
2188  /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2189  s->progressive_sequence = 1;
2190  s->progressive_frame = 1;
2191  s->picture_structure = PICT_FRAME;
2192  s->first_field = 0;
2193  s->frame_pred_frame_dct = 1;
2194  s->chroma_format = 1;
2195  s->codec_id =
2196  s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2197  s->out_format = FMT_MPEG1;
2198  s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2199  if (s->avctx->flags & CODEC_FLAG_LOW_DELAY)
2200  s->low_delay = 1;
2201 
2202  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2203  av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%d, aspect_ratio_info: %d \n",
2204  s->avctx->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
2205 
2206  return 0;
2207 }
2208 
2209 static int vcr2_init_sequence(AVCodecContext *avctx)
2210 {
2211  Mpeg1Context *s1 = avctx->priv_data;
2212  MpegEncContext *s = &s1->mpeg_enc_ctx;
2213  int i, v, ret;
2214 
2215  /* start new MPEG-1 context decoding */
2216  s->out_format = FMT_MPEG1;
2217  if (s1->mpeg_enc_ctx_allocated) {
2218  ff_mpv_common_end(s);
2219  s1->mpeg_enc_ctx_allocated = 0;
2220  }
2221  s->width = avctx->coded_width;
2222  s->height = avctx->coded_height;
2223  avctx->has_b_frames = 0; // true?
2224  s->low_delay = 1;
2225 
2226  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2227  setup_hwaccel_for_pixfmt(avctx);
2228 
2229  ff_mpv_idct_init(s);
2230  if ((ret = ff_mpv_common_init(s)) < 0)
2231  return ret;
2232  s1->mpeg_enc_ctx_allocated = 1;
2233 
2234  for (i = 0; i < 64; i++) {
2235  int j = s->idsp.idct_permutation[i];
2236  v = ff_mpeg1_default_intra_matrix[i];
2237  s->intra_matrix[j] = v;
2238  s->chroma_intra_matrix[j] = v;
2239 
2240  v = ff_mpeg1_default_non_intra_matrix[i];
2241  s->inter_matrix[j] = v;
2242  s->chroma_inter_matrix[j] = v;
2243  }
2244 
2245  s->progressive_sequence = 1;
2246  s->progressive_frame = 1;
2247  s->picture_structure = PICT_FRAME;
2248  s->first_field = 0;
2249  s->frame_pred_frame_dct = 1;
2250  s->chroma_format = 1;
2251  if (s->codec_tag == AV_RL32("BW10")) {
2252  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2253  } else {
2254  s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2255  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2256  }
2257  s1->save_width = s->width;
2258  s1->save_height = s->height;
2259  s1->save_progressive_seq = s->progressive_sequence;
2260  return 0;
2261 }
2262 
2263 static int mpeg_decode_a53_cc(AVCodecContext *avctx,
2264  const uint8_t *p, int buf_size)
2265 {
2266  Mpeg1Context *s1 = avctx->priv_data;
2267 
2268  if (buf_size >= 6 &&
2269  p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2270  p[4] == 3 && (p[5] & 0x40)) {
2271  /* extract A53 Part 4 CC data */
2272  int cc_count = p[5] & 0x1f;
2273  if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2274  av_freep(&s1->a53_caption);
2275  s1->a53_caption_size = cc_count * 3;
2276  s1->a53_caption = av_malloc(s1->a53_caption_size);
2277  if (s1->a53_caption)
2278  memcpy(s1->a53_caption, p + 7, s1->a53_caption_size);
2279  }
2280  return 1;
2281  } else if (buf_size >= 11 &&
2282  p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2283  /* extract DVD CC data */
2284  int cc_count = 0;
2285  int i;
2286  // There is a caption count field in the data, but it is often
2287  // incorect. So count the number of captions present.
2288  for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2289  cc_count++;
2290  // Transform the DVD format into A53 Part 4 format
2291  if (cc_count > 0) {
2292  av_freep(&s1->a53_caption);
2293  s1->a53_caption_size = cc_count * 6;
2294  s1->a53_caption = av_malloc(s1->a53_caption_size);
2295  if (s1->a53_caption) {
2296  uint8_t field1 = !!(p[4] & 0x80);
2297  uint8_t *cap = s1->a53_caption;
2298  p += 5;
2299  for (i = 0; i < cc_count; i++) {
2300  cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2301  cap[1] = p[1];
2302  cap[2] = p[2];
2303  cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2304  cap[4] = p[4];
2305  cap[5] = p[5];
2306  cap += 6;
2307  p += 6;
2308  }
2309  }
2310  }
2311  return 1;
2312  }
2313  return 0;
2314 }
2315 
2316 static void mpeg_decode_user_data(AVCodecContext *avctx,
2317  const uint8_t *p, int buf_size)
2318 {
2319  Mpeg1Context *s = avctx->priv_data;
2320  const uint8_t *buf_end = p + buf_size;
2321  Mpeg1Context *s1 = avctx->priv_data;
2322 
2323 #if 0
2324  int i;
2325  for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2326  av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2327  }
2328  av_log(avctx, AV_LOG_ERROR, "\n");
2329 #endif
2330 
2331  if (buf_size > 29){
2332  int i;
2333  for(i=0; i<20; i++)
2334  if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2335  s->tmpgexs= 1;
2336  }
2337  }
2338  /* we parse the DTG active format information */
2339  if (buf_end - p >= 5 &&
2340  p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2341  int flags = p[4];
2342  p += 5;
2343  if (flags & 0x80) {
2344  /* skip event id */
2345  p += 2;
2346  }
2347  if (flags & 0x40) {
2348  if (buf_end - p < 1)
2349  return;
2350 #if FF_API_AFD
2351 FF_DISABLE_DEPRECATION_WARNINGS
2352  avctx->dtg_active_format = p[0] & 0x0f;
2353 FF_ENABLE_DEPRECATION_WARNINGS
2354 #endif /* FF_API_AFD */
2355  s1->has_afd = 1;
2356  s1->afd = p[0] & 0x0f;
2357  }
2358  } else if (buf_end - p >= 6 &&
2359  p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2360  p[4] == 0x03) { // S3D_video_format_length
2361  // the 0x7F mask ignores the reserved_bit value
2362  const uint8_t S3D_video_format_type = p[5] & 0x7F;
2363 
2364  if (S3D_video_format_type == 0x03 ||
2365  S3D_video_format_type == 0x04 ||
2366  S3D_video_format_type == 0x08 ||
2367  S3D_video_format_type == 0x23) {
2368 
2369  s1->has_stereo3d = 1;
2370 
2371  switch (S3D_video_format_type) {
2372  case 0x03:
2373  s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
2374  break;
2375  case 0x04:
2376  s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
2377  break;
2378  case 0x08:
2379  s1->stereo3d.type = AV_STEREO3D_2D;
2380  break;
2381  case 0x23:
2382  s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2383  break;
2384  }
2385  }
2386  } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2387  return;
2388  }
2389 }
2390 
2391 static void mpeg_decode_gop(AVCodecContext *avctx,
2392  const uint8_t *buf, int buf_size)
2393 {
2394  Mpeg1Context *s1 = avctx->priv_data;
2395  MpegEncContext *s = &s1->mpeg_enc_ctx;
2396  int broken_link;
2397  int64_t tc;
2398 
2399  init_get_bits(&s->gb, buf, buf_size * 8);
2400 
2401  tc = avctx->timecode_frame_start = get_bits(&s->gb, 25);
2402 
2403  s->closed_gop = get_bits1(&s->gb);
2404  /* broken_link indicate that after editing the
2405  * reference frames of the first B-Frames after GOP I-Frame
2406  * are missing (open gop) */
2407  broken_link = get_bits1(&s->gb);
2408 
2409  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2410  char tcbuf[AV_TIMECODE_STR_SIZE];
2411  av_timecode_make_mpeg_tc_string(tcbuf, tc);
2412  av_log(s->avctx, AV_LOG_DEBUG,
2413  "GOP (%s) closed_gop=%d broken_link=%d\n",
2414  tcbuf, s->closed_gop, broken_link);
2415  }
2416 }
2417 
2418 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2419  int *got_output, const uint8_t *buf, int buf_size)
2420 {
2421  Mpeg1Context *s = avctx->priv_data;
2422  MpegEncContext *s2 = &s->mpeg_enc_ctx;
2423  const uint8_t *buf_ptr = buf;
2424  const uint8_t *buf_end = buf + buf_size;
2425  int ret, input_size;
2426  int last_code = 0, skip_frame = 0;
2427  int picture_start_code_seen = 0;
2428 
2429  for (;;) {
2430  /* find next start code */
2431  uint32_t start_code = -1;
2432  buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2433  if (start_code > 0x1ff) {
2434  if (!skip_frame) {
2435  if (HAVE_THREADS &&
2436  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2437  !avctx->hwaccel) {
2438  int i;
2439  av_assert0(avctx->thread_count > 1);
2440 
2441  avctx->execute(avctx, slice_decode_thread,
2442  &s2->thread_context[0], NULL,
2443  s->slice_count, sizeof(void *));
2444  for (i = 0; i < s->slice_count; i++)
2445  s2->er.error_count += s2->thread_context[i]->er.error_count;
2446  }
2447 
2448  if ((CONFIG_MPEG_VDPAU_DECODER || CONFIG_MPEG1_VDPAU_DECODER)
2449  && uses_vdpau(avctx))
2450  ff_vdpau_mpeg_picture_complete(s2, buf, buf_size, s->slice_count);
2451 
2452  ret = slice_end(avctx, picture);
2453  if (ret < 0)
2454  return ret;
2455  else if (ret) {
2456  // FIXME: merge with the stuff in mpeg_decode_slice
2457  if (s2->last_picture_ptr || s2->low_delay)
2458  *got_output = 1;
2459  }
2460  }
2461  s2->pict_type = 0;
2462 
2463  if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2464  return AVERROR_INVALIDDATA;
2465 
2466  return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2467  }
2468 
2469  input_size = buf_end - buf_ptr;
2470 
2471  if (avctx->debug & FF_DEBUG_STARTCODE)
2472  av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2473  start_code, buf_ptr - buf, input_size);
2474 
2475  /* prepare data for next start code */
2476  switch (start_code) {
2477  case SEQ_START_CODE:
2478  if (last_code == 0) {
2479  mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2480  if (buf != avctx->extradata)
2481  s->sync = 1;
2482  } else {
2483  av_log(avctx, AV_LOG_ERROR,
2484  "ignoring SEQ_START_CODE after %X\n", last_code);
2485  if (avctx->err_recognition & AV_EF_EXPLODE)
2486  return AVERROR_INVALIDDATA;
2487  }
2488  break;
2489 
2490  case PICTURE_START_CODE:
2491  if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2492  /* If it's a frame picture, there can't be more than one picture header.
2493  Yet, it does happen and we need to handle it. */
2494  av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2495  break;
2496  }
2497  picture_start_code_seen = 1;
2498 
2499  if (s2->width <= 0 || s2->height <= 0) {
2500  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2501  s2->width, s2->height);
2502  return AVERROR_INVALIDDATA;
2503  }
2504 
2505  if (s->tmpgexs){
2506  s2->intra_dc_precision= 3;
2507  s2->intra_matrix[0]= 1;
2508  }
2509  if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2510  !avctx->hwaccel && s->slice_count) {
2511  int i;
2512 
2513  avctx->execute(avctx, slice_decode_thread,
2514  s2->thread_context, NULL,
2515  s->slice_count, sizeof(void *));
2516  for (i = 0; i < s->slice_count; i++)
2517  s2->er.error_count += s2->thread_context[i]->er.error_count;
2518  s->slice_count = 0;
2519  }
2520  if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2521  ret = mpeg_decode_postinit(avctx);
2522  if (ret < 0) {
2523  av_log(avctx, AV_LOG_ERROR,
2524  "mpeg_decode_postinit() failure\n");
2525  return ret;
2526  }
2527 
2528  /* We have a complete image: we try to decompress it. */
2529  if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2530  s2->pict_type = 0;
2531  s->first_slice = 1;
2532  last_code = PICTURE_START_CODE;
2533  } else {
2534  av_log(avctx, AV_LOG_ERROR,
2535  "ignoring pic after %X\n", last_code);
2536  if (avctx->err_recognition & AV_EF_EXPLODE)
2537  return AVERROR_INVALIDDATA;
2538  }
2539  break;
2540  case EXT_START_CODE:
2541  init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2542 
2543  switch (get_bits(&s2->gb, 4)) {
2544  case 0x1:
2545  if (last_code == 0) {
2546  mpeg_decode_sequence_extension(s);
2547  } else {
2548  av_log(avctx, AV_LOG_ERROR,
2549  "ignoring seq ext after %X\n", last_code);
2550  if (avctx->err_recognition & AV_EF_EXPLODE)
2551  return AVERROR_INVALIDDATA;
2552  }
2553  break;
2554  case 0x2:
2555  mpeg_decode_sequence_display_extension(s);
2556  break;
2557  case 0x3:
2558  mpeg_decode_quant_matrix_extension(s2);
2559  break;
2560  case 0x7:
2561  mpeg_decode_picture_display_extension(s);
2562  break;
2563  case 0x8:
2564  if (last_code == PICTURE_START_CODE) {
2565  mpeg_decode_picture_coding_extension(s);
2566  } else {
2567  av_log(avctx, AV_LOG_ERROR,
2568  "ignoring pic cod ext after %X\n", last_code);
2569  if (avctx->err_recognition & AV_EF_EXPLODE)
2570  return AVERROR_INVALIDDATA;
2571  }
2572  break;
2573  }
2574  break;
2575  case USER_START_CODE:
2576  mpeg_decode_user_data(avctx, buf_ptr, input_size);
2577  break;
2578  case GOP_START_CODE:
2579  if (last_code == 0) {
2580  s2->first_field = 0;
2581  mpeg_decode_gop(avctx, buf_ptr, input_size);
2582  s->sync = 1;
2583  } else {
2584  av_log(avctx, AV_LOG_ERROR,
2585  "ignoring GOP_START_CODE after %X\n", last_code);
2586  if (avctx->err_recognition & AV_EF_EXPLODE)
2587  return AVERROR_INVALIDDATA;
2588  }
2589  break;
2590  default:
2591  if (start_code >= SLICE_MIN_START_CODE &&
2592  start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2593  if (s2->progressive_sequence && !s2->progressive_frame) {
2594  s2->progressive_frame = 1;
2595  av_log(s2->avctx, AV_LOG_ERROR,
2596  "interlaced frame in progressive sequence, ignoring\n");
2597  }
2598 
2599  if (s2->picture_structure == 0 ||
2600  (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2601  av_log(s2->avctx, AV_LOG_ERROR,
2602  "picture_structure %d invalid, ignoring\n",
2603  s2->picture_structure);
2604  s2->picture_structure = PICT_FRAME;
2605  }
2606 
2607  if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2608  av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2609 
2610  if (s2->picture_structure == PICT_FRAME) {
2611  s2->first_field = 0;
2612  s2->v_edge_pos = 16 * s2->mb_height;
2613  } else {
2614  s2->first_field ^= 1;
2615  s2->v_edge_pos = 8 * s2->mb_height;
2616  memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2617  }
2618  }
2619  if (start_code >= SLICE_MIN_START_CODE &&
2620  start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2621  const int field_pic = s2->picture_structure != PICT_FRAME;
2622  int mb_y = start_code - SLICE_MIN_START_CODE;
2623  last_code = SLICE_MIN_START_CODE;
2624  if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2625  mb_y += (*buf_ptr&0xE0)<<2;
2626 
2627  mb_y <<= field_pic;
2628  if (s2->picture_structure == PICT_BOTTOM_FIELD)
2629  mb_y++;
2630 
2631  if (buf_end - buf_ptr < 2) {
2632  av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2633  return AVERROR_INVALIDDATA;
2634  }
2635 
2636  if (mb_y >= s2->mb_height) {
2637  av_log(s2->avctx, AV_LOG_ERROR,
2638  "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2639  return AVERROR_INVALIDDATA;
2640  }
2641 
2642  if (!s2->last_picture_ptr) {
2643  /* Skip B-frames if we do not have reference frames and
2644  * GOP is not closed. */
2645  if (s2->pict_type == AV_PICTURE_TYPE_B) {
2646  if (!s2->closed_gop) {
2647  skip_frame = 1;
2648  break;
2649  }
2650  }
2651  }
2652  if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & CODEC_FLAG2_SHOW_ALL))
2653  s->sync = 1;
2654  if (!s2->next_picture_ptr) {
2655  /* Skip P-frames if we do not have a reference frame or
2656  * we have an invalid header. */
2657  if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2658  skip_frame = 1;
2659  break;
2660  }
2661  }
2662  if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2663  s2->pict_type == AV_PICTURE_TYPE_B) ||
2664  (avctx->skip_frame >= AVDISCARD_NONKEY &&
2665  s2->pict_type != AV_PICTURE_TYPE_I) ||
2666  avctx->skip_frame >= AVDISCARD_ALL) {
2667  skip_frame = 1;
2668  break;
2669  }
2670 
2671  if (!s->mpeg_enc_ctx_allocated)
2672  break;
2673 
2674  if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2675  if (mb_y < avctx->skip_top ||
2676  mb_y >= s2->mb_height - avctx->skip_bottom)
2677  break;
2678  }
2679 
2680  if (!s2->pict_type) {
2681  av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2682  if (avctx->err_recognition & AV_EF_EXPLODE)
2683  return AVERROR_INVALIDDATA;
2684  break;
2685  }
2686 
2687  if (s->first_slice) {
2688  skip_frame = 0;
2689  s->first_slice = 0;
2690  if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2691  return ret;
2692  }
2693  if (!s2->current_picture_ptr) {
2694  av_log(avctx, AV_LOG_ERROR,
2695  "current_picture not initialized\n");
2696  return AVERROR_INVALIDDATA;
2697  }
2698 
2699  if (uses_vdpau(avctx)) {
2700  s->slice_count++;
2701  break;
2702  }
2703 
2704  if (HAVE_THREADS &&
2705  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2706  !avctx->hwaccel) {
2707  int threshold = (s2->mb_height * s->slice_count +
2708  s2->slice_context_count / 2) /
2709  s2->slice_context_count;
2710  av_assert0(avctx->thread_count > 1);
2711  if (threshold <= mb_y) {
2712  MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2713 
2714  thread_context->start_mb_y = mb_y;
2715  thread_context->end_mb_y = s2->mb_height;
2716  if (s->slice_count) {
2717  s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2718  ret = ff_update_duplicate_context(thread_context, s2);
2719  if (ret < 0)
2720  return ret;
2721  }
2722  init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2723  s->slice_count++;
2724  }
2725  buf_ptr += 2; // FIXME add minimum number of bytes per slice
2726  } else {
2727  ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2728  emms_c();
2729 
2730  if (ret < 0) {
2731  if (avctx->err_recognition & AV_EF_EXPLODE)
2732  return ret;
2733  if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2734  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2735  s2->resync_mb_y, s2->mb_x, s2->mb_y,
2736  ER_AC_ERROR | ER_DC_ERROR | ER_MV_ERROR);
2737  } else {
2738  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2739  s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2740  ER_AC_END | ER_DC_END | ER_MV_END);
2741  }
2742  }
2743  }
2744  break;
2745  }
2746  }
2747 }
2748 
2749 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2750  int *got_output, AVPacket *avpkt)
2751 {
2752  const uint8_t *buf = avpkt->data;
2753  int ret;
2754  int buf_size = avpkt->size;
2755  Mpeg1Context *s = avctx->priv_data;
2756  AVFrame *picture = data;
2757  MpegEncContext *s2 = &s->mpeg_enc_ctx;
2758 
2759  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2760  /* special case for last picture */
2761  if (s2->low_delay == 0 && s2->next_picture_ptr) {
2762  int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2763  if (ret < 0)
2764  return ret;
2765 
2766  s2->next_picture_ptr = NULL;
2767 
2768  *got_output = 1;
2769  }
2770  return buf_size;
2771  }
2772 
2773  if (s2->avctx->flags & CODEC_FLAG_TRUNCATED) {
2774  int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2775  buf_size, NULL);
2776 
2777  if (ff_combine_frame(&s2->parse_context, next,
2778  (const uint8_t **) &buf, &buf_size) < 0)
2779  return buf_size;
2780  }
2781 
2782  s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2783  if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2784  || s2->codec_tag == AV_RL32("BW10")
2785  ))
2786  vcr2_init_sequence(avctx);
2787 
2788  s->slice_count = 0;
2789 
2790  if (avctx->extradata && !s->extradata_decoded) {
2791  ret = decode_chunks(avctx, picture, got_output,
2792  avctx->extradata, avctx->extradata_size);
2793  if (*got_output) {
2794  av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2795  *got_output = 0;
2796  }
2797  s->extradata_decoded = 1;
2798  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2799  s2->current_picture_ptr = NULL;
2800  return ret;
2801  }
2802  }
2803 
2804  ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2805  if (ret<0 || *got_output)
2806  s2->current_picture_ptr = NULL;
2807 
2808  return ret;
2809 }
2810 
2811 static void flush(AVCodecContext *avctx)
2812 {
2813  Mpeg1Context *s = avctx->priv_data;
2814 
2815  s->sync = 0;
2816 
2817  ff_mpeg_flush(avctx);
2818 }
2819 
2820 static av_cold int mpeg_decode_end(AVCodecContext *avctx)
2821 {
2822  Mpeg1Context *s = avctx->priv_data;
2823 
2824  if (s->mpeg_enc_ctx_allocated)
2825  ff_mpv_common_end(&s->mpeg_enc_ctx);
2826  av_freep(&s->a53_caption);
2827  return 0;
2828 }
2829 
2830 static const AVProfile mpeg2_video_profiles[] = {
2831  { FF_PROFILE_MPEG2_422, "4:2:2" },
2832  { FF_PROFILE_MPEG2_HIGH, "High" },
2833  { FF_PROFILE_MPEG2_SS, "Spatially Scalable" },
2834  { FF_PROFILE_MPEG2_SNR_SCALABLE, "SNR Scalable" },
2835  { FF_PROFILE_MPEG2_MAIN, "Main" },
2836  { FF_PROFILE_MPEG2_SIMPLE, "Simple" },
2837  { FF_PROFILE_RESERVED, "Reserved" },
2838  { FF_PROFILE_RESERVED, "Reserved" },
2839  { FF_PROFILE_UNKNOWN },
2840 };
2841 
2842 AVCodec ff_mpeg1video_decoder = {
2843  .name = "mpeg1video",
2844  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2845  .type = AVMEDIA_TYPE_VIDEO,
2846  .id = AV_CODEC_ID_MPEG1VIDEO,
2847  .priv_data_size = sizeof(Mpeg1Context),
2848  .init = mpeg_decode_init,
2849  .close = mpeg_decode_end,
2850  .decode = mpeg_decode_frame,
2851  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2852  CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
2853  CODEC_CAP_SLICE_THREADS,
2854  .flush = flush,
2855  .max_lowres = 3,
2856  .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
2857 };
2858 
2859 AVCodec ff_mpeg2video_decoder = {
2860  .name = "mpeg2video",
2861  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2862  .type = AVMEDIA_TYPE_VIDEO,
2863  .id = AV_CODEC_ID_MPEG2VIDEO,
2864  .priv_data_size = sizeof(Mpeg1Context),
2865  .init = mpeg_decode_init,
2866  .close = mpeg_decode_end,
2867  .decode = mpeg_decode_frame,
2868  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2869  CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
2870  CODEC_CAP_SLICE_THREADS,
2871  .flush = flush,
2872  .max_lowres = 3,
2873  .profiles = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
2874 };
2875 
2876 //legacy decoder
2877 AVCodec ff_mpegvideo_decoder = {
2878  .name = "mpegvideo",
2879  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2880  .type = AVMEDIA_TYPE_VIDEO,
2881  .id = AV_CODEC_ID_MPEG2VIDEO,
2882  .priv_data_size = sizeof(Mpeg1Context),
2883  .init = mpeg_decode_init,
2884  .close = mpeg_decode_end,
2885  .decode = mpeg_decode_frame,
2886  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY | CODEC_CAP_SLICE_THREADS,
2887  .flush = flush,
2888  .max_lowres = 3,
2889 };
2890 
2891 #if FF_API_XVMC
2892 #if CONFIG_MPEG_XVMC_DECODER
2893 static av_cold int mpeg_mc_decode_init(AVCodecContext *avctx)
2894 {
2895  if (avctx->active_thread_type & FF_THREAD_SLICE)
2896  return -1;
2897  if (!(avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2898  return -1;
2899  if (!(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) {
2900  ff_dlog(avctx, "mpeg12.c: XvMC decoder will work better if SLICE_FLAG_ALLOW_FIELD is set\n");
2901  }
2902  mpeg_decode_init(avctx);
2903 
2904  avctx->pix_fmt = AV_PIX_FMT_XVMC_MPEG2_IDCT;
2905  avctx->xvmc_acceleration = 2; // 2 - the blocks are packed!
2906 
2907  return 0;
2908 }
2909 
2910 AVCodec ff_mpeg_xvmc_decoder = {
2911  .name = "mpegvideo_xvmc",
2912  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video XvMC (X-Video Motion Compensation)"),
2913  .type = AVMEDIA_TYPE_VIDEO,
2914  .id = AV_CODEC_ID_MPEG2VIDEO_XVMC,
2915  .priv_data_size = sizeof(Mpeg1Context),
2916  .init = mpeg_mc_decode_init,
2917  .close = mpeg_decode_end,
2918  .decode = mpeg_decode_frame,
2919  .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
2920  CODEC_CAP_TRUNCATED | CODEC_CAP_HWACCEL | CODEC_CAP_DELAY,
2921  .flush = flush,
2922 };
2923 
2924 #endif
2925 #endif /* FF_API_XVMC */
2926 
2927 #if CONFIG_MPEG_VDPAU_DECODER
2928 AVCodec ff_mpeg_vdpau_decoder = {
2929  .name = "mpegvideo_vdpau",
2930  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1/2 video (VDPAU acceleration)"),
2931  .type = AVMEDIA_TYPE_VIDEO,
2932  .id = AV_CODEC_ID_MPEG2VIDEO,
2933  .priv_data_size = sizeof(Mpeg1Context),
2934  .init = mpeg_decode_init,
2935  .close = mpeg_decode_end,
2936  .decode = mpeg_decode_frame,
2937  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED |
2938  CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
2939  .flush = flush,
2940 };
2941 #endif
2942 
2943 #if CONFIG_MPEG1_VDPAU_DECODER
2944 AVCodec ff_mpeg1_vdpau_decoder = {
2945  .name = "mpeg1video_vdpau",
2946  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video (VDPAU acceleration)"),
2947  .type = AVMEDIA_TYPE_VIDEO,
2948  .id = AV_CODEC_ID_MPEG1VIDEO,
2949  .priv_data_size = sizeof(Mpeg1Context),
2950  .init = mpeg_decode_init,
2951  .close = mpeg_decode_end,
2952  .decode = mpeg_decode_frame,
2953  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_TRUNCATED |
2954  CODEC_CAP_HWACCEL_VDPAU | CODEC_CAP_DELAY,
2955  .flush = flush,
2956 };
2957 #endif
btype2mb_type
static const uint32_t btype2mb_type[11]
Definition: mpeg12dec.c:85
ff_mpeg1_default_non_intra_matrix
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
Definition: mpeg12data.c:41
MBINCR_VLC_BITS
#define MBINCR_VLC_BITS
Definition: mpeg12.h:31
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:60
MpegEncContext::idsp
IDCTDSPContext idsp
Definition: mpegvideo.h:299
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:1250
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: avcodec.h:905
val
const char const char void * val
Definition: avisynth_c.h:634
AVDISCARD_NONKEY
discard all frames except keyframes
Definition: avcodec.h:668
Picture::ref_index
int8_t * ref_index[2]
Definition: mpegvideo.h:106
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:3148
AVHWAccel::start_frame
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
Definition: avcodec.h:3351
v
float v
Definition: avf_showspectrum.c:96
MpegEncContext::aspect_ratio_info
int aspect_ratio_info
Definition: mpegvideo.h:465
MpegEncContext::picture_number
int picture_number
Definition: mpegvideo.h:196
s
const char * s
Definition: avisynth_c.h:631
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
CODEC_FLAG2_FAST
#define CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
Definition: avcodec.h:765
SLICE_MAX_START_CODE
#define SLICE_MAX_START_CODE
Definition: cavs.h:32
FF_PROFILE_MPEG2_SNR_SCALABLE
#define FF_PROFILE_MPEG2_SNR_SCALABLE
Definition: avcodec.h:2860
shift
static int shift(int a, int b)
Definition: sonic.c:82
AVCHROMA_LOC_LEFT
mpeg2/4 4:2:0, h264 default for 4:2:0
Definition: pixfmt.h:544
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
quant_matrix_rebuild
static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm, const uint8_t *new_perm)
Definition: mpeg12dec.c:1173
h
h
Definition: vp9dsp_template.c:2093
GET_RL_VLC
#define GET_RL_VLC
Definition: get_bits.h:689
data
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
MpegEncContext::start_mb_y
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:222
MV_TYPE_FIELD
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:336
MpegEncContext::last_mv
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG1 & B-frame MPEG4
Definition: mpegvideo.h:345
ff_mpeg1_decode_block_intra
int ff_mpeg1_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:225
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1424
mpeg2_video_profiles
static const AVProfile mpeg2_video_profiles[]
Definition: mpeg12dec.c:2830
mpeg_decode_sequence_display_extension
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1492
FF_PROFILE_MPEG2_SS
#define FF_PROFILE_MPEG2_SS
Definition: avcodec.h:2859
AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:68
imgutils.h
misc image utilities
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:260
AV_STEREO3D_SIDEBYSIDE_QUINCUNX
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:87
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
ff_mpeg12_init_vlcs
av_cold void ff_mpeg12_init_vlcs(void)
Definition: mpeg12.c:145
AV_PIX_FMT_VDPAU_MPEG2
MPEG-2 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstr...
Definition: pixfmt.h:107
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:229
Mpeg1Context::afd
uint8_t afd
Definition: mpeg12dec.c:61
MpegEncContext::end_mb_y
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y) ...
Definition: mpegvideo.h:223
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
Mpeg1Context::a53_caption
uint8_t * a53_caption
Definition: mpeg12dec.c:59
CODEC_CAP_TRUNCATED
#define CODEC_CAP_TRUNCATED
Definition: avcodec.h:790
MpegEncContext::chroma_intra_matrix
uint16_t chroma_intra_matrix[64]
Definition: mpegvideo.h:368
AVPanScan::height
int height
Definition: avcodec.h:937
MpegEncContext::v_edge_pos
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
Definition: mpegvideo.h:201
MpegEncContext::chroma_inter_matrix
uint16_t chroma_inter_matrix[64]
Definition: mpegvideo.h:370
ff_er_frame_end
void ff_er_frame_end(ERContext *s)
Definition: error_resilience.c:865
mpeg2_fast_decode_block_non_intra
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
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1960
FF_PROFILE_RESERVED
#define FF_PROFILE_RESERVED
Definition: avcodec.h:2837
AVRational::num
int num
numerator
Definition: rational.h:44
AVFrame::repeat_pict
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:362
AVPacket::size
int size
Definition: avcodec.h:1163
MpegEncContext::codec_id
enum AVCodecID codec_id
Definition: mpegvideo.h:181
BlockDSPContext::clear_blocks
void(* clear_blocks)(int16_t *blocks)
Definition: blockdsp.h:36
AV_PIX_FMT_VAAPI_VLD
HW decoding through VA API, Picture.data[3] contains a vaapi_render_state struct which contains the b...
Definition: pixfmt.h:126
mpeg_decode_picture_coding_extension
static void mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1587
AV_EF_AGGRESSIVE
#define AV_EF_AGGRESSIVE
consider things that a sane encoder should not do as an error
Definition: avcodec.h:2628
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:55
ff_mpeg1_clean_buffers
void ff_mpeg1_clean_buffers(MpegEncContext *s)
Definition: mpeg12.c:123
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1623
xvmc_internal.h
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:69
ff_mpeg1video_decoder
AVCodec ff_mpeg1video_decoder
Definition: mpeg12dec.c:2842
av_timecode_make_mpeg_tc_string
char * av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)
Get the timecode string from the 25-bit timecode format (MPEG GOP format).
Definition: timecode.c:130
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1444
tc
#define tc
Definition: regdef.h:69
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:66
mpeg_decode_init
static av_cold int mpeg_decode_init(AVCodecContext *avctx)
Definition: mpeg12dec.c:1120
MB_TYPE_QUANT
#define MB_TYPE_QUANT
Definition: avcodec.h:913
mpegvideo.h
mpegvideo header.
HAS_CBP
#define HAS_CBP(a)
Definition: mpegutils.h:97
AVDISCARD_ALL
discard all
Definition: avcodec.h:669
ScanTable::permutated
uint8_t permutated[64]
Definition: idctdsp.h:31
run
uint8_t run
Definition: svq3.c:149
ER_MV_ERROR
#define ER_MV_ERROR
Definition: error_resilience.h:33
mpeg_decode_gop
static void mpeg_decode_gop(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2391
SLICE_MIN_START_CODE
#define SLICE_MIN_START_CODE
Definition: mpegvideo.h:81
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:2835
AVCodec
AVCodec.
Definition: avcodec.h:3181
get_dmv
static int get_dmv(MpegEncContext *s)
Definition: mpeg12dec.c:710
MpegEncContext::qscale
int qscale
QP.
Definition: mpegvideo.h:273
RLTable
RLTable.
Definition: rl.h:38
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:245
MpegEncContext::chroma_x_shift
int chroma_x_shift
Definition: mpegvideo.h:537
MpegEncContext::encoding
int encoding
true if we are encoding (vs decoding)
Definition: mpegvideo.h:183
MpegEncContext::field_select
int field_select[2][2]
Definition: mpegvideo.h:344
attributes.h
Macro definitions for various function/variable attributes.
FFALIGN
#define FFALIGN(x, a)
Definition: common.h:71
MB_PAT_VLC_BITS
#define MB_PAT_VLC_BITS
Definition: mpeg12.h:32
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2947
mpeg_decode_update_thread_context
static int mpeg_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
Definition: mpeg12dec.c:1148
AVCodecContext::hwaccel
struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2644
USES_LIST
#define USES_LIST(a, list)
Definition: mpegutils.h:95
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo.c:3141
ptype2mb_type
static const uint32_t ptype2mb_type[7]
Definition: mpeg12dec.c:75
if
if()
Definition: avfilter.c:975
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:74
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
ff_rl_mpeg2
RLTable ff_rl_mpeg2
Definition: mpeg12data.c:174
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:123
MpegEncContext::out_format
enum OutputFormat out_format
output format
Definition: mpegvideo.h:173
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:67
ff_mpeg1_aspect
const float ff_mpeg1_aspect[16]
Definition: mpeg12data.c:394
thread.h
Multithreading support functions.
CODEC_CAP_HWACCEL_VDPAU
#define CODEC_CAP_HWACCEL_VDPAU
Codec can export data for HW decoding (VDPAU).
Definition: avcodec.h:834
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:363
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:2836
FF_PROFILE_MPEG2_MAIN
#define FF_PROFILE_MPEG2_MAIN
Definition: avcodec.h:2861
load_matrix
static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1[64], int intra)
Definition: mpeg12dec.c:1550
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1355
MpegEncContext::full_pel
int full_pel[2]
Definition: mpegvideo.h:541
MpegEncContext::interlaced_dct
int interlaced_dct
Definition: mpegvideo.h:542
ff_mpv_decode_mb
void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:3129
mpeg_get_pixelformat
static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
Definition: mpeg12dec.c:1232
mpeg1_fast_decode_block_inter
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
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:85
MpegEncContext::current_picture
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:249
Mpeg1Context::first_slice
int first_slice
Definition: mpeg12dec.c:69
AV_FRAME_DATA_PANSCAN
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:52
MpegEncContext::intra_dc_precision
int intra_dc_precision
Definition: mpegvideo.h:523
MpegEncContext::repeat_first_field
int repeat_first_field
Definition: mpegvideo.h:531
CODEC_CAP_DR1
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:789
ff_xvmc_init_block
void ff_xvmc_init_block(MpegEncContext *s)
Initialize the block field of the MpegEncContext pointer passed as parameter after making sure that t...
Definition: mpegvideo_xvmc.c:43
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:134
av_image_check_sar
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
Definition: imgutils.c:252
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:34
AVPacket::data
uint8_t * data
Definition: avcodec.h:1162
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:212
ff_xvmc_pack_pblocks
void ff_xvmc_pack_pblocks(MpegEncContext *s, int cbp)
Fill individual block pointers, so there are no gaps in the data_block array in case not all blocks i...
Definition: mpegvideo_xvmc.c:64
ER_MV_END
#define ER_MV_END
Definition: error_resilience.h:36
AV_PIX_FMT_VDPAU_MPEG1
MPEG-1 HW decoding with VDPAU, data[0] contains a vdpau_render_state struct which contains the bitstr...
Definition: pixfmt.h:106
FF_PROFILE_MPEG2_HIGH
#define FF_PROFILE_MPEG2_HIGH
Definition: avcodec.h:2858
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:346
MpegEncContext::mb_height
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:198
AVCodecContext::lowres
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
Definition: avcodec.h:2737
MpegEncContext::codec_tag
int codec_tag
internal codec_tag upper case converted from avctx codec_tag
Definition: mpegvideo.h:189
ff_thread_finish_setup
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...
Definition: pthread_frame.c:514
AV_FRAME_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:89
ff_mv_vlc
VLC ff_mv_vlc
Definition: mpeg12.c:135
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_vdpau_mpeg_picture_complete
void ff_vdpau_mpeg_picture_complete(MpegEncContext *s, const uint8_t *buf, int buf_size, int slice_count)
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
m
unsigned m
Definition: audioconvert.c:187
setup_hwaccel_for_pixfmt
static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
Definition: mpeg12dec.c:1253
version.h
Libavcodec version macros.
AV_CODEC_ID_MPEG1VIDEO
Definition: avcodec.h:106
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:588
AVCodec::id
enum AVCodecID id
Definition: avcodec.h:3195
MpegEncContext::slice_context_count
int slice_context_count
number of used thread_contexts
Definition: mpegvideo.h:225
CODEC_FLAG_TRUNCATED
#define CODEC_FLAG_TRUNCATED
Definition: avcodec.h:747
Mpeg1Context::extradata_decoded
int extradata_decoded
Definition: mpeg12dec.c:70
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:173
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1533
MpegEncContext::last_dc
int last_dc[3]
last DC values for MPEG1
Definition: mpegvideo.h:254
s2
#define s2
Definition: regdef.h:39
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition: error_resilience.c:795
MT_FIELD
#define MT_FIELD
Definition: mpeg12dec.c:729
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:249
MpegEncContext::mb_skipped
int mb_skipped
MUST BE SET only during DECODING.
Definition: mpegvideo.h:264
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2623
CODEC_CAP_DELAY
#define 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:824
MpegEncContext::chroma_y_shift
int chroma_y_shift
Definition: mpegvideo.h:538
ff_combine_frame
int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
Combine the (truncated) bitstream to a complete frame.
Definition: parser.c:231
AVERROR
#define AVERROR(e)
Definition: error.h:43
mpeg_decode_sequence_extension
static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1455
FF_PROFILE_MPEG2_SIMPLE
#define FF_PROFILE_MPEG2_SIMPLE
Definition: avcodec.h:2862
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:175
MpegEncContext::er
ERContext er
Definition: mpegvideo.h:610
mpeg1_decode_block_inter
static int mpeg1_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:230
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2772
ff_mpegvideo_decoder
AVCodec ff_mpegvideo_decoder
Definition: mpeg12dec.c:2877
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
get_qscale
static int get_qscale(MpegEncContext *s)
Definition: mpeg12dec.c:718
arg
const char * arg
Definition: jacosubdec.c:66
AVCodecContext::flags
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1335
wrap
#define wrap(func)
Definition: neontest.h:62
SEQ_END_CODE
#define SEQ_END_CODE
Definition: mpegvideo.h:77
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:33
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3188
mpeg_decode_motion
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
Definition: mpeg12dec.c:107
AVPanScan::width
int width
width and height in 1/16 pel
Definition: avcodec.h:936
MpegEncContext::low_delay
int low_delay
no reordering needed / has no b-frames
Definition: mpegvideo.h:469
mpeg_decode_user_data
static void mpeg_decode_user_data(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition: mpeg12dec.c:2316
MpegEncContext::gb
GetBitContext gb
Definition: mpegvideo.h:509
AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:35
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:144
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1474
ff_mb_pat_vlc
VLC ff_mb_pat_vlc
Definition: mpeg12.c:143
FFMAX
#define FFMAX(a, b)
Definition: common.h:64
decode_dc
static int decode_dc(GetBitContext *gb, int component)
Definition: mpeg12.h:49
avcodec.h
Libavcodec external API header.
Mpeg1Context::repeat_field
int repeat_field
Definition: mpeg12dec.c:55
DECODE_SLICE_ERROR
#define DECODE_SLICE_ERROR
Definition: mpeg12dec.c:1743
CODEC_FLAG_LOW_DELAY
#define CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:757
check_marker
static int check_marker(GetBitContext *s, const char *msg)
Definition: get_bits.h:393
DECODE_SLICE_OK
#define DECODE_SLICE_OK
Definition: mpeg12dec.c:1744
AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:67
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:3209
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:188
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:214
MpegEncContext::resync_mb_x
int resync_mb_x
x position of last resync marker
Definition: mpegvideo.h:422
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2304
update_thread_context
static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: ffv1dec.c:1058
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
MB_PTYPE_VLC_BITS
#define MB_PTYPE_VLC_BITS
Definition: mpeg12.h:33
CODEC_FLAG2_SHOW_ALL
#define CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition: avcodec.h:772
internal.h
common internal API header
ER_AC_ERROR
#define ER_AC_ERROR
Definition: error_resilience.h:31
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:2579
mpeg_field_start
static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:1646
non_linear_qscale
static const uint8_t non_linear_qscale[32]
Definition: mpeg12dec.c:99
MpegEncContext::intra_vlc_format
int intra_vlc_format
Definition: mpegvideo.h:528
mpeg2_decode_block_non_intra
static int mpeg2_decode_block_non_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:395
ff_mpv_export_qp_table
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:2377
AVCodecContext::timecode_frame_start
int64_t timecode_frame_start
GOP timecode frame start number.
Definition: avcodec.h:2455
MpegEncContext::progressive_frame
int progressive_frame
Definition: mpegvideo.h:540
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:267
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:242
MpegEncContext::top_field_first
int top_field_first
Definition: mpegvideo.h:525
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2612
CODEC_CAP_DRAW_HORIZ_BAND
#define CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: avcodec.h:783
FF_IDCT_SIMPLE
#define FF_IDCT_SIMPLE
Definition: avcodec.h:2688
FFMIN
#define FFMIN(a, b)
Definition: common.h:66
MB_BTYPE_VLC_BITS
#define MB_BTYPE_VLC_BITS
Definition: mpeg12.h:34
ParseContext::last_index
int last_index
Definition: parser.h:31
vcr2_init_sequence
static int vcr2_init_sequence(AVCodecContext *avctx)
Definition: mpeg12dec.c:2209
ret
ret
Definition: avfilter.c:974
MpegEncContext::mbskip_table
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:265
AVCodecContext::idct_algo
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:2685
MB_TYPE_INTERLACED
#define MB_TYPE_INTERLACED
Definition: avcodec.h:901
Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: mpegvideo.h:97
MpegEncContext::current_picture_ptr
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:253
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
ER_DC_END
#define ER_DC_END
Definition: error_resilience.h:35
mpeg_decode_a53_cc
static int mpeg_decode_a53_cc(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition: mpeg12dec.c:2263
ff_rl_mpeg1
RLTable ff_rl_mpeg1
Definition: mpeg12data.c:166
AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:546
MpegEncContext::alternate_scan
int alternate_scan
Definition: mpegvideo.h:529
Mpeg1Context::save_height
int save_height
Definition: mpeg12dec.c:65
GOP_START_CODE
#define GOP_START_CODE
Definition: mpegvideo.h:79
int32_t
int32_t
Definition: audio_convert.c:194
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1939
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:287
Mpeg1Context::a53_caption_size
int a53_caption_size
Definition: mpeg12dec.c:60
MB_TYPE_L0L1
#define MB_TYPE_L0L1
Definition: avcodec.h:912
AVCodecContext::level
int level
level
Definition: avcodec.h:2925
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:194
mpeg_decode_end
static av_cold int mpeg_decode_end(AVCodecContext *avctx)
Definition: mpeg12dec.c:2820
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:555
mpeg_decode_quant_matrix_extension
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
Definition: mpeg12dec.c:1573
MpegEncContext::pblocks
int16_t(*[12] pblocks)[64]
Definition: mpegvideo.h:556
MpegEncContext::block_last_index
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:155
n
int n
Definition: avisynth_c.h:547
IDCTDSPContext::idct_permutation
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:94
MpegEncContext::mpeg_f_code
int mpeg_f_code[2][2]
Definition: mpegvideo.h:518
EXT_START_CODE
#define EXT_START_CODE
Definition: cavs.h:33
MB_TYPE_L1
#define MB_TYPE_L1
Definition: avcodec.h:911
Mpeg1Context::mpeg_enc_ctx_allocated
int mpeg_enc_ctx_allocated
Definition: mpeg12dec.c:54
check_scantable_index
#define check_scantable_index(ctx, x)
Definition: mpeg12dec.c:133
ff_mpeg_update_thread_context
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo.c:880
AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:107
RLTable::rl_vlc
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:47
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:206
ff_mpv_decode_defaults
void ff_mpv_decode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for decoding.
Definition: mpegvideo.c:1054
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2753
mpeg1_decode_sequence
static int mpeg1_decode_sequence(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2121
SLICE_FLAG_ALLOW_FIELD
#define SLICE_FLAG_ALLOW_FIELD
allow draw_horiz_band() with field slices (MPEG2 field pics)
Definition: avcodec.h:1759
pred
static const float pred[4]
Definition: siprdata.h:259
Mpeg1Context::save_aspect
AVRational save_aspect
Definition: mpeg12dec.c:64
MpegEncContext::first_field
int first_field
is 1 for the first field of a field picture 0 otherwise
Definition: mpegvideo.h:543
Mpeg1Context::save_width
int save_width
Definition: mpeg12dec.c:65
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:333
MV_VLC_BITS
#define MV_VLC_BITS
Definition: ituh263dec.c:51
FF_IDCT_AUTO
#define FF_IDCT_AUTO
Definition: avcodec.h:2686
MpegEncContext::frame_pred_frame_dct
int frame_pred_frame_dct
Definition: mpegvideo.h:524
mpeg2_decode_block_intra
static int mpeg2_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:547
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:127
MpegEncContext::inter_matrix
uint16_t inter_matrix[64]
Definition: mpegvideo.h:369
mpeg2_hwaccel_pixfmt_list_420
static enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[]
Definition: mpeg12dec.c:1197
MpegEncContext::concealment_motion_vectors
int concealment_motion_vectors
Definition: mpegvideo.h:526
MpegEncContext::thread_context
struct MpegEncContext * thread_context[MAX_THREADS]
Definition: mpegvideo.h:224
ff_dlog
#define ff_dlog(ctx,...)
Definition: internal.h:54
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:2765
Mpeg1Context::frame_rate_ext
AVRational frame_rate_ext
Definition: mpeg12dec.c:66
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:1258
MpegEncContext::bdsp
BlockDSPContext bdsp
Definition: mpegvideo.h:295
mpeg2_fast_decode_block_intra
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
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:199
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:2565
error_resilience.h
AVCodecContext
main external API structure.
Definition: avcodec.h:1241
mpeg_er.h
MpegEncContext::intra_scantable
ScanTable intra_scantable
Definition: mpegvideo.h:160
USER_START_CODE
#define USER_START_CODE
Definition: cavs.h:34
MpegEncContext::height
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:169
IS_QUANT
#define IS_QUANT(a)
Definition: mpegutils.h:91
mpeg12data.h
MPEG1/2 tables.
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1273
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:133
AVFrameSideData::data
uint8_t * data
Definition: frame.h:136
MV_TYPE_16X8
#define MV_TYPE_16X8
2 vectors, one per 16x8 block
Definition: mpegvideo.h:335
MpegEncContext::chroma_420_type
int chroma_420_type
Definition: mpegvideo.h:532
buf
void * buf
Definition: avisynth_c.h:553
mpeg_decode_slice
static int mpeg_decode_slice(MpegEncContext *s, int mb_y, const uint8_t **buf, int buf_size)
Decode a slice.
Definition: mpeg12dec.c:1752
ff_print_debug_info
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:2370
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:1356
MpegEncContext::progressive_sequence
int progressive_sequence
Definition: mpegvideo.h:517
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
height
BYTE int const BYTE int int int height
Definition: avisynth_c.h:676
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:329
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2764
AVCodecContext::slice_flags
int slice_flags
slice flags
Definition: avcodec.h:1757
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:1424
profiles
static const AVProfile profiles[]
Definition: aacdec.c:3543
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:297
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
Definition: frame.c:584
MpegEncContext::closed_gop
int closed_gop
MPEG1/2 GOP is closed.
Definition: mpegvideo.h:280
Mpeg1Context::has_stereo3d
int has_stereo3d
Definition: mpeg12dec.c:58
ff_mb_ptype_vlc
VLC ff_mb_ptype_vlc
Definition: mpeg12.c:141
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:3675
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1953
AVRational
rational number numerator/denominator
Definition: rational.h:43
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1946
Picture::f
struct AVFrame * f
Definition: mpegvideo.h:90
AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:211
mpeg12_pixfmt_list_422
static enum AVPixelFormat mpeg12_pixfmt_list_422[]
Definition: mpeg12dec.c:1218
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:410
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:210
ff_mpeg1_default_intra_matrix
const uint16_t ff_mpeg1_default_intra_matrix[256]
Definition: mpeg12data.c:30
ff_mpeg1_find_frame_end
int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size, AVCodecParserContext *s)
Find the end of the current frame in the bitstream.
Definition: mpeg12.c:186
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: avcodec.h:897
Mpeg1Context::save_progressive_seq
int save_progressive_seq
Definition: mpeg12dec.c:65
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:117
mpeg1_decode_block_intra
static int mpeg1_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:142
MT_DMV
#define MT_DMV
Definition: mpeg12dec.c:732
ff_thread_get_format
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: pthread_frame.c:827
s1
#define s1
Definition: regdef.h:38
ff_mpv_frame_start
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1611
AVCodecContext::dtg_active_format
attribute_deprecated int dtg_active_format
DTG active format information (additional aspect ratio information only used in DVB MPEG-2 transport ...
Definition: avcodec.h:1718
ER_DC_ERROR
#define ER_DC_ERROR
Definition: error_resilience.h:32
uses_vdpau
static int uses_vdpau(AVCodecContext *avctx)
Definition: mpeg12dec.c:1228
AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
Definition: pixfmt.h:137
mpeg_decode_frame
static int mpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_output, AVPacket *avpkt)
Definition: mpeg12dec.c:2749
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:329
decode_chunks
static int decode_chunks(AVCodecContext *avctx, AVFrame *picture, int *got_output, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2418
MpegEncContext::pict_type
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:281
MpegEncContext::bit_rate
int bit_rate
wanted bit rate
Definition: mpegvideo.h:172
start_code
static const uint8_t start_code[]
Definition: h264.c:1264
ff_mpeg12_common_init
av_cold void ff_mpeg12_common_init(MpegEncContext *s)
Definition: mpeg12.c:115
AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition: stereo3d.h:55
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:139
AVCodecContext::skip_bottom
int skip_bottom
Number of macroblock rows at the bottom which are skipped.
Definition: avcodec.h:1844
flags
static int flags
Definition: cpu.c:47
av_stereo3d_create_side_data
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition: stereo3d.c:32
AVPanScan
Pan Scan area.
Definition: avcodec.h:923
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
level
uint8_t level
Definition: svq3.c:150
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2566
MpegEncContext::mv
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:343
MpegEncContext::b8_stride
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
Definition: mpegvideo.h:200
AVCOL_RANGE_MPEG
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:522
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:150
MpegEncContext::next_picture_ptr
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
Definition: mpegvideo.h:252
AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:45
MpegEncContext::avctx
struct AVCodecContext * avctx
Definition: mpegvideo.h:167
decode
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:522
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:207
MB_TYPE_CBP
#define MB_TYPE_CBP
Definition: avcodec.h:914
AV_PIX_FMT_XVMC
#define AV_PIX_FMT_XVMC
Definition: pixfmt.h:81
AVDISCARD_NONREF
discard all non reference
Definition: avcodec.h:665
ff_mpeg2_aspect
const AVRational ff_mpeg2_aspect[16]
Definition: mpeg12data.c:415
ERContext::error_count
volatile int error_count
Definition: error_resilience.h:64
mpeg1_hwaccel_pixfmt_list_420
static enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[]
Definition: mpeg12dec.c:1185
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:71
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:79
CODEC_CAP_SLICE_THREADS
#define CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:870
internal.h
common internal api header.
MpegEncContext::mb_stride
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:199
ff_mpv_decode_init
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Definition: mpegvideo.c:1059
ff_mpeg2video_decoder
AVCodec ff_mpeg2video_decoder
Definition: mpeg12dec.c:2859
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: dv.h:93
CODEC_FLAG_GRAY
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:738
mpeg_decode_mb
static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpeg12dec.c:734
MpegEncContext::dest
uint8_t * dest[3]
Definition: mpegvideo.h:362
c
static double c[64]
Definition: vsrc_mptestsrc.c:87
GetBitContext::buffer_end
const uint8_t * buffer_end
Definition: get_bits.h:55
flush
static void flush(AVCodecContext *avctx)
Definition: mpeg12dec.c:2811
ff_mbincr_vlc
VLC ff_mbincr_vlc
Definition: mpeg12.c:140
MpegEncContext::last_picture_ptr
Picture * last_picture_ptr
pointer to the previous picture.
Definition: mpegvideo.h:251
AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:269
AVProfile
AVProfile.
Definition: avcodec.h:3169
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: avcodec.h:2621
mpeg1_decode_picture
static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:1408
AVRational::den
int den
denominator
Definition: rational.h:45
ff_alternate_vertical_scan
const uint8_t ff_alternate_vertical_scan[64]
Definition: mpegvideodata.c:93
MB_TYPE_16x8
#define MB_TYPE_16x8
Definition: avcodec.h:898
ff_update_duplicate_context
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
Definition: mpegvideo.c:852
SLICE_FLAG_CODED_ORDER
#define SLICE_FLAG_CODED_ORDER
draw_horiz_band() is called in coded order instead of display
Definition: avcodec.h:1758
Mpeg1Context::stereo3d
AVStereo3D stereo3d
Definition: mpeg12dec.c:57
lowres
static int lowres
Definition: ffplay.c:324
IS_INTRA
#define IS_INTRA(x, y)
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2073
AVPanScan::position
int16_t position[3][2]
position of the top left corner in 1/16 pel for up to 3 fields/frames
Definition: avcodec.h:944
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1283
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:35
MpegEncContext::frame_rate_index
int frame_rate_index
Definition: mpegvideo.h:286
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:1234
mpeg_decode_postinit
static int mpeg_decode_postinit(AVCodecContext *avctx)
Definition: mpeg12dec.c:1273
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:133
MpegEncContext::picture_structure
int picture_structure
Definition: mpegvideo.h:521
re
float re
Definition: fft-test.c:73
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
AVCodecContext::execute
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2793
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:80
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1838
MT_FRAME
#define MT_FRAME
Definition: mpeg12dec.c:730
MV_TYPE_DMV
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition: mpegvideo.h:337
SEQ_START_CODE
#define SEQ_START_CODE
Definition: mpegvideo.h:78
MpegEncContext::resync_mb_y
int resync_mb_y
y position of last resync marker
Definition: mpegvideo.h:423
MpegEncContext::block
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:558
MpegEncContext::parse_context
ParseContext parse_context
Definition: mpegvideo.h:428
FF_QSCALE_TYPE_MPEG2
#define FF_QSCALE_TYPE_MPEG2
Definition: avcodec.h:949
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:237
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:2627
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:449
AVCodecContext::flags2
int flags2
CODEC_FLAG2_*.
Definition: avcodec.h:1342
Mpeg1Context::mpeg_enc_ctx
MpegEncContext mpeg_enc_ctx
Definition: mpeg12dec.c:53
Mpeg1Context::slice_count
int slice_count
Definition: mpeg12dec.c:63
dc
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
Definition: audio_convert.c:194
MB_TYPE_ZERO_MV
#define MB_TYPE_ZERO_MV
Definition: mpeg12dec.c:73
MpegEncContext::intra_matrix
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
Definition: mpegvideo.h:367
Picture::mb_type
uint32_t * mb_type
types and macros are defined in mpegutils.h
Definition: mpegvideo.h:100
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
MpegEncContext::inter_scantable
ScanTable inter_scantable
if inter == intra then intra should be used to reduce tha cache usage
Definition: mpegvideo.h:159
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:194
PICTURE_START_CODE
#define PICTURE_START_CODE
Definition: mpegvideo.h:80
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:593
AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11, Picture.data[3] contains a ID3D11VideoDecoderOutputView pointer...
Definition: pixfmt.h:256
AVCHROMA_LOC_CENTER
mpeg1 4:2:0, jpeg 4:2:0, h263 4:2:0
Definition: pixfmt.h:545
ER_AC_END
#define ER_AC_END
Definition: error_resilience.h:34
FF_PROFILE_MPEG2_422
#define FF_PROFILE_MPEG2_422
Definition: avcodec.h:2857
AVHWAccel::decode_slice
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:3365
slice_decode_thread
static int slice_decode_thread(AVCodecContext *c, void *arg)
Definition: mpeg12dec.c:2022
AVHWAccel::end_frame
int(* end_frame)(AVCodecContext *avctx)
Called at the end of each frame or field picture.
Definition: avcodec.h:3376
mpeg12_pixfmt_list_444
static enum AVPixelFormat mpeg12_pixfmt_list_444[]
Definition: mpeg12dec.c:1223
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:85
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:61
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1139
ff_mpv_report_decode_progress
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo.c:3254
ff_mpeg12_frame_rate_tab
const AVRational ff_mpeg12_frame_rate_tab[16]
Definition: mpeg12data.c:308
MB_TYPE_L0
#define MB_TYPE_L0
Definition: avcodec.h:910
vdpau_compat.h
mpeg_decode_picture_display_extension
static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1516
AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:268
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
Mpeg1Context::pan_scan
AVPanScan pan_scan
Definition: mpeg12dec.c:56
width
static int width
Definition: demuxing_decoding.c:39
block
static int16_t block[64]
Definition: dct-test.c:110
ff_mb_btype_vlc
VLC ff_mb_btype_vlc
Definition: mpeg12.c:142
Generated on Wed Jun 10 2015 01:56:45 for FFmpeg by   doxygen 1.8.6