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