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