FFmpeg
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/mem_internal.h"
35 #include "libavutil/stereo3d.h"
37 
38 #include "avcodec.h"
39 #include "bytestream.h"
40 #include "error_resilience.h"
41 #include "hwconfig.h"
42 #include "idctdsp.h"
43 #include "internal.h"
44 #include "mpeg_er.h"
45 #include "mpeg12.h"
46 #include "mpeg12data.h"
47 #include "mpegutils.h"
48 #include "mpegvideo.h"
49 #include "mpegvideodata.h"
50 #include "profiles.h"
51 #include "thread.h"
52 #include "xvmc_internal.h"
53 
54 #define A53_MAX_CC_COUNT 2000
55 
56 typedef struct Mpeg1Context {
58  int mpeg_enc_ctx_allocated; /* true if decoding context allocated */
59  int repeat_field; /* true if we must repeat the field */
60  AVPanScan pan_scan; /* some temporary storage for the panscan */
64  uint8_t afd;
65  int has_afd;
70  AVRational frame_rate_ext; /* MPEG-2 specific framerate modificator */
71  int sync; /* Did we reach a sync point like a GOP/SEQ/KEYFrame? */
72  int tmpgexs;
75 } Mpeg1Context;
76 
77 #define MB_TYPE_ZERO_MV 0x20000000
78 
79 static const uint32_t ptype2mb_type[7] = {
82  MB_TYPE_L0,
87 };
88 
89 static const uint32_t btype2mb_type[11] = {
91  MB_TYPE_L1,
93  MB_TYPE_L0,
101 };
102 
103 /* as H.263, but only 17 codes */
104 static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
105 {
106  int code, sign, val, shift;
107 
108  code = get_vlc2(&s->gb, ff_mv_vlc.table, MV_VLC_BITS, 2);
109  if (code == 0)
110  return pred;
111  if (code < 0)
112  return 0xffff;
113 
114  sign = get_bits1(&s->gb);
115  shift = fcode - 1;
116  val = code;
117  if (shift) {
118  val = (val - 1) << shift;
119  val |= get_bits(&s->gb, shift);
120  val++;
121  }
122  if (sign)
123  val = -val;
124  val += pred;
125 
126  /* modulo decoding */
127  return sign_extend(val, 5 + shift);
128 }
129 
130 #define MAX_INDEX (64 - 1)
131 #define check_scantable_index(ctx, x) \
132  do { \
133  if ((x) > MAX_INDEX) { \
134  av_log(ctx->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", \
135  ctx->mb_x, ctx->mb_y); \
136  return AVERROR_INVALIDDATA; \
137  } \
138  } while (0)
139 
141  int16_t *block, int n)
142 {
143  int level, i, j, run;
144  RLTable *rl = &ff_rl_mpeg1;
145  uint8_t *const scantable = s->intra_scantable.permutated;
146  const uint16_t *quant_matrix = s->inter_matrix;
147  const int qscale = s->qscale;
148 
149  {
150  OPEN_READER(re, &s->gb);
151  i = -1;
152  // special case for first coefficient, no need to add second VLC table
153  UPDATE_CACHE(re, &s->gb);
154  if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
155  level = (3 * qscale * quant_matrix[0]) >> 5;
156  level = (level - 1) | 1;
157  if (GET_CACHE(re, &s->gb) & 0x40000000)
158  level = -level;
159  block[0] = level;
160  i++;
161  SKIP_BITS(re, &s->gb, 2);
162  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
163  goto end;
164  }
165  /* now quantify & encode AC coefficients */
166  for (;;) {
167  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
168  TEX_VLC_BITS, 2, 0);
169 
170  if (level != 0) {
171  i += run;
172  if (i > MAX_INDEX)
173  break;
174  j = scantable[i];
175  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
176  level = (level - 1) | 1;
177  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
178  SHOW_SBITS(re, &s->gb, 1);
179  SKIP_BITS(re, &s->gb, 1);
180  } else {
181  /* escape */
182  run = SHOW_UBITS(re, &s->gb, 6) + 1;
183  LAST_SKIP_BITS(re, &s->gb, 6);
184  UPDATE_CACHE(re, &s->gb);
185  level = SHOW_SBITS(re, &s->gb, 8);
186  SKIP_BITS(re, &s->gb, 8);
187  if (level == -128) {
188  level = SHOW_UBITS(re, &s->gb, 8) - 256;
189  SKIP_BITS(re, &s->gb, 8);
190  } else if (level == 0) {
191  level = SHOW_UBITS(re, &s->gb, 8);
192  SKIP_BITS(re, &s->gb, 8);
193  }
194  i += run;
195  if (i > MAX_INDEX)
196  break;
197  j = scantable[i];
198  if (level < 0) {
199  level = -level;
200  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
201  level = (level - 1) | 1;
202  level = -level;
203  } else {
204  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
205  level = (level - 1) | 1;
206  }
207  }
208 
209  block[j] = level;
210  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
211  break;
212  UPDATE_CACHE(re, &s->gb);
213  }
214 end:
215  LAST_SKIP_BITS(re, &s->gb, 2);
216  CLOSE_READER(re, &s->gb);
217  }
218 
220 
221  s->block_last_index[n] = i;
222  return 0;
223 }
224 
225 /**
226  * Changing this would eat up any speed benefits it has.
227  * Do not use "fast" flag if you need the code to be robust.
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 int qscale = s->qscale;
236 
237  {
238  OPEN_READER(re, &s->gb);
239  i = -1;
240  // Special case for first coefficient, no need to add second VLC table.
241  UPDATE_CACHE(re, &s->gb);
242  if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
243  level = (3 * qscale) >> 1;
244  level = (level - 1) | 1;
245  if (GET_CACHE(re, &s->gb) & 0x40000000)
246  level = -level;
247  block[0] = level;
248  i++;
249  SKIP_BITS(re, &s->gb, 2);
250  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
251  goto end;
252  }
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  if (i > MAX_INDEX)
262  break;
263  j = scantable[i];
264  level = ((level * 2 + 1) * qscale) >> 1;
265  level = (level - 1) | 1;
266  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
267  SHOW_SBITS(re, &s->gb, 1);
268  SKIP_BITS(re, &s->gb, 1);
269  } else {
270  /* escape */
271  run = SHOW_UBITS(re, &s->gb, 6) + 1;
272  LAST_SKIP_BITS(re, &s->gb, 6);
273  UPDATE_CACHE(re, &s->gb);
274  level = SHOW_SBITS(re, &s->gb, 8);
275  SKIP_BITS(re, &s->gb, 8);
276  if (level == -128) {
277  level = SHOW_UBITS(re, &s->gb, 8) - 256;
278  SKIP_BITS(re, &s->gb, 8);
279  } else if (level == 0) {
280  level = SHOW_UBITS(re, &s->gb, 8);
281  SKIP_BITS(re, &s->gb, 8);
282  }
283  i += run;
284  if (i > MAX_INDEX)
285  break;
286  j = scantable[i];
287  if (level < 0) {
288  level = -level;
289  level = ((level * 2 + 1) * qscale) >> 1;
290  level = (level - 1) | 1;
291  level = -level;
292  } else {
293  level = ((level * 2 + 1) * qscale) >> 1;
294  level = (level - 1) | 1;
295  }
296  }
297 
298  block[j] = level;
299  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
300  break;
301  UPDATE_CACHE(re, &s->gb);
302  }
303 end:
304  LAST_SKIP_BITS(re, &s->gb, 2);
305  CLOSE_READER(re, &s->gb);
306  }
307 
309 
310  s->block_last_index[n] = i;
311  return 0;
312 }
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 uint16_t *quant_matrix;
321  const int qscale = s->qscale;
322  int mismatch;
323 
324  mismatch = 1;
325 
326  {
327  OPEN_READER(re, &s->gb);
328  i = -1;
329  if (n < 4)
330  quant_matrix = s->inter_matrix;
331  else
332  quant_matrix = s->chroma_inter_matrix;
333 
334  // Special case for first coefficient, no need to add second VLC table.
335  UPDATE_CACHE(re, &s->gb);
336  if (((int32_t) GET_CACHE(re, &s->gb)) < 0) {
337  level = (3 * qscale * quant_matrix[0]) >> 5;
338  if (GET_CACHE(re, &s->gb) & 0x40000000)
339  level = -level;
340  block[0] = level;
341  mismatch ^= level;
342  i++;
343  SKIP_BITS(re, &s->gb, 2);
344  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
345  goto end;
346  }
347 
348  /* now quantify & encode AC coefficients */
349  for (;;) {
350  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
351  TEX_VLC_BITS, 2, 0);
352 
353  if (level != 0) {
354  i += run;
355  if (i > MAX_INDEX)
356  break;
357  j = scantable[i];
358  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
359  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
360  SHOW_SBITS(re, &s->gb, 1);
361  SKIP_BITS(re, &s->gb, 1);
362  } else {
363  /* escape */
364  run = SHOW_UBITS(re, &s->gb, 6) + 1;
365  LAST_SKIP_BITS(re, &s->gb, 6);
366  UPDATE_CACHE(re, &s->gb);
367  level = SHOW_SBITS(re, &s->gb, 12);
368  SKIP_BITS(re, &s->gb, 12);
369 
370  i += run;
371  if (i > MAX_INDEX)
372  break;
373  j = scantable[i];
374  if (level < 0) {
375  level = ((-level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
376  level = -level;
377  } else {
378  level = ((level * 2 + 1) * qscale * quant_matrix[j]) >> 5;
379  }
380  }
381 
382  mismatch ^= level;
383  block[j] = level;
384  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
385  break;
386  UPDATE_CACHE(re, &s->gb);
387  }
388 end:
389  LAST_SKIP_BITS(re, &s->gb, 2);
390  CLOSE_READER(re, &s->gb);
391  }
392  block[63] ^= (mismatch & 1);
393 
395 
396  s->block_last_index[n] = i;
397  return 0;
398 }
399 
400 /**
401  * Changing this would eat up any speed benefits it has.
402  * Do not use "fast" flag if you need the code to be robust.
403  */
405  int16_t *block, int n)
406 {
407  int level, i, j, run;
408  RLTable *rl = &ff_rl_mpeg1;
409  uint8_t *const scantable = s->intra_scantable.permutated;
410  const int qscale = s->qscale;
411  OPEN_READER(re, &s->gb);
412  i = -1;
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) >> 1;
418  if (GET_CACHE(re, &s->gb) & 0x40000000)
419  level = -level;
420  block[0] = level;
421  i++;
422  SKIP_BITS(re, &s->gb, 2);
423  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF)
424  goto end;
425  }
426 
427  /* now quantify & encode AC coefficients */
428  for (;;) {
429  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0], TEX_VLC_BITS, 2, 0);
430 
431  if (level != 0) {
432  i += run;
433  if (i > MAX_INDEX)
434  break;
435  j = scantable[i];
436  level = ((level * 2 + 1) * qscale) >> 1;
437  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
438  SHOW_SBITS(re, &s->gb, 1);
439  SKIP_BITS(re, &s->gb, 1);
440  } else {
441  /* escape */
442  run = SHOW_UBITS(re, &s->gb, 6) + 1;
443  LAST_SKIP_BITS(re, &s->gb, 6);
444  UPDATE_CACHE(re, &s->gb);
445  level = SHOW_SBITS(re, &s->gb, 12);
446  SKIP_BITS(re, &s->gb, 12);
447 
448  i += run;
449  if (i > MAX_INDEX)
450  break;
451  j = scantable[i];
452  if (level < 0) {
453  level = ((-level * 2 + 1) * qscale) >> 1;
454  level = -level;
455  } else {
456  level = ((level * 2 + 1) * qscale) >> 1;
457  }
458  }
459 
460  block[j] = level;
461  if (((int32_t) GET_CACHE(re, &s->gb)) <= (int32_t) 0xBFFFFFFF || i > 63)
462  break;
463 
464  UPDATE_CACHE(re, &s->gb);
465  }
466 end:
467  LAST_SKIP_BITS(re, &s->gb, 2);
468  CLOSE_READER(re, &s->gb);
469 
471 
472  s->block_last_index[n] = i;
473  return 0;
474 }
475 
477  int16_t *block, int n)
478 {
479  int level, dc, diff, i, j, run;
480  int component;
481  RLTable *rl;
482  uint8_t *const scantable = s->intra_scantable.permutated;
483  const uint16_t *quant_matrix;
484  const int qscale = s->qscale;
485  int mismatch;
486 
487  /* DC coefficient */
488  if (n < 4) {
489  quant_matrix = s->intra_matrix;
490  component = 0;
491  } else {
492  quant_matrix = s->chroma_intra_matrix;
493  component = (n & 1) + 1;
494  }
495  diff = decode_dc(&s->gb, component);
496  dc = s->last_dc[component];
497  dc += diff;
498  s->last_dc[component] = dc;
499  block[0] = dc * (1 << (3 - s->intra_dc_precision));
500  ff_tlog(s->avctx, "dc=%d\n", block[0]);
501  mismatch = block[0] ^ 1;
502  i = 0;
503  if (s->intra_vlc_format)
504  rl = &ff_rl_mpeg2;
505  else
506  rl = &ff_rl_mpeg1;
507 
508  {
509  OPEN_READER(re, &s->gb);
510  /* now quantify & encode AC coefficients */
511  for (;;) {
512  UPDATE_CACHE(re, &s->gb);
513  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
514  TEX_VLC_BITS, 2, 0);
515 
516  if (level == 127) {
517  break;
518  } else if (level != 0) {
519  i += run;
520  if (i > MAX_INDEX)
521  break;
522  j = scantable[i];
523  level = (level * qscale * quant_matrix[j]) >> 4;
524  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
525  SHOW_SBITS(re, &s->gb, 1);
526  LAST_SKIP_BITS(re, &s->gb, 1);
527  } else {
528  /* escape */
529  run = SHOW_UBITS(re, &s->gb, 6) + 1;
530  SKIP_BITS(re, &s->gb, 6);
531  level = SHOW_SBITS(re, &s->gb, 12);
532  LAST_SKIP_BITS(re, &s->gb, 12);
533  i += run;
534  if (i > MAX_INDEX)
535  break;
536  j = scantable[i];
537  if (level < 0) {
538  level = (-level * qscale * quant_matrix[j]) >> 4;
539  level = -level;
540  } else {
541  level = (level * qscale * quant_matrix[j]) >> 4;
542  }
543  }
544 
545  mismatch ^= level;
546  block[j] = level;
547  }
548  CLOSE_READER(re, &s->gb);
549  }
550  block[63] ^= mismatch & 1;
551 
553 
554  s->block_last_index[n] = i;
555  return 0;
556 }
557 
558 /**
559  * Changing this would eat up any speed benefits it has.
560  * Do not use "fast" flag if you need the code to be robust.
561  */
563  int16_t *block, int n)
564 {
565  int level, dc, diff, i, j, run;
566  int component;
567  RLTable *rl;
568  uint8_t *const scantable = s->intra_scantable.permutated;
569  const uint16_t *quant_matrix;
570  const int qscale = s->qscale;
571 
572  /* DC coefficient */
573  if (n < 4) {
574  quant_matrix = s->intra_matrix;
575  component = 0;
576  } else {
577  quant_matrix = s->chroma_intra_matrix;
578  component = (n & 1) + 1;
579  }
580  diff = decode_dc(&s->gb, component);
581  dc = s->last_dc[component];
582  dc += diff;
583  s->last_dc[component] = dc;
584  block[0] = dc * (1 << (3 - s->intra_dc_precision));
585  i = 0;
586  if (s->intra_vlc_format)
587  rl = &ff_rl_mpeg2;
588  else
589  rl = &ff_rl_mpeg1;
590 
591  {
592  OPEN_READER(re, &s->gb);
593  /* now quantify & encode AC coefficients */
594  for (;;) {
595  UPDATE_CACHE(re, &s->gb);
596  GET_RL_VLC(level, run, re, &s->gb, rl->rl_vlc[0],
597  TEX_VLC_BITS, 2, 0);
598 
599  if (level >= 64 || i > 63) {
600  break;
601  } else if (level != 0) {
602  i += run;
603  j = scantable[i];
604  level = (level * qscale * quant_matrix[j]) >> 4;
605  level = (level ^ SHOW_SBITS(re, &s->gb, 1)) -
606  SHOW_SBITS(re, &s->gb, 1);
607  LAST_SKIP_BITS(re, &s->gb, 1);
608  } else {
609  /* escape */
610  run = SHOW_UBITS(re, &s->gb, 6) + 1;
611  SKIP_BITS(re, &s->gb, 6);
612  level = SHOW_SBITS(re, &s->gb, 12);
613  LAST_SKIP_BITS(re, &s->gb, 12);
614  i += run;
615  j = scantable[i];
616  if (level < 0) {
617  level = (-level * qscale * quant_matrix[j]) >> 4;
618  level = -level;
619  } else {
620  level = (level * qscale * quant_matrix[j]) >> 4;
621  }
622  }
623 
624  block[j] = level;
625  }
626  CLOSE_READER(re, &s->gb);
627  }
628 
630 
631  s->block_last_index[n] = i;
632  return 0;
633 }
634 
635 /******************************************/
636 /* decoding */
637 
638 static inline int get_dmv(MpegEncContext *s)
639 {
640  if (get_bits1(&s->gb))
641  return 1 - (get_bits1(&s->gb) << 1);
642  else
643  return 0;
644 }
645 
646 /* motion type (for MPEG-2) */
647 #define MT_FIELD 1
648 #define MT_FRAME 2
649 #define MT_16X8 2
650 #define MT_DMV 3
651 
652 static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
653 {
654  int i, j, k, cbp, val, mb_type, motion_type;
655  const int mb_block_count = 4 + (1 << s->chroma_format);
656  int ret;
657 
658  ff_tlog(s->avctx, "decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
659 
660  av_assert2(s->mb_skipped == 0);
661 
662  if (s->mb_skip_run-- != 0) {
663  if (s->pict_type == AV_PICTURE_TYPE_P) {
664  s->mb_skipped = 1;
665  s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
667  } else {
668  int mb_type;
669 
670  if (s->mb_x)
671  mb_type = s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride - 1];
672  else
673  // FIXME not sure if this is allowed in MPEG at all
674  mb_type = s->current_picture.mb_type[s->mb_width + (s->mb_y - 1) * s->mb_stride - 1];
675  if (IS_INTRA(mb_type)) {
676  av_log(s->avctx, AV_LOG_ERROR, "skip with previntra\n");
677  return AVERROR_INVALIDDATA;
678  }
679  s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
680  mb_type | MB_TYPE_SKIP;
681 
682  if ((s->mv[0][0][0] | s->mv[0][0][1] | s->mv[1][0][0] | s->mv[1][0][1]) == 0)
683  s->mb_skipped = 1;
684  }
685 
686  return 0;
687  }
688 
689  switch (s->pict_type) {
690  default:
691  case AV_PICTURE_TYPE_I:
692  if (get_bits1(&s->gb) == 0) {
693  if (get_bits1(&s->gb) == 0) {
694  av_log(s->avctx, AV_LOG_ERROR,
695  "Invalid mb type in I-frame at %d %d\n",
696  s->mb_x, s->mb_y);
697  return AVERROR_INVALIDDATA;
698  }
699  mb_type = MB_TYPE_QUANT | MB_TYPE_INTRA;
700  } else {
701  mb_type = MB_TYPE_INTRA;
702  }
703  break;
704  case AV_PICTURE_TYPE_P:
705  mb_type = get_vlc2(&s->gb, ff_mb_ptype_vlc.table, MB_PTYPE_VLC_BITS, 1);
706  if (mb_type < 0) {
707  av_log(s->avctx, AV_LOG_ERROR,
708  "Invalid mb type in P-frame at %d %d\n", s->mb_x, s->mb_y);
709  return AVERROR_INVALIDDATA;
710  }
711  mb_type = ptype2mb_type[mb_type];
712  break;
713  case AV_PICTURE_TYPE_B:
714  mb_type = get_vlc2(&s->gb, ff_mb_btype_vlc.table, MB_BTYPE_VLC_BITS, 1);
715  if (mb_type < 0) {
716  av_log(s->avctx, AV_LOG_ERROR,
717  "Invalid mb type in B-frame at %d %d\n", s->mb_x, s->mb_y);
718  return AVERROR_INVALIDDATA;
719  }
720  mb_type = btype2mb_type[mb_type];
721  break;
722  }
723  ff_tlog(s->avctx, "mb_type=%x\n", mb_type);
724 // motion_type = 0; /* avoid warning */
725  if (IS_INTRA(mb_type)) {
726  s->bdsp.clear_blocks(s->block[0]);
727 
728  if (!s->chroma_y_shift)
729  s->bdsp.clear_blocks(s->block[6]);
730 
731  /* compute DCT type */
732  // FIXME: add an interlaced_dct coded var?
733  if (s->picture_structure == PICT_FRAME &&
734  !s->frame_pred_frame_dct)
735  s->interlaced_dct = get_bits1(&s->gb);
736 
737  if (IS_QUANT(mb_type))
738  s->qscale = mpeg_get_qscale(s);
739 
740  if (s->concealment_motion_vectors) {
741  /* just parse them */
742  if (s->picture_structure != PICT_FRAME)
743  skip_bits1(&s->gb); /* field select */
744 
745  s->mv[0][0][0] =
746  s->last_mv[0][0][0] =
747  s->last_mv[0][1][0] = mpeg_decode_motion(s, s->mpeg_f_code[0][0],
748  s->last_mv[0][0][0]);
749  s->mv[0][0][1] =
750  s->last_mv[0][0][1] =
751  s->last_mv[0][1][1] = mpeg_decode_motion(s, s->mpeg_f_code[0][1],
752  s->last_mv[0][0][1]);
753 
754  check_marker(s->avctx, &s->gb, "after concealment_motion_vectors");
755  } else {
756  /* reset mv prediction */
757  memset(s->last_mv, 0, sizeof(s->last_mv));
758  }
759  s->mb_intra = 1;
760  // if 1, we memcpy blocks in xvmcvideo
761  if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
762  ff_xvmc_pack_pblocks(s, -1); // inter are always full blocks
763 
764  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
765  if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
766  for (i = 0; i < 6; i++)
767  mpeg2_fast_decode_block_intra(s, *s->pblocks[i], i);
768  } else {
769  for (i = 0; i < mb_block_count; i++)
770  if ((ret = mpeg2_decode_block_intra(s, *s->pblocks[i], i)) < 0)
771  return ret;
772  }
773  } else {
774  for (i = 0; i < 6; i++) {
776  s->intra_matrix,
777  s->intra_scantable.permutated,
778  s->last_dc, *s->pblocks[i],
779  i, s->qscale);
780  if (ret < 0) {
781  av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n",
782  s->mb_x, s->mb_y);
783  return ret;
784  }
785 
786  s->block_last_index[i] = ret;
787  }
788  }
789  } else {
790  if (mb_type & MB_TYPE_ZERO_MV) {
791  av_assert2(mb_type & MB_TYPE_CBP);
792 
793  s->mv_dir = MV_DIR_FORWARD;
794  if (s->picture_structure == PICT_FRAME) {
795  if (s->picture_structure == PICT_FRAME
796  && !s->frame_pred_frame_dct)
797  s->interlaced_dct = get_bits1(&s->gb);
798  s->mv_type = MV_TYPE_16X16;
799  } else {
800  s->mv_type = MV_TYPE_FIELD;
801  mb_type |= MB_TYPE_INTERLACED;
802  s->field_select[0][0] = s->picture_structure - 1;
803  }
804 
805  if (IS_QUANT(mb_type))
806  s->qscale = mpeg_get_qscale(s);
807 
808  s->last_mv[0][0][0] = 0;
809  s->last_mv[0][0][1] = 0;
810  s->last_mv[0][1][0] = 0;
811  s->last_mv[0][1][1] = 0;
812  s->mv[0][0][0] = 0;
813  s->mv[0][0][1] = 0;
814  } else {
815  av_assert2(mb_type & MB_TYPE_L0L1);
816  // FIXME decide if MBs in field pictures are MB_TYPE_INTERLACED
817  /* get additional motion vector type */
818  if (s->picture_structure == PICT_FRAME && s->frame_pred_frame_dct) {
819  motion_type = MT_FRAME;
820  } else {
821  motion_type = get_bits(&s->gb, 2);
822  if (s->picture_structure == PICT_FRAME && HAS_CBP(mb_type))
823  s->interlaced_dct = get_bits1(&s->gb);
824  }
825 
826  if (IS_QUANT(mb_type))
827  s->qscale = mpeg_get_qscale(s);
828 
829  /* motion vectors */
830  s->mv_dir = (mb_type >> 13) & 3;
831  ff_tlog(s->avctx, "motion_type=%d\n", motion_type);
832  switch (motion_type) {
833  case MT_FRAME: /* or MT_16X8 */
834  if (s->picture_structure == PICT_FRAME) {
835  mb_type |= MB_TYPE_16x16;
836  s->mv_type = MV_TYPE_16X16;
837  for (i = 0; i < 2; i++) {
838  if (USES_LIST(mb_type, i)) {
839  /* MT_FRAME */
840  s->mv[i][0][0] =
841  s->last_mv[i][0][0] =
842  s->last_mv[i][1][0] =
843  mpeg_decode_motion(s, s->mpeg_f_code[i][0],
844  s->last_mv[i][0][0]);
845  s->mv[i][0][1] =
846  s->last_mv[i][0][1] =
847  s->last_mv[i][1][1] =
848  mpeg_decode_motion(s, s->mpeg_f_code[i][1],
849  s->last_mv[i][0][1]);
850  /* full_pel: only for MPEG-1 */
851  if (s->full_pel[i]) {
852  s->mv[i][0][0] *= 2;
853  s->mv[i][0][1] *= 2;
854  }
855  }
856  }
857  } else {
858  mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
859  s->mv_type = MV_TYPE_16X8;
860  for (i = 0; i < 2; i++) {
861  if (USES_LIST(mb_type, i)) {
862  /* MT_16X8 */
863  for (j = 0; j < 2; j++) {
864  s->field_select[i][j] = get_bits1(&s->gb);
865  for (k = 0; k < 2; k++) {
866  val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
867  s->last_mv[i][j][k]);
868  s->last_mv[i][j][k] = val;
869  s->mv[i][j][k] = val;
870  }
871  }
872  }
873  }
874  }
875  break;
876  case MT_FIELD:
877  s->mv_type = MV_TYPE_FIELD;
878  if (s->picture_structure == PICT_FRAME) {
879  mb_type |= MB_TYPE_16x8 | MB_TYPE_INTERLACED;
880  for (i = 0; i < 2; i++) {
881  if (USES_LIST(mb_type, i)) {
882  for (j = 0; j < 2; j++) {
883  s->field_select[i][j] = get_bits1(&s->gb);
884  val = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
885  s->last_mv[i][j][0]);
886  s->last_mv[i][j][0] = val;
887  s->mv[i][j][0] = val;
888  ff_tlog(s->avctx, "fmx=%d\n", val);
889  val = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
890  s->last_mv[i][j][1] >> 1);
891  s->last_mv[i][j][1] = 2 * val;
892  s->mv[i][j][1] = val;
893  ff_tlog(s->avctx, "fmy=%d\n", val);
894  }
895  }
896  }
897  } else {
898  av_assert0(!s->progressive_sequence);
899  mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
900  for (i = 0; i < 2; i++) {
901  if (USES_LIST(mb_type, i)) {
902  s->field_select[i][0] = get_bits1(&s->gb);
903  for (k = 0; k < 2; k++) {
904  val = mpeg_decode_motion(s, s->mpeg_f_code[i][k],
905  s->last_mv[i][0][k]);
906  s->last_mv[i][0][k] = val;
907  s->last_mv[i][1][k] = val;
908  s->mv[i][0][k] = val;
909  }
910  }
911  }
912  }
913  break;
914  case MT_DMV:
915  if (s->progressive_sequence){
916  av_log(s->avctx, AV_LOG_ERROR, "MT_DMV in progressive_sequence\n");
917  return AVERROR_INVALIDDATA;
918  }
919  s->mv_type = MV_TYPE_DMV;
920  for (i = 0; i < 2; i++) {
921  if (USES_LIST(mb_type, i)) {
922  int dmx, dmy, mx, my, m;
923  const int my_shift = s->picture_structure == PICT_FRAME;
924 
925  mx = mpeg_decode_motion(s, s->mpeg_f_code[i][0],
926  s->last_mv[i][0][0]);
927  s->last_mv[i][0][0] = mx;
928  s->last_mv[i][1][0] = mx;
929  dmx = get_dmv(s);
930  my = mpeg_decode_motion(s, s->mpeg_f_code[i][1],
931  s->last_mv[i][0][1] >> my_shift);
932  dmy = get_dmv(s);
933 
934 
935  s->last_mv[i][0][1] = my * (1 << my_shift);
936  s->last_mv[i][1][1] = my * (1 << my_shift);
937 
938  s->mv[i][0][0] = mx;
939  s->mv[i][0][1] = my;
940  s->mv[i][1][0] = mx; // not used
941  s->mv[i][1][1] = my; // not used
942 
943  if (s->picture_structure == PICT_FRAME) {
944  mb_type |= MB_TYPE_16x16 | MB_TYPE_INTERLACED;
945 
946  // m = 1 + 2 * s->top_field_first;
947  m = s->top_field_first ? 1 : 3;
948 
949  /* top -> top pred */
950  s->mv[i][2][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
951  s->mv[i][2][1] = ((my * m + (my > 0)) >> 1) + dmy - 1;
952  m = 4 - m;
953  s->mv[i][3][0] = ((mx * m + (mx > 0)) >> 1) + dmx;
954  s->mv[i][3][1] = ((my * m + (my > 0)) >> 1) + dmy + 1;
955  } else {
956  mb_type |= MB_TYPE_16x16;
957 
958  s->mv[i][2][0] = ((mx + (mx > 0)) >> 1) + dmx;
959  s->mv[i][2][1] = ((my + (my > 0)) >> 1) + dmy;
960  if (s->picture_structure == PICT_TOP_FIELD)
961  s->mv[i][2][1]--;
962  else
963  s->mv[i][2][1]++;
964  }
965  }
966  }
967  break;
968  default:
969  av_log(s->avctx, AV_LOG_ERROR,
970  "00 motion_type at %d %d\n", s->mb_x, s->mb_y);
971  return AVERROR_INVALIDDATA;
972  }
973  }
974 
975  s->mb_intra = 0;
976  if (HAS_CBP(mb_type)) {
977  s->bdsp.clear_blocks(s->block[0]);
978 
979  cbp = get_vlc2(&s->gb, ff_mb_pat_vlc.table, MB_PAT_VLC_BITS, 1);
980  if (mb_block_count > 6) {
981  cbp *= 1 << mb_block_count - 6;
982  cbp |= get_bits(&s->gb, mb_block_count - 6);
983  s->bdsp.clear_blocks(s->block[6]);
984  }
985  if (cbp <= 0) {
986  av_log(s->avctx, AV_LOG_ERROR,
987  "invalid cbp %d at %d %d\n", cbp, s->mb_x, s->mb_y);
988  return AVERROR_INVALIDDATA;
989  }
990 
991  // if 1, we memcpy blocks in xvmcvideo
992  if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
993  ff_xvmc_pack_pblocks(s, cbp);
994 
995  if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
996  if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
997  for (i = 0; i < 6; i++) {
998  if (cbp & 32)
999  mpeg2_fast_decode_block_non_intra(s, *s->pblocks[i], i);
1000  else
1001  s->block_last_index[i] = -1;
1002  cbp += cbp;
1003  }
1004  } else {
1005  cbp <<= 12 - mb_block_count;
1006 
1007  for (i = 0; i < mb_block_count; i++) {
1008  if (cbp & (1 << 11)) {
1009  if ((ret = mpeg2_decode_block_non_intra(s, *s->pblocks[i], i)) < 0)
1010  return ret;
1011  } else {
1012  s->block_last_index[i] = -1;
1013  }
1014  cbp += cbp;
1015  }
1016  }
1017  } else {
1018  if (s->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1019  for (i = 0; i < 6; i++) {
1020  if (cbp & 32)
1021  mpeg1_fast_decode_block_inter(s, *s->pblocks[i], i);
1022  else
1023  s->block_last_index[i] = -1;
1024  cbp += cbp;
1025  }
1026  } else {
1027  for (i = 0; i < 6; i++) {
1028  if (cbp & 32) {
1029  if ((ret = mpeg1_decode_block_inter(s, *s->pblocks[i], i)) < 0)
1030  return ret;
1031  } else {
1032  s->block_last_index[i] = -1;
1033  }
1034  cbp += cbp;
1035  }
1036  }
1037  }
1038  } else {
1039  for (i = 0; i < 12; i++)
1040  s->block_last_index[i] = -1;
1041  }
1042  }
1043 
1044  s->current_picture.mb_type[s->mb_x + s->mb_y * s->mb_stride] = mb_type;
1045 
1046  return 0;
1047 }
1048 
1050 {
1051  Mpeg1Context *s = avctx->priv_data;
1052  MpegEncContext *s2 = &s->mpeg_enc_ctx;
1053 
1054  if ( avctx->codec_tag != AV_RL32("VCR2")
1055  && avctx->codec_tag != AV_RL32("BW10"))
1056  avctx->coded_width = avctx->coded_height = 0; // do not trust dimensions from input
1057  ff_mpv_decode_init(s2, avctx);
1058 
1059  /* we need some permutation to store matrices,
1060  * until the decoder sets the real permutation. */
1062  ff_mpeg12_common_init(&s->mpeg_enc_ctx);
1064 
1065  s2->chroma_format = 1;
1066  s->mpeg_enc_ctx_allocated = 0;
1067  s->mpeg_enc_ctx.picture_number = 0;
1068  s->repeat_field = 0;
1069  avctx->color_range = AVCOL_RANGE_MPEG;
1070  return 0;
1071 }
1072 
1073 #if HAVE_THREADS
1074 static int mpeg_decode_update_thread_context(AVCodecContext *avctx,
1075  const AVCodecContext *avctx_from)
1076 {
1077  Mpeg1Context *ctx = avctx->priv_data, *ctx_from = avctx_from->priv_data;
1078  MpegEncContext *s = &ctx->mpeg_enc_ctx, *s1 = &ctx_from->mpeg_enc_ctx;
1079  int err;
1080 
1081  if (avctx == avctx_from ||
1082  !ctx_from->mpeg_enc_ctx_allocated ||
1083  !s1->context_initialized)
1084  return 0;
1085 
1086  err = ff_mpeg_update_thread_context(avctx, avctx_from);
1087  if (err)
1088  return err;
1089 
1090  if (!ctx->mpeg_enc_ctx_allocated)
1091  memcpy(s + 1, s1 + 1, sizeof(Mpeg1Context) - sizeof(MpegEncContext));
1092 
1093  if (!(s->pict_type == AV_PICTURE_TYPE_B || s->low_delay))
1094  s->picture_number++;
1095 
1096  return 0;
1097 }
1098 #endif
1099 
1100 static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm,
1101  const uint8_t *new_perm)
1102 {
1103  uint16_t temp_matrix[64];
1104  int i;
1105 
1106  memcpy(temp_matrix, matrix, 64 * sizeof(uint16_t));
1107 
1108  for (i = 0; i < 64; i++)
1109  matrix[new_perm[i]] = temp_matrix[old_perm[i]];
1110 }
1111 
1113 #if CONFIG_MPEG1_NVDEC_HWACCEL
1115 #endif
1116 #if CONFIG_MPEG1_XVMC_HWACCEL
1118 #endif
1119 #if CONFIG_MPEG1_VDPAU_HWACCEL
1121 #endif
1124 };
1125 
1127 #if CONFIG_MPEG2_NVDEC_HWACCEL
1129 #endif
1130 #if CONFIG_MPEG2_XVMC_HWACCEL
1132 #endif
1133 #if CONFIG_MPEG2_VDPAU_HWACCEL
1135 #endif
1136 #if CONFIG_MPEG2_DXVA2_HWACCEL
1138 #endif
1139 #if CONFIG_MPEG2_D3D11VA_HWACCEL
1142 #endif
1143 #if CONFIG_MPEG2_VAAPI_HWACCEL
1145 #endif
1146 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
1148 #endif
1151 };
1152 
1153 static const enum AVPixelFormat mpeg12_pixfmt_list_422[] = {
1156 };
1157 
1158 static const enum AVPixelFormat mpeg12_pixfmt_list_444[] = {
1161 };
1162 
1164 {
1165  Mpeg1Context *s1 = avctx->priv_data;
1166  MpegEncContext *s = &s1->mpeg_enc_ctx;
1167  const enum AVPixelFormat *pix_fmts;
1168 
1169  if (CONFIG_GRAY && (avctx->flags & AV_CODEC_FLAG_GRAY))
1170  return AV_PIX_FMT_GRAY8;
1171 
1172  if (s->chroma_format < 2)
1176  else if (s->chroma_format == 2)
1178  else
1180 
1181  return ff_thread_get_format(avctx, pix_fmts);
1182 }
1183 
1185 {
1186  // until then pix_fmt may be changed right after codec init
1187  if (avctx->hwaccel)
1188  if (avctx->idct_algo == FF_IDCT_AUTO)
1189  avctx->idct_algo = FF_IDCT_NONE;
1190 
1191  if (avctx->hwaccel && avctx->pix_fmt == AV_PIX_FMT_XVMC) {
1192  Mpeg1Context *s1 = avctx->priv_data;
1193  MpegEncContext *s = &s1->mpeg_enc_ctx;
1194 
1195  s->pack_pblocks = 1;
1196  }
1197 }
1198 
1199 /* Call this function when we know all parameters.
1200  * It may be called in different places for MPEG-1 and MPEG-2. */
1202 {
1203  Mpeg1Context *s1 = avctx->priv_data;
1204  MpegEncContext *s = &s1->mpeg_enc_ctx;
1205  uint8_t old_permutation[64];
1206  int ret;
1207 
1208  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1209  // MPEG-1 aspect
1210  AVRational aspect_inv = av_d2q(ff_mpeg1_aspect[s->aspect_ratio_info], 255);
1211  avctx->sample_aspect_ratio = (AVRational) { aspect_inv.den, aspect_inv.num };
1212  } else { // MPEG-2
1213  // MPEG-2 aspect
1214  if (s->aspect_ratio_info > 1) {
1215  AVRational dar =
1216  av_mul_q(av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1217  (AVRational) { s1->pan_scan.width,
1218  s1->pan_scan.height }),
1219  (AVRational) { s->width, s->height });
1220 
1221  /* We ignore the spec here and guess a bit as reality does not
1222  * match the spec, see for example res_change_ffmpeg_aspect.ts
1223  * and sequence-display-aspect.mpg.
1224  * issue1613, 621, 562 */
1225  if ((s1->pan_scan.width == 0) || (s1->pan_scan.height == 0) ||
1226  (av_cmp_q(dar, (AVRational) { 4, 3 }) &&
1227  av_cmp_q(dar, (AVRational) { 16, 9 }))) {
1228  s->avctx->sample_aspect_ratio =
1229  av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1230  (AVRational) { s->width, s->height });
1231  } else {
1232  s->avctx->sample_aspect_ratio =
1233  av_div_q(ff_mpeg2_aspect[s->aspect_ratio_info],
1234  (AVRational) { s1->pan_scan.width, s1->pan_scan.height });
1235 // issue1613 4/3 16/9 -> 16/9
1236 // res_change_ffmpeg_aspect.ts 4/3 225/44 ->4/3
1237 // widescreen-issue562.mpg 4/3 16/9 -> 16/9
1238 // s->avctx->sample_aspect_ratio = av_mul_q(s->avctx->sample_aspect_ratio, (AVRational) {s->width, s->height});
1239  ff_dlog(avctx, "aspect A %d/%d\n",
1240  ff_mpeg2_aspect[s->aspect_ratio_info].num,
1241  ff_mpeg2_aspect[s->aspect_ratio_info].den);
1242  ff_dlog(avctx, "aspect B %d/%d\n", s->avctx->sample_aspect_ratio.num,
1243  s->avctx->sample_aspect_ratio.den);
1244  }
1245  } else {
1246  s->avctx->sample_aspect_ratio =
1247  ff_mpeg2_aspect[s->aspect_ratio_info];
1248  }
1249  } // MPEG-2
1250 
1251  if (av_image_check_sar(s->width, s->height,
1252  avctx->sample_aspect_ratio) < 0) {
1253  av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1254  avctx->sample_aspect_ratio.num,
1255  avctx->sample_aspect_ratio.den);
1256  avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1257  }
1258 
1259  if ((s1->mpeg_enc_ctx_allocated == 0) ||
1260  avctx->coded_width != s->width ||
1261  avctx->coded_height != s->height ||
1262  s1->save_width != s->width ||
1263  s1->save_height != s->height ||
1264  av_cmp_q(s1->save_aspect, s->avctx->sample_aspect_ratio) ||
1265  (s1->save_progressive_seq != s->progressive_sequence && FFALIGN(s->height, 16) != FFALIGN(s->height, 32)) ||
1266  0) {
1267  if (s1->mpeg_enc_ctx_allocated) {
1268 #if FF_API_FLAG_TRUNCATED
1269  ParseContext pc = s->parse_context;
1270  s->parse_context.buffer = 0;
1272  s->parse_context = pc;
1273 #else
1275 #endif
1276  s1->mpeg_enc_ctx_allocated = 0;
1277  }
1278 
1279  ret = ff_set_dimensions(avctx, s->width, s->height);
1280  if (ret < 0)
1281  return ret;
1282 
1283  if (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO && s->bit_rate) {
1284  avctx->rc_max_rate = s->bit_rate;
1285  } else if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && s->bit_rate &&
1286  (s->bit_rate != 0x3FFFF*400 || s->vbv_delay != 0xFFFF)) {
1287  avctx->bit_rate = s->bit_rate;
1288  }
1289  s1->save_aspect = s->avctx->sample_aspect_ratio;
1290  s1->save_width = s->width;
1291  s1->save_height = s->height;
1292  s1->save_progressive_seq = s->progressive_sequence;
1293 
1294  /* low_delay may be forced, in this case we will have B-frames
1295  * that behave like P-frames. */
1296  avctx->has_b_frames = !s->low_delay;
1297 
1298  if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
1299  // MPEG-1 fps
1300  avctx->framerate = ff_mpeg12_frame_rate_tab[s->frame_rate_index];
1301  avctx->ticks_per_frame = 1;
1302 
1304  } else { // MPEG-2
1305  // MPEG-2 fps
1306  av_reduce(&s->avctx->framerate.num,
1307  &s->avctx->framerate.den,
1308  ff_mpeg12_frame_rate_tab[s->frame_rate_index].num * s1->frame_rate_ext.num,
1309  ff_mpeg12_frame_rate_tab[s->frame_rate_index].den * s1->frame_rate_ext.den,
1310  1 << 30);
1311  avctx->ticks_per_frame = 2;
1312 
1313  switch (s->chroma_format) {
1314  case 1: avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; break;
1315  case 2:
1316  case 3: avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT; break;
1317  default: av_assert0(0);
1318  }
1319  } // MPEG-2
1320 
1321  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
1322  setup_hwaccel_for_pixfmt(avctx);
1323 
1324  /* Quantization matrices may need reordering
1325  * if DCT permutation is changed. */
1326  memcpy(old_permutation, s->idsp.idct_permutation, 64 * sizeof(uint8_t));
1327 
1329  if ((ret = ff_mpv_common_init(s)) < 0)
1330  return ret;
1331 
1332  quant_matrix_rebuild(s->intra_matrix, old_permutation, s->idsp.idct_permutation);
1333  quant_matrix_rebuild(s->inter_matrix, old_permutation, s->idsp.idct_permutation);
1334  quant_matrix_rebuild(s->chroma_intra_matrix, old_permutation, s->idsp.idct_permutation);
1335  quant_matrix_rebuild(s->chroma_inter_matrix, old_permutation, s->idsp.idct_permutation);
1336 
1337  s1->mpeg_enc_ctx_allocated = 1;
1338  }
1339  return 0;
1340 }
1341 
1342 static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf,
1343  int buf_size)
1344 {
1345  Mpeg1Context *s1 = avctx->priv_data;
1346  MpegEncContext *s = &s1->mpeg_enc_ctx;
1347  int ref, f_code, vbv_delay, ret;
1348 
1349  ret = init_get_bits8(&s->gb, buf, buf_size);
1350  if (ret < 0)
1351  return ret;
1352 
1353  ref = get_bits(&s->gb, 10); /* temporal ref */
1354  s->pict_type = get_bits(&s->gb, 3);
1355  if (s->pict_type == 0 || s->pict_type > 3)
1356  return AVERROR_INVALIDDATA;
1357 
1358  vbv_delay = get_bits(&s->gb, 16);
1359  s->vbv_delay = vbv_delay;
1360  if (s->pict_type == AV_PICTURE_TYPE_P ||
1361  s->pict_type == AV_PICTURE_TYPE_B) {
1362  s->full_pel[0] = get_bits1(&s->gb);
1363  f_code = get_bits(&s->gb, 3);
1364  if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1365  return AVERROR_INVALIDDATA;
1366  f_code += !f_code;
1367  s->mpeg_f_code[0][0] = f_code;
1368  s->mpeg_f_code[0][1] = f_code;
1369  }
1370  if (s->pict_type == AV_PICTURE_TYPE_B) {
1371  s->full_pel[1] = get_bits1(&s->gb);
1372  f_code = get_bits(&s->gb, 3);
1373  if (f_code == 0 && (avctx->err_recognition & (AV_EF_BITSTREAM|AV_EF_COMPLIANT)))
1374  return AVERROR_INVALIDDATA;
1375  f_code += !f_code;
1376  s->mpeg_f_code[1][0] = f_code;
1377  s->mpeg_f_code[1][1] = f_code;
1378  }
1379  s->current_picture.f->pict_type = s->pict_type;
1380  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1381 
1382  if (avctx->debug & FF_DEBUG_PICT_INFO)
1383  av_log(avctx, AV_LOG_DEBUG,
1384  "vbv_delay %d, ref %d type:%d\n", vbv_delay, ref, s->pict_type);
1385 
1386  s->y_dc_scale = 8;
1387  s->c_dc_scale = 8;
1388  return 0;
1389 }
1390 
1392 {
1393  MpegEncContext *s = &s1->mpeg_enc_ctx;
1394  int horiz_size_ext, vert_size_ext;
1395  int bit_rate_ext;
1396  AVCPBProperties *cpb_props;
1397 
1398  skip_bits(&s->gb, 1); /* profile and level esc*/
1399  s->avctx->profile = get_bits(&s->gb, 3);
1400  s->avctx->level = get_bits(&s->gb, 4);
1401  s->progressive_sequence = get_bits1(&s->gb); /* progressive_sequence */
1402  s->chroma_format = get_bits(&s->gb, 2); /* chroma_format 1=420, 2=422, 3=444 */
1403 
1404  if (!s->chroma_format) {
1405  s->chroma_format = 1;
1406  av_log(s->avctx, AV_LOG_WARNING, "Chroma format invalid\n");
1407  }
1408 
1409  horiz_size_ext = get_bits(&s->gb, 2);
1410  vert_size_ext = get_bits(&s->gb, 2);
1411  s->width |= (horiz_size_ext << 12);
1412  s->height |= (vert_size_ext << 12);
1413  bit_rate_ext = get_bits(&s->gb, 12); /* XXX: handle it */
1414  s->bit_rate += (bit_rate_ext << 18) * 400LL;
1415  check_marker(s->avctx, &s->gb, "after bit rate extension");
1416  s1->rc_buffer_size += get_bits(&s->gb, 8) * 1024 * 16 << 10;
1417 
1418  s->low_delay = get_bits1(&s->gb);
1419  if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
1420  s->low_delay = 1;
1421 
1422  s1->frame_rate_ext.num = get_bits(&s->gb, 2) + 1;
1423  s1->frame_rate_ext.den = get_bits(&s->gb, 5) + 1;
1424 
1425  ff_dlog(s->avctx, "sequence extension\n");
1426  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
1427 
1428  if (cpb_props = ff_add_cpb_side_data(s->avctx)) {
1429  cpb_props->buffer_size = s1->rc_buffer_size;
1430  if (s->bit_rate != 0x3FFFF*400)
1431  cpb_props->max_bitrate = s->bit_rate;
1432  }
1433 
1434  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1435  av_log(s->avctx, AV_LOG_DEBUG,
1436  "profile: %d, level: %d ps: %d cf:%d vbv buffer: %d, bitrate:%"PRId64"\n",
1437  s->avctx->profile, s->avctx->level, s->progressive_sequence, s->chroma_format,
1438  s1->rc_buffer_size, s->bit_rate);
1439 }
1440 
1442 {
1443  MpegEncContext *s = &s1->mpeg_enc_ctx;
1444  int color_description, w, h;
1445 
1446  skip_bits(&s->gb, 3); /* video format */
1447  color_description = get_bits1(&s->gb);
1448  if (color_description) {
1449  s->avctx->color_primaries = get_bits(&s->gb, 8);
1450  s->avctx->color_trc = get_bits(&s->gb, 8);
1451  s->avctx->colorspace = get_bits(&s->gb, 8);
1452  }
1453  w = get_bits(&s->gb, 14);
1454  skip_bits(&s->gb, 1); // marker
1455  h = get_bits(&s->gb, 14);
1456  // remaining 3 bits are zero padding
1457 
1458  s1->pan_scan.width = 16 * w;
1459  s1->pan_scan.height = 16 * h;
1460 
1461  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1462  av_log(s->avctx, AV_LOG_DEBUG, "sde w:%d, h:%d\n", w, h);
1463 }
1464 
1466 {
1467  MpegEncContext *s = &s1->mpeg_enc_ctx;
1468  int i, nofco;
1469 
1470  nofco = 1;
1471  if (s->progressive_sequence) {
1472  if (s->repeat_first_field) {
1473  nofco++;
1474  if (s->top_field_first)
1475  nofco++;
1476  }
1477  } else {
1478  if (s->picture_structure == PICT_FRAME) {
1479  nofco++;
1480  if (s->repeat_first_field)
1481  nofco++;
1482  }
1483  }
1484  for (i = 0; i < nofco; i++) {
1485  s1->pan_scan.position[i][0] = get_sbits(&s->gb, 16);
1486  skip_bits(&s->gb, 1); // marker
1487  s1->pan_scan.position[i][1] = get_sbits(&s->gb, 16);
1488  skip_bits(&s->gb, 1); // marker
1489  }
1490 
1491  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1492  av_log(s->avctx, AV_LOG_DEBUG,
1493  "pde (%"PRId16",%"PRId16") (%"PRId16",%"PRId16") (%"PRId16",%"PRId16")\n",
1494  s1->pan_scan.position[0][0], s1->pan_scan.position[0][1],
1495  s1->pan_scan.position[1][0], s1->pan_scan.position[1][1],
1496  s1->pan_scan.position[2][0], s1->pan_scan.position[2][1]);
1497 }
1498 
1499 static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
1500  uint16_t matrix1[64], int intra)
1501 {
1502  int i;
1503 
1504  for (i = 0; i < 64; i++) {
1505  int j = s->idsp.idct_permutation[ff_zigzag_direct[i]];
1506  int v = get_bits(&s->gb, 8);
1507  if (v == 0) {
1508  av_log(s->avctx, AV_LOG_ERROR, "matrix damaged\n");
1509  return AVERROR_INVALIDDATA;
1510  }
1511  if (intra && i == 0 && v != 8) {
1512  av_log(s->avctx, AV_LOG_DEBUG, "intra matrix specifies invalid DC quantizer %d, ignoring\n", v);
1513  v = 8; // needed by pink.mpg / issue1046
1514  }
1515  matrix0[j] = v;
1516  if (matrix1)
1517  matrix1[j] = v;
1518  }
1519  return 0;
1520 }
1521 
1523 {
1524  ff_dlog(s->avctx, "matrix extension\n");
1525 
1526  if (get_bits1(&s->gb))
1527  load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
1528  if (get_bits1(&s->gb))
1529  load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
1530  if (get_bits1(&s->gb))
1531  load_matrix(s, s->chroma_intra_matrix, NULL, 1);
1532  if (get_bits1(&s->gb))
1533  load_matrix(s, s->chroma_inter_matrix, NULL, 0);
1534 }
1535 
1537 {
1538  MpegEncContext *s = &s1->mpeg_enc_ctx;
1539 
1540  s->full_pel[0] = s->full_pel[1] = 0;
1541  s->mpeg_f_code[0][0] = get_bits(&s->gb, 4);
1542  s->mpeg_f_code[0][1] = get_bits(&s->gb, 4);
1543  s->mpeg_f_code[1][0] = get_bits(&s->gb, 4);
1544  s->mpeg_f_code[1][1] = get_bits(&s->gb, 4);
1545  s->mpeg_f_code[0][0] += !s->mpeg_f_code[0][0];
1546  s->mpeg_f_code[0][1] += !s->mpeg_f_code[0][1];
1547  s->mpeg_f_code[1][0] += !s->mpeg_f_code[1][0];
1548  s->mpeg_f_code[1][1] += !s->mpeg_f_code[1][1];
1549  if (!s->pict_type && s1->mpeg_enc_ctx_allocated) {
1550  av_log(s->avctx, AV_LOG_ERROR, "Missing picture start code\n");
1551  if (s->avctx->err_recognition & AV_EF_EXPLODE)
1552  return AVERROR_INVALIDDATA;
1553  av_log(s->avctx, AV_LOG_WARNING, "Guessing pict_type from mpeg_f_code\n");
1554  if (s->mpeg_f_code[1][0] == 15 && s->mpeg_f_code[1][1] == 15) {
1555  if (s->mpeg_f_code[0][0] == 15 && s->mpeg_f_code[0][1] == 15)
1556  s->pict_type = AV_PICTURE_TYPE_I;
1557  else
1558  s->pict_type = AV_PICTURE_TYPE_P;
1559  } else
1560  s->pict_type = AV_PICTURE_TYPE_B;
1561  s->current_picture.f->pict_type = s->pict_type;
1562  s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1563  }
1564 
1565  s->intra_dc_precision = get_bits(&s->gb, 2);
1566  s->picture_structure = get_bits(&s->gb, 2);
1567  s->top_field_first = get_bits1(&s->gb);
1568  s->frame_pred_frame_dct = get_bits1(&s->gb);
1569  s->concealment_motion_vectors = get_bits1(&s->gb);
1570  s->q_scale_type = get_bits1(&s->gb);
1571  s->intra_vlc_format = get_bits1(&s->gb);
1572  s->alternate_scan = get_bits1(&s->gb);
1573  s->repeat_first_field = get_bits1(&s->gb);
1574  s->chroma_420_type = get_bits1(&s->gb);
1575  s->progressive_frame = get_bits1(&s->gb);
1576 
1577  if (s->alternate_scan) {
1578  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
1579  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
1580  } else {
1581  ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
1582  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
1583  }
1584 
1585  /* composite display not parsed */
1586  ff_dlog(s->avctx, "intra_dc_precision=%d\n", s->intra_dc_precision);
1587  ff_dlog(s->avctx, "picture_structure=%d\n", s->picture_structure);
1588  ff_dlog(s->avctx, "top field first=%d\n", s->top_field_first);
1589  ff_dlog(s->avctx, "repeat first field=%d\n", s->repeat_first_field);
1590  ff_dlog(s->avctx, "conceal=%d\n", s->concealment_motion_vectors);
1591  ff_dlog(s->avctx, "intra_vlc_format=%d\n", s->intra_vlc_format);
1592  ff_dlog(s->avctx, "alternate_scan=%d\n", s->alternate_scan);
1593  ff_dlog(s->avctx, "frame_pred_frame_dct=%d\n", s->frame_pred_frame_dct);
1594  ff_dlog(s->avctx, "progressive_frame=%d\n", s->progressive_frame);
1595 
1596  return 0;
1597 }
1598 
1599 static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
1600 {
1601  AVCodecContext *avctx = s->avctx;
1602  Mpeg1Context *s1 = (Mpeg1Context *) s;
1603  int ret;
1604 
1605  if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
1606  if (s->mb_width * s->mb_height * 11LL / (33 * 2 * 8) > buf_size)
1607  return AVERROR_INVALIDDATA;
1608  }
1609 
1610  /* start frame decoding */
1611  if (s->first_field || s->picture_structure == PICT_FRAME) {
1612  AVFrameSideData *pan_scan;
1613 
1614  if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
1615  return ret;
1616 
1618 
1619  /* first check if we must repeat the frame */
1620  s->current_picture_ptr->f->repeat_pict = 0;
1621  if (s->repeat_first_field) {
1622  if (s->progressive_sequence) {
1623  if (s->top_field_first)
1624  s->current_picture_ptr->f->repeat_pict = 4;
1625  else
1626  s->current_picture_ptr->f->repeat_pict = 2;
1627  } else if (s->progressive_frame) {
1628  s->current_picture_ptr->f->repeat_pict = 1;
1629  }
1630  }
1631 
1632  pan_scan = av_frame_new_side_data(s->current_picture_ptr->f,
1634  sizeof(s1->pan_scan));
1635  if (!pan_scan)
1636  return AVERROR(ENOMEM);
1637  memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));
1638 
1639  if (s1->a53_buf_ref) {
1641  s->current_picture_ptr->f, AV_FRAME_DATA_A53_CC,
1642  s1->a53_buf_ref);
1643  if (!sd)
1644  av_buffer_unref(&s1->a53_buf_ref);
1645  s1->a53_buf_ref = NULL;
1646  }
1647 
1648  if (s1->has_stereo3d) {
1649  AVStereo3D *stereo = av_stereo3d_create_side_data(s->current_picture_ptr->f);
1650  if (!stereo)
1651  return AVERROR(ENOMEM);
1652 
1653  *stereo = s1->stereo3d;
1654  s1->has_stereo3d = 0;
1655  }
1656 
1657  if (s1->has_afd) {
1658  AVFrameSideData *sd =
1659  av_frame_new_side_data(s->current_picture_ptr->f,
1660  AV_FRAME_DATA_AFD, 1);
1661  if (!sd)
1662  return AVERROR(ENOMEM);
1663 
1664  *sd->data = s1->afd;
1665  s1->has_afd = 0;
1666  }
1667 
1668  if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME))
1669  ff_thread_finish_setup(avctx);
1670  } else { // second field
1671  int i;
1672 
1673  if (!s->current_picture_ptr) {
1674  av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
1675  return AVERROR_INVALIDDATA;
1676  }
1677 
1678  if (s->avctx->hwaccel) {
1679  if ((ret = s->avctx->hwaccel->end_frame(s->avctx)) < 0) {
1680  av_log(avctx, AV_LOG_ERROR,
1681  "hardware accelerator failed to decode first field\n");
1682  return ret;
1683  }
1684  }
1685 
1686  for (i = 0; i < 4; i++) {
1687  s->current_picture.f->data[i] = s->current_picture_ptr->f->data[i];
1688  if (s->picture_structure == PICT_BOTTOM_FIELD)
1689  s->current_picture.f->data[i] +=
1690  s->current_picture_ptr->f->linesize[i];
1691  }
1692  }
1693 
1694  if (avctx->hwaccel) {
1695  if ((ret = avctx->hwaccel->start_frame(avctx, buf, buf_size)) < 0)
1696  return ret;
1697  }
1698 
1699  return 0;
1700 }
1701 
1702 #define DECODE_SLICE_ERROR -1
1703 #define DECODE_SLICE_OK 0
1704 
1705 /**
1706  * Decode a slice.
1707  * MpegEncContext.mb_y must be set to the MB row from the startcode.
1708  * @return DECODE_SLICE_ERROR if the slice is damaged,
1709  * DECODE_SLICE_OK if this slice is OK
1710  */
1711 static int mpeg_decode_slice(MpegEncContext *s, int mb_y,
1712  const uint8_t **buf, int buf_size)
1713 {
1714  AVCodecContext *avctx = s->avctx;
1715  const int lowres = s->avctx->lowres;
1716  const int field_pic = s->picture_structure != PICT_FRAME;
1717  int ret;
1718 
1719  s->resync_mb_x =
1720  s->resync_mb_y = -1;
1721 
1722  av_assert0(mb_y < s->mb_height);
1723 
1724  init_get_bits(&s->gb, *buf, buf_size * 8);
1725  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
1726  skip_bits(&s->gb, 3);
1727 
1729  s->interlaced_dct = 0;
1730 
1731  s->qscale = mpeg_get_qscale(s);
1732 
1733  if (s->qscale == 0) {
1734  av_log(s->avctx, AV_LOG_ERROR, "qscale == 0\n");
1735  return AVERROR_INVALIDDATA;
1736  }
1737 
1738  /* extra slice info */
1739  if (skip_1stop_8data_bits(&s->gb) < 0)
1740  return AVERROR_INVALIDDATA;
1741 
1742  s->mb_x = 0;
1743 
1744  if (mb_y == 0 && s->codec_tag == AV_RL32("SLIF")) {
1745  skip_bits1(&s->gb);
1746  } else {
1747  while (get_bits_left(&s->gb) > 0) {
1748  int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1749  MBINCR_VLC_BITS, 2);
1750  if (code < 0) {
1751  av_log(s->avctx, AV_LOG_ERROR, "first mb_incr damaged\n");
1752  return AVERROR_INVALIDDATA;
1753  }
1754  if (code >= 33) {
1755  if (code == 33)
1756  s->mb_x += 33;
1757  /* otherwise, stuffing, nothing to do */
1758  } else {
1759  s->mb_x += code;
1760  break;
1761  }
1762  }
1763  }
1764 
1765  if (s->mb_x >= (unsigned) s->mb_width) {
1766  av_log(s->avctx, AV_LOG_ERROR, "initial skip overflow\n");
1767  return AVERROR_INVALIDDATA;
1768  }
1769 
1770  if (avctx->hwaccel && avctx->hwaccel->decode_slice) {
1771  const uint8_t *buf_end, *buf_start = *buf - 4; /* include start_code */
1772  int start_code = -1;
1773  buf_end = avpriv_find_start_code(buf_start + 2, *buf + buf_size, &start_code);
1774  if (buf_end < *buf + buf_size)
1775  buf_end -= 4;
1776  s->mb_y = mb_y;
1777  if (avctx->hwaccel->decode_slice(avctx, buf_start, buf_end - buf_start) < 0)
1778  return DECODE_SLICE_ERROR;
1779  *buf = buf_end;
1780  return DECODE_SLICE_OK;
1781  }
1782 
1783  s->resync_mb_x = s->mb_x;
1784  s->resync_mb_y = s->mb_y = mb_y;
1785  s->mb_skip_run = 0;
1787 
1788  if (s->mb_y == 0 && s->mb_x == 0 && (s->first_field || s->picture_structure == PICT_FRAME)) {
1789  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
1790  av_log(s->avctx, AV_LOG_DEBUG,
1791  "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",
1792  s->qscale,
1793  s->mpeg_f_code[0][0], s->mpeg_f_code[0][1],
1794  s->mpeg_f_code[1][0], s->mpeg_f_code[1][1],
1795  s->pict_type == AV_PICTURE_TYPE_I ? "I" :
1796  (s->pict_type == AV_PICTURE_TYPE_P ? "P" :
1797  (s->pict_type == AV_PICTURE_TYPE_B ? "B" : "S")),
1798  s->progressive_sequence ? "ps" : "",
1799  s->progressive_frame ? "pf" : "",
1800  s->alternate_scan ? "alt" : "",
1801  s->top_field_first ? "top" : "",
1802  s->intra_dc_precision, s->picture_structure,
1803  s->frame_pred_frame_dct, s->concealment_motion_vectors,
1804  s->q_scale_type, s->intra_vlc_format,
1805  s->repeat_first_field, s->chroma_420_type ? "420" : "");
1806  }
1807  }
1808 
1809  for (;;) {
1810  // If 1, we memcpy blocks in xvmcvideo.
1811  if ((CONFIG_MPEG1_XVMC_HWACCEL || CONFIG_MPEG2_XVMC_HWACCEL) && s->pack_pblocks)
1812  ff_xvmc_init_block(s); // set s->block
1813 
1814  if ((ret = mpeg_decode_mb(s, s->block)) < 0)
1815  return ret;
1816 
1817  // Note motion_val is normally NULL unless we want to extract the MVs.
1818  if (s->current_picture.motion_val[0] && !s->encoding) {
1819  const int wrap = s->b8_stride;
1820  int xy = s->mb_x * 2 + s->mb_y * 2 * wrap;
1821  int b8_xy = 4 * (s->mb_x + s->mb_y * s->mb_stride);
1822  int motion_x, motion_y, dir, i;
1823 
1824  for (i = 0; i < 2; i++) {
1825  for (dir = 0; dir < 2; dir++) {
1826  if (s->mb_intra ||
1827  (dir == 1 && s->pict_type != AV_PICTURE_TYPE_B)) {
1828  motion_x = motion_y = 0;
1829  } else if (s->mv_type == MV_TYPE_16X16 ||
1830  (s->mv_type == MV_TYPE_FIELD && field_pic)) {
1831  motion_x = s->mv[dir][0][0];
1832  motion_y = s->mv[dir][0][1];
1833  } else { /* if ((s->mv_type == MV_TYPE_FIELD) || (s->mv_type == MV_TYPE_16X8)) */
1834  motion_x = s->mv[dir][i][0];
1835  motion_y = s->mv[dir][i][1];
1836  }
1837 
1838  s->current_picture.motion_val[dir][xy][0] = motion_x;
1839  s->current_picture.motion_val[dir][xy][1] = motion_y;
1840  s->current_picture.motion_val[dir][xy + 1][0] = motion_x;
1841  s->current_picture.motion_val[dir][xy + 1][1] = motion_y;
1842  s->current_picture.ref_index [dir][b8_xy] =
1843  s->current_picture.ref_index [dir][b8_xy + 1] = s->field_select[dir][i];
1844  av_assert2(s->field_select[dir][i] == 0 ||
1845  s->field_select[dir][i] == 1);
1846  }
1847  xy += wrap;
1848  b8_xy += 2;
1849  }
1850  }
1851 
1852  s->dest[0] += 16 >> lowres;
1853  s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
1854  s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
1855 
1856  ff_mpv_reconstruct_mb(s, s->block);
1857 
1858  if (++s->mb_x >= s->mb_width) {
1859  const int mb_size = 16 >> s->avctx->lowres;
1860  int left;
1861 
1862  ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
1864 
1865  s->mb_x = 0;
1866  s->mb_y += 1 << field_pic;
1867 
1868  if (s->mb_y >= s->mb_height) {
1869  int left = get_bits_left(&s->gb);
1870  int is_d10 = s->chroma_format == 2 &&
1871  s->pict_type == AV_PICTURE_TYPE_I &&
1872  avctx->profile == 0 && avctx->level == 5 &&
1873  s->intra_dc_precision == 2 &&
1874  s->q_scale_type == 1 && s->alternate_scan == 0 &&
1875  s->progressive_frame == 0
1876  /* vbv_delay == 0xBBB || 0xE10 */;
1877 
1878  if (left >= 32 && !is_d10) {
1879  GetBitContext gb = s->gb;
1880  align_get_bits(&gb);
1881  if (show_bits(&gb, 24) == 0x060E2B) {
1882  av_log(avctx, AV_LOG_DEBUG, "Invalid MXF data found in video stream\n");
1883  is_d10 = 1;
1884  }
1885  if (left > 32 && show_bits_long(&gb, 32) == 0x201) {
1886  av_log(avctx, AV_LOG_DEBUG, "skipping m704 alpha (unsupported)\n");
1887  goto eos;
1888  }
1889  }
1890 
1891  if (left < 0 ||
1892  (left && show_bits(&s->gb, FFMIN(left, 23)) && !is_d10) ||
1893  ((avctx->err_recognition & (AV_EF_BITSTREAM | AV_EF_AGGRESSIVE)) && left > 8)) {
1894  av_log(avctx, AV_LOG_ERROR, "end mismatch left=%d %0X at %d %d\n",
1895  left, left>0 ? show_bits(&s->gb, FFMIN(left, 23)) : 0, s->mb_x, s->mb_y);
1896  return AVERROR_INVALIDDATA;
1897  } else
1898  goto eos;
1899  }
1900  // There are some files out there which are missing the last slice
1901  // in cases where the slice is completely outside the visible
1902  // area, we detect this here instead of running into the end expecting
1903  // more data
1904  left = get_bits_left(&s->gb);
1905  if (s->mb_y >= ((s->height + 15) >> 4) &&
1906  !s->progressive_sequence &&
1907  left <= 25 &&
1908  left >= 0 &&
1909  s->mb_skip_run == -1 &&
1910  (!left || show_bits(&s->gb, left) == 0))
1911  goto eos;
1912 
1914  }
1915 
1916  /* skip mb handling */
1917  if (s->mb_skip_run == -1) {
1918  /* read increment again */
1919  s->mb_skip_run = 0;
1920  for (;;) {
1921  int code = get_vlc2(&s->gb, ff_mbincr_vlc.table,
1922  MBINCR_VLC_BITS, 2);
1923  if (code < 0) {
1924  av_log(s->avctx, AV_LOG_ERROR, "mb incr damaged\n");
1925  return AVERROR_INVALIDDATA;
1926  }
1927  if (code >= 33) {
1928  if (code == 33) {
1929  s->mb_skip_run += 33;
1930  } else if (code == 35) {
1931  if (s->mb_skip_run != 0 || show_bits(&s->gb, 15) != 0) {
1932  av_log(s->avctx, AV_LOG_ERROR, "slice mismatch\n");
1933  return AVERROR_INVALIDDATA;
1934  }
1935  goto eos; /* end of slice */
1936  }
1937  /* otherwise, stuffing, nothing to do */
1938  } else {
1939  s->mb_skip_run += code;
1940  break;
1941  }
1942  }
1943  if (s->mb_skip_run) {
1944  int i;
1945  if (s->pict_type == AV_PICTURE_TYPE_I) {
1946  av_log(s->avctx, AV_LOG_ERROR,
1947  "skipped MB in I-frame at %d %d\n", s->mb_x, s->mb_y);
1948  return AVERROR_INVALIDDATA;
1949  }
1950 
1951  /* skip mb */
1952  s->mb_intra = 0;
1953  for (i = 0; i < 12; i++)
1954  s->block_last_index[i] = -1;
1955  if (s->picture_structure == PICT_FRAME)
1956  s->mv_type = MV_TYPE_16X16;
1957  else
1958  s->mv_type = MV_TYPE_FIELD;
1959  if (s->pict_type == AV_PICTURE_TYPE_P) {
1960  /* if P type, zero motion vector is implied */
1961  s->mv_dir = MV_DIR_FORWARD;
1962  s->mv[0][0][0] = s->mv[0][0][1] = 0;
1963  s->last_mv[0][0][0] = s->last_mv[0][0][1] = 0;
1964  s->last_mv[0][1][0] = s->last_mv[0][1][1] = 0;
1965  s->field_select[0][0] = (s->picture_structure - 1) & 1;
1966  } else {
1967  /* if B type, reuse previous vectors and directions */
1968  s->mv[0][0][0] = s->last_mv[0][0][0];
1969  s->mv[0][0][1] = s->last_mv[0][0][1];
1970  s->mv[1][0][0] = s->last_mv[1][0][0];
1971  s->mv[1][0][1] = s->last_mv[1][0][1];
1972  s->field_select[0][0] = (s->picture_structure - 1) & 1;
1973  s->field_select[1][0] = (s->picture_structure - 1) & 1;
1974  }
1975  }
1976  }
1977  }
1978 eos: // end of slice
1979  if (get_bits_left(&s->gb) < 0) {
1980  av_log(s, AV_LOG_ERROR, "overread %d\n", -get_bits_left(&s->gb));
1981  return AVERROR_INVALIDDATA;
1982  }
1983  *buf += (get_bits_count(&s->gb) - 1) / 8;
1984  ff_dlog(s, "Slice start:%d %d end:%d %d\n", s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y);
1985  return 0;
1986 }
1987 
1989 {
1990  MpegEncContext *s = *(void **) arg;
1991  const uint8_t *buf = s->gb.buffer;
1992  int mb_y = s->start_mb_y;
1993  const int field_pic = s->picture_structure != PICT_FRAME;
1994 
1995  s->er.error_count = (3 * (s->end_mb_y - s->start_mb_y) * s->mb_width) >> field_pic;
1996 
1997  for (;;) {
1998  uint32_t start_code;
1999  int ret;
2000 
2001  ret = mpeg_decode_slice(s, mb_y, &buf, s->gb.buffer_end - buf);
2002  emms_c();
2003  ff_dlog(c, "ret:%d resync:%d/%d mb:%d/%d ts:%d/%d ec:%d\n",
2004  ret, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y,
2005  s->start_mb_y, s->end_mb_y, s->er.error_count);
2006  if (ret < 0) {
2007  if (c->err_recognition & AV_EF_EXPLODE)
2008  return ret;
2009  if (s->resync_mb_x >= 0 && s->resync_mb_y >= 0)
2010  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2011  s->mb_x, s->mb_y,
2013  } else {
2014  ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y,
2015  s->mb_x - 1, s->mb_y,
2017  }
2018 
2019  if (s->mb_y == s->end_mb_y)
2020  return 0;
2021 
2022  start_code = -1;
2023  buf = avpriv_find_start_code(buf, s->gb.buffer_end, &start_code);
2024  if (start_code < SLICE_MIN_START_CODE || start_code > SLICE_MAX_START_CODE)
2025  return AVERROR_INVALIDDATA;
2027  if (s->codec_id != AV_CODEC_ID_MPEG1VIDEO && s->mb_height > 2800/16)
2028  mb_y += (*buf&0xE0)<<2;
2029  mb_y <<= field_pic;
2030  if (s->picture_structure == PICT_BOTTOM_FIELD)
2031  mb_y++;
2032  if (mb_y >= s->end_mb_y)
2033  return AVERROR_INVALIDDATA;
2034  }
2035 }
2036 
2037 /**
2038  * Handle slice ends.
2039  * @return 1 if it seems to be the last slice
2040  */
2041 static int slice_end(AVCodecContext *avctx, AVFrame *pict)
2042 {
2043  Mpeg1Context *s1 = avctx->priv_data;
2044  MpegEncContext *s = &s1->mpeg_enc_ctx;
2045 
2046  if (!s1->mpeg_enc_ctx_allocated || !s->current_picture_ptr)
2047  return 0;
2048 
2049  if (s->avctx->hwaccel) {
2050  int ret = s->avctx->hwaccel->end_frame(s->avctx);
2051  if (ret < 0) {
2052  av_log(avctx, AV_LOG_ERROR,
2053  "hardware accelerator failed to decode picture\n");
2054  return ret;
2055  }
2056  }
2057 
2058  /* end of slice reached */
2059  if (/* s->mb_y << field_pic == s->mb_height && */ !s->first_field && !s1->first_slice) {
2060  /* end of image */
2061 
2062  ff_er_frame_end(&s->er);
2063 
2065 
2066  if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
2067  int ret = av_frame_ref(pict, s->current_picture_ptr->f);
2068  if (ret < 0)
2069  return ret;
2070  ff_print_debug_info(s, s->current_picture_ptr, pict);
2071  ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2072  } else {
2073  if (avctx->active_thread_type & FF_THREAD_FRAME)
2074  s->picture_number++;
2075  /* latency of 1 frame for I- and P-frames */
2076  /* XXX: use another variable than picture_number */
2077  if (s->last_picture_ptr) {
2078  int ret = av_frame_ref(pict, s->last_picture_ptr->f);
2079  if (ret < 0)
2080  return ret;
2081  ff_print_debug_info(s, s->last_picture_ptr, pict);
2082  ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG2);
2083  }
2084  }
2085 
2086  return 1;
2087  } else {
2088  return 0;
2089  }
2090 }
2091 
2093  const uint8_t *buf, int buf_size)
2094 {
2095  Mpeg1Context *s1 = avctx->priv_data;
2096  MpegEncContext *s = &s1->mpeg_enc_ctx;
2097  int width, height;
2098  int i, v, j;
2099 
2100  init_get_bits(&s->gb, buf, buf_size * 8);
2101 
2102  width = get_bits(&s->gb, 12);
2103  height = get_bits(&s->gb, 12);
2104  if (width == 0 || height == 0) {
2105  av_log(avctx, AV_LOG_WARNING,
2106  "Invalid horizontal or vertical size value.\n");
2108  return AVERROR_INVALIDDATA;
2109  }
2110  s->aspect_ratio_info = get_bits(&s->gb, 4);
2111  if (s->aspect_ratio_info == 0) {
2112  av_log(avctx, AV_LOG_ERROR, "aspect ratio has forbidden 0 value\n");
2114  return AVERROR_INVALIDDATA;
2115  }
2116  s->frame_rate_index = get_bits(&s->gb, 4);
2117  if (s->frame_rate_index == 0 || s->frame_rate_index > 13) {
2118  av_log(avctx, AV_LOG_WARNING,
2119  "frame_rate_index %d is invalid\n", s->frame_rate_index);
2120  s->frame_rate_index = 1;
2121  }
2122  s->bit_rate = get_bits(&s->gb, 18) * 400LL;
2123  if (check_marker(s->avctx, &s->gb, "in sequence header") == 0) {
2124  return AVERROR_INVALIDDATA;
2125  }
2126 
2127  s1->rc_buffer_size = get_bits(&s->gb, 10) * 1024 * 16;
2128  skip_bits(&s->gb, 1);
2129 
2130  /* get matrix */
2131  if (get_bits1(&s->gb)) {
2132  load_matrix(s, s->chroma_intra_matrix, s->intra_matrix, 1);
2133  } else {
2134  for (i = 0; i < 64; i++) {
2135  j = s->idsp.idct_permutation[i];
2137  s->intra_matrix[j] = v;
2138  s->chroma_intra_matrix[j] = v;
2139  }
2140  }
2141  if (get_bits1(&s->gb)) {
2142  load_matrix(s, s->chroma_inter_matrix, s->inter_matrix, 0);
2143  } else {
2144  for (i = 0; i < 64; i++) {
2145  int j = s->idsp.idct_permutation[i];
2147  s->inter_matrix[j] = v;
2148  s->chroma_inter_matrix[j] = v;
2149  }
2150  }
2151 
2152  if (show_bits(&s->gb, 23) != 0) {
2153  av_log(s->avctx, AV_LOG_ERROR, "sequence header damaged\n");
2154  return AVERROR_INVALIDDATA;
2155  }
2156 
2157  s->width = width;
2158  s->height = height;
2159 
2160  /* We set MPEG-2 parameters so that it emulates MPEG-1. */
2161  s->progressive_sequence = 1;
2162  s->progressive_frame = 1;
2163  s->picture_structure = PICT_FRAME;
2164  s->first_field = 0;
2165  s->frame_pred_frame_dct = 1;
2166  s->chroma_format = 1;
2167  s->codec_id =
2168  s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2169  s->out_format = FMT_MPEG1;
2170  s->swap_uv = 0; // AFAIK VCR2 does not have SEQ_HEADER
2171  if (s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
2172  s->low_delay = 1;
2173 
2174  if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2175  av_log(s->avctx, AV_LOG_DEBUG, "vbv buffer: %d, bitrate:%"PRId64", aspect_ratio_info: %d \n",
2176  s1->rc_buffer_size, s->bit_rate, s->aspect_ratio_info);
2177 
2178  return 0;
2179 }
2180 
2182 {
2183  Mpeg1Context *s1 = avctx->priv_data;
2184  MpegEncContext *s = &s1->mpeg_enc_ctx;
2185  int i, v, ret;
2186 
2187  /* start new MPEG-1 context decoding */
2188  s->out_format = FMT_MPEG1;
2189  if (s1->mpeg_enc_ctx_allocated) {
2191  s1->mpeg_enc_ctx_allocated = 0;
2192  }
2193  s->width = avctx->coded_width;
2194  s->height = avctx->coded_height;
2195  avctx->has_b_frames = 0; // true?
2196  s->low_delay = 1;
2197 
2198  avctx->pix_fmt = mpeg_get_pixelformat(avctx);
2199  setup_hwaccel_for_pixfmt(avctx);
2200 
2202  if ((ret = ff_mpv_common_init(s)) < 0)
2203  return ret;
2204  s1->mpeg_enc_ctx_allocated = 1;
2205 
2206  for (i = 0; i < 64; i++) {
2207  int j = s->idsp.idct_permutation[i];
2209  s->intra_matrix[j] = v;
2210  s->chroma_intra_matrix[j] = v;
2211 
2213  s->inter_matrix[j] = v;
2214  s->chroma_inter_matrix[j] = v;
2215  }
2216 
2217  s->progressive_sequence = 1;
2218  s->progressive_frame = 1;
2219  s->picture_structure = PICT_FRAME;
2220  s->first_field = 0;
2221  s->frame_pred_frame_dct = 1;
2222  s->chroma_format = 1;
2223  if (s->codec_tag == AV_RL32("BW10")) {
2224  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG1VIDEO;
2225  } else {
2226  s->swap_uv = 1; // in case of xvmc we need to swap uv for each MB
2227  s->codec_id = s->avctx->codec_id = AV_CODEC_ID_MPEG2VIDEO;
2228  }
2229  s1->save_width = s->width;
2230  s1->save_height = s->height;
2231  s1->save_progressive_seq = s->progressive_sequence;
2232  return 0;
2233 }
2234 
2236  const uint8_t *p, int buf_size)
2237 {
2238  Mpeg1Context *s1 = avctx->priv_data;
2239 
2240  if (buf_size >= 6 &&
2241  p[0] == 'G' && p[1] == 'A' && p[2] == '9' && p[3] == '4' &&
2242  p[4] == 3 && (p[5] & 0x40)) {
2243  /* extract A53 Part 4 CC data */
2244  int cc_count = p[5] & 0x1f;
2245  if (cc_count > 0 && buf_size >= 7 + cc_count * 3) {
2246  int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
2247  const uint64_t new_size = (old_size + cc_count
2248  * UINT64_C(3));
2249  int ret;
2250 
2251  if (new_size > 3*A53_MAX_CC_COUNT)
2252  return AVERROR(EINVAL);
2253 
2254  ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
2255  if (ret >= 0)
2256  memcpy(s1->a53_buf_ref->data + old_size, p + 7, cc_count * UINT64_C(3));
2257 
2259  }
2260  return 1;
2261  } else if (buf_size >= 2 &&
2262  p[0] == 0x03 && (p[1]&0x7f) == 0x01) {
2263  /* extract SCTE-20 CC data */
2264  GetBitContext gb;
2265  int cc_count = 0;
2266  int i, ret;
2267 
2268  init_get_bits(&gb, p + 2, buf_size - 2);
2269  cc_count = get_bits(&gb, 5);
2270  if (cc_count > 0) {
2271  int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
2272  const uint64_t new_size = (old_size + cc_count
2273  * UINT64_C(3));
2274  if (new_size > 3*A53_MAX_CC_COUNT)
2275  return AVERROR(EINVAL);
2276 
2277  ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
2278  if (ret >= 0) {
2279  uint8_t field, cc1, cc2;
2280  uint8_t *cap = s1->a53_buf_ref->data;
2281 
2282  memset(s1->a53_buf_ref->data + old_size, 0, cc_count * 3);
2283  for (i = 0; i < cc_count && get_bits_left(&gb) >= 26; i++) {
2284  skip_bits(&gb, 2); // priority
2285  field = get_bits(&gb, 2);
2286  skip_bits(&gb, 5); // line_offset
2287  cc1 = get_bits(&gb, 8);
2288  cc2 = get_bits(&gb, 8);
2289  skip_bits(&gb, 1); // marker
2290 
2291  if (!field) { // forbidden
2292  cap[0] = cap[1] = cap[2] = 0x00;
2293  } else {
2294  field = (field == 2 ? 1 : 0);
2295  if (!s1->mpeg_enc_ctx.top_field_first) field = !field;
2296  cap[0] = 0x04 | field;
2297  cap[1] = ff_reverse[cc1];
2298  cap[2] = ff_reverse[cc2];
2299  }
2300  cap += 3;
2301  }
2302  }
2304  }
2305  return 1;
2306  } else if (buf_size >= 11 &&
2307  p[0] == 'C' && p[1] == 'C' && p[2] == 0x01 && p[3] == 0xf8) {
2308  /* extract DVD CC data
2309  *
2310  * uint32_t user_data_start_code 0x000001B2 (big endian)
2311  * uint16_t user_identifier 0x4343 "CC"
2312  * uint8_t user_data_type_code 0x01
2313  * uint8_t caption_block_size 0xF8
2314  * uint8_t
2315  * bit 7 caption_odd_field_first 1=odd field (CC1/CC2) first 0=even field (CC3/CC4) first
2316  * bit 6 caption_filler 0
2317  * bit 5:1 caption_block_count number of caption blocks (pairs of caption words = frames). Most DVDs use 15 per start of GOP.
2318  * bit 0 caption_extra_field_added 1=one additional caption word
2319  *
2320  * struct caption_field_block {
2321  * uint8_t
2322  * bit 7:1 caption_filler 0x7F (all 1s)
2323  * bit 0 caption_field_odd 1=odd field (this is CC1/CC2) 0=even field (this is CC3/CC4)
2324  * uint8_t caption_first_byte
2325  * uint8_t caption_second_byte
2326  * } caption_block[(caption_block_count * 2) + caption_extra_field_added];
2327  *
2328  * Some DVDs encode caption data for both fields with caption_field_odd=1. The only way to decode the fields
2329  * correctly is to start on the field indicated by caption_odd_field_first and count between odd/even fields.
2330  * Don't assume that the first caption word is the odd field. There do exist MPEG files in the wild that start
2331  * on the even field. There also exist DVDs in the wild that encode an odd field count and the
2332  * caption_extra_field_added/caption_odd_field_first bits change per packet to allow that. */
2333  int cc_count = 0;
2334  int i, ret;
2335  // There is a caption count field in the data, but it is often
2336  // incorrect. So count the number of captions present.
2337  for (i = 5; i + 6 <= buf_size && ((p[i] & 0xfe) == 0xfe); i += 6)
2338  cc_count++;
2339  // Transform the DVD format into A53 Part 4 format
2340  if (cc_count > 0) {
2341  int old_size = s1->a53_buf_ref ? s1->a53_buf_ref->size : 0;
2342  const uint64_t new_size = (old_size + cc_count
2343  * UINT64_C(6));
2344  if (new_size > 3*A53_MAX_CC_COUNT)
2345  return AVERROR(EINVAL);
2346 
2347  ret = av_buffer_realloc(&s1->a53_buf_ref, new_size);
2348  if (ret >= 0) {
2349  uint8_t field1 = !!(p[4] & 0x80);
2350  uint8_t *cap = s1->a53_buf_ref->data;
2351  p += 5;
2352  for (i = 0; i < cc_count; i++) {
2353  cap[0] = (p[0] == 0xff && field1) ? 0xfc : 0xfd;
2354  cap[1] = p[1];
2355  cap[2] = p[2];
2356  cap[3] = (p[3] == 0xff && !field1) ? 0xfc : 0xfd;
2357  cap[4] = p[4];
2358  cap[5] = p[5];
2359  cap += 6;
2360  p += 6;
2361  }
2362  }
2364  }
2365  return 1;
2366  }
2367  return 0;
2368 }
2369 
2371  const uint8_t *p, int buf_size)
2372 {
2373  Mpeg1Context *s = avctx->priv_data;
2374  const uint8_t *buf_end = p + buf_size;
2375  Mpeg1Context *s1 = avctx->priv_data;
2376 
2377 #if 0
2378  int i;
2379  for(i=0; !(!p[i-2] && !p[i-1] && p[i]==1) && i<buf_size; i++){
2380  av_log(avctx, AV_LOG_ERROR, "%c", p[i]);
2381  }
2382  av_log(avctx, AV_LOG_ERROR, "\n");
2383 #endif
2384 
2385  if (buf_size > 29){
2386  int i;
2387  for(i=0; i<20; i++)
2388  if (!memcmp(p+i, "\0TMPGEXS\0", 9)){
2389  s->tmpgexs= 1;
2390  }
2391  }
2392  /* we parse the DTG active format information */
2393  if (buf_end - p >= 5 &&
2394  p[0] == 'D' && p[1] == 'T' && p[2] == 'G' && p[3] == '1') {
2395  int flags = p[4];
2396  p += 5;
2397  if (flags & 0x80) {
2398  /* skip event id */
2399  p += 2;
2400  }
2401  if (flags & 0x40) {
2402  if (buf_end - p < 1)
2403  return;
2404  s1->has_afd = 1;
2405  s1->afd = p[0] & 0x0f;
2406  }
2407  } else if (buf_end - p >= 6 &&
2408  p[0] == 'J' && p[1] == 'P' && p[2] == '3' && p[3] == 'D' &&
2409  p[4] == 0x03) { // S3D_video_format_length
2410  // the 0x7F mask ignores the reserved_bit value
2411  const uint8_t S3D_video_format_type = p[5] & 0x7F;
2412 
2413  if (S3D_video_format_type == 0x03 ||
2414  S3D_video_format_type == 0x04 ||
2415  S3D_video_format_type == 0x08 ||
2416  S3D_video_format_type == 0x23) {
2417 
2418  s1->has_stereo3d = 1;
2419 
2420  switch (S3D_video_format_type) {
2421  case 0x03:
2422  s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE;
2423  break;
2424  case 0x04:
2425  s1->stereo3d.type = AV_STEREO3D_TOPBOTTOM;
2426  break;
2427  case 0x08:
2428  s1->stereo3d.type = AV_STEREO3D_2D;
2429  break;
2430  case 0x23:
2431  s1->stereo3d.type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
2432  break;
2433  }
2434  }
2435  } else if (mpeg_decode_a53_cc(avctx, p, buf_size)) {
2436  return;
2437  }
2438 }
2439 
2440 static void mpeg_decode_gop(AVCodecContext *avctx,
2441  const uint8_t *buf, int buf_size)
2442 {
2443  Mpeg1Context *s1 = avctx->priv_data;
2444  MpegEncContext *s = &s1->mpeg_enc_ctx;
2445  int broken_link;
2446  int64_t tc;
2447 
2448  init_get_bits(&s->gb, buf, buf_size * 8);
2449 
2450  tc = s-> timecode_frame_start = get_bits(&s->gb, 25);
2451 
2452  s->closed_gop = get_bits1(&s->gb);
2453  /* broken_link indicates that after editing the
2454  * reference frames of the first B-Frames after GOP I-Frame
2455  * are missing (open gop) */
2456  broken_link = get_bits1(&s->gb);
2457 
2458  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
2459  char tcbuf[AV_TIMECODE_STR_SIZE];
2461  av_log(s->avctx, AV_LOG_DEBUG,
2462  "GOP (%s) closed_gop=%d broken_link=%d\n",
2463  tcbuf, s->closed_gop, broken_link);
2464  }
2465 }
2466 
2467 static int decode_chunks(AVCodecContext *avctx, AVFrame *picture,
2468  int *got_output, const uint8_t *buf, int buf_size)
2469 {
2470  Mpeg1Context *s = avctx->priv_data;
2471  MpegEncContext *s2 = &s->mpeg_enc_ctx;
2472  const uint8_t *buf_ptr = buf;
2473  const uint8_t *buf_end = buf + buf_size;
2474  int ret, input_size;
2475  int last_code = 0, skip_frame = 0;
2476  int picture_start_code_seen = 0;
2477 
2478  for (;;) {
2479  /* find next start code */
2480  uint32_t start_code = -1;
2481  buf_ptr = avpriv_find_start_code(buf_ptr, buf_end, &start_code);
2482  if (start_code > 0x1ff) {
2483  if (!skip_frame) {
2484  if (HAVE_THREADS &&
2485  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2486  !avctx->hwaccel) {
2487  int i;
2488  av_assert0(avctx->thread_count > 1);
2489 
2490  avctx->execute(avctx, slice_decode_thread,
2491  &s2->thread_context[0], NULL,
2492  s->slice_count, sizeof(void *));
2493  for (i = 0; i < s->slice_count; i++)
2494  s2->er.error_count += s2->thread_context[i]->er.error_count;
2495  }
2496 
2497  ret = slice_end(avctx, picture);
2498  if (ret < 0)
2499  return ret;
2500  else if (ret) {
2501  // FIXME: merge with the stuff in mpeg_decode_slice
2502  if (s2->last_picture_ptr || s2->low_delay || s2->pict_type == AV_PICTURE_TYPE_B)
2503  *got_output = 1;
2504  }
2505  }
2506  s2->pict_type = 0;
2507 
2508  if (avctx->err_recognition & AV_EF_EXPLODE && s2->er.error_count)
2509  return AVERROR_INVALIDDATA;
2510 
2511 #if FF_API_FLAG_TRUNCATED
2512  return FFMAX(0, buf_ptr - buf - s2->parse_context.last_index);
2513 #else
2514  return FFMAX(0, buf_ptr - buf);
2515 #endif
2516  }
2517 
2518  input_size = buf_end - buf_ptr;
2519 
2520  if (avctx->debug & FF_DEBUG_STARTCODE)
2521  av_log(avctx, AV_LOG_DEBUG, "%3"PRIX32" at %"PTRDIFF_SPECIFIER" left %d\n",
2522  start_code, buf_ptr - buf, input_size);
2523 
2524  /* prepare data for next start code */
2525  switch (start_code) {
2526  case SEQ_START_CODE:
2527  if (last_code == 0) {
2528  mpeg1_decode_sequence(avctx, buf_ptr, input_size);
2529  if (buf != avctx->extradata)
2530  s->sync = 1;
2531  } else {
2532  av_log(avctx, AV_LOG_ERROR,
2533  "ignoring SEQ_START_CODE after %X\n", last_code);
2534  if (avctx->err_recognition & AV_EF_EXPLODE)
2535  return AVERROR_INVALIDDATA;
2536  }
2537  break;
2538 
2539  case PICTURE_START_CODE:
2540  if (picture_start_code_seen && s2->picture_structure == PICT_FRAME) {
2541  /* If it's a frame picture, there can't be more than one picture header.
2542  Yet, it does happen and we need to handle it. */
2543  av_log(avctx, AV_LOG_WARNING, "ignoring extra picture following a frame-picture\n");
2544  break;
2545  }
2546  picture_start_code_seen = 1;
2547 
2548  if (s2->width <= 0 || s2->height <= 0) {
2549  av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d.\n",
2550  s2->width, s2->height);
2551  return AVERROR_INVALIDDATA;
2552  }
2553 
2554  if (s->tmpgexs){
2555  s2->intra_dc_precision= 3;
2556  s2->intra_matrix[0]= 1;
2557  }
2558  if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_SLICE) &&
2559  !avctx->hwaccel && s->slice_count) {
2560  int i;
2561 
2562  avctx->execute(avctx, slice_decode_thread,
2563  s2->thread_context, NULL,
2564  s->slice_count, sizeof(void *));
2565  for (i = 0; i < s->slice_count; i++)
2566  s2->er.error_count += s2->thread_context[i]->er.error_count;
2567  s->slice_count = 0;
2568  }
2569  if (last_code == 0 || last_code == SLICE_MIN_START_CODE) {
2570  ret = mpeg_decode_postinit(avctx);
2571  if (ret < 0) {
2572  av_log(avctx, AV_LOG_ERROR,
2573  "mpeg_decode_postinit() failure\n");
2574  return ret;
2575  }
2576 
2577  /* We have a complete image: we try to decompress it. */
2578  if (mpeg1_decode_picture(avctx, buf_ptr, input_size) < 0)
2579  s2->pict_type = 0;
2580  s->first_slice = 1;
2581  last_code = PICTURE_START_CODE;
2582  } else {
2583  av_log(avctx, AV_LOG_ERROR,
2584  "ignoring pic after %X\n", last_code);
2585  if (avctx->err_recognition & AV_EF_EXPLODE)
2586  return AVERROR_INVALIDDATA;
2587  }
2588  break;
2589  case EXT_START_CODE:
2590  init_get_bits(&s2->gb, buf_ptr, input_size * 8);
2591 
2592  switch (get_bits(&s2->gb, 4)) {
2593  case 0x1:
2594  if (last_code == 0) {
2596  } else {
2597  av_log(avctx, AV_LOG_ERROR,
2598  "ignoring seq ext after %X\n", last_code);
2599  if (avctx->err_recognition & AV_EF_EXPLODE)
2600  return AVERROR_INVALIDDATA;
2601  }
2602  break;
2603  case 0x2:
2605  break;
2606  case 0x3:
2608  break;
2609  case 0x7:
2611  break;
2612  case 0x8:
2613  if (last_code == PICTURE_START_CODE) {
2615  if (ret < 0)
2616  return ret;
2617  } else {
2618  av_log(avctx, AV_LOG_ERROR,
2619  "ignoring pic cod ext after %X\n", last_code);
2620  if (avctx->err_recognition & AV_EF_EXPLODE)
2621  return AVERROR_INVALIDDATA;
2622  }
2623  break;
2624  }
2625  break;
2626  case USER_START_CODE:
2627  mpeg_decode_user_data(avctx, buf_ptr, input_size);
2628  break;
2629  case GOP_START_CODE:
2630  if (last_code == 0) {
2631  s2->first_field = 0;
2632  mpeg_decode_gop(avctx, buf_ptr, input_size);
2633  s->sync = 1;
2634  } else {
2635  av_log(avctx, AV_LOG_ERROR,
2636  "ignoring GOP_START_CODE after %X\n", last_code);
2637  if (avctx->err_recognition & AV_EF_EXPLODE)
2638  return AVERROR_INVALIDDATA;
2639  }
2640  break;
2641  default:
2643  start_code <= SLICE_MAX_START_CODE && last_code == PICTURE_START_CODE) {
2644  if (s2->progressive_sequence && !s2->progressive_frame) {
2645  s2->progressive_frame = 1;
2646  av_log(s2->avctx, AV_LOG_ERROR,
2647  "interlaced frame in progressive sequence, ignoring\n");
2648  }
2649 
2650  if (s2->picture_structure == 0 ||
2651  (s2->progressive_frame && s2->picture_structure != PICT_FRAME)) {
2652  av_log(s2->avctx, AV_LOG_ERROR,
2653  "picture_structure %d invalid, ignoring\n",
2654  s2->picture_structure);
2655  s2->picture_structure = PICT_FRAME;
2656  }
2657 
2658  if (s2->progressive_sequence && !s2->frame_pred_frame_dct)
2659  av_log(s2->avctx, AV_LOG_WARNING, "invalid frame_pred_frame_dct\n");
2660 
2661  if (s2->picture_structure == PICT_FRAME) {
2662  s2->first_field = 0;
2663  s2->v_edge_pos = 16 * s2->mb_height;
2664  } else {
2665  s2->first_field ^= 1;
2666  s2->v_edge_pos = 8 * s2->mb_height;
2667  memset(s2->mbskip_table, 0, s2->mb_stride * s2->mb_height);
2668  }
2669  }
2671  start_code <= SLICE_MAX_START_CODE && last_code != 0) {
2672  const int field_pic = s2->picture_structure != PICT_FRAME;
2673  int mb_y = start_code - SLICE_MIN_START_CODE;
2674  last_code = SLICE_MIN_START_CODE;
2675  if (s2->codec_id != AV_CODEC_ID_MPEG1VIDEO && s2->mb_height > 2800/16)
2676  mb_y += (*buf_ptr&0xE0)<<2;
2677 
2678  mb_y <<= field_pic;
2679  if (s2->picture_structure == PICT_BOTTOM_FIELD)
2680  mb_y++;
2681 
2682  if (buf_end - buf_ptr < 2) {
2683  av_log(s2->avctx, AV_LOG_ERROR, "slice too small\n");
2684  return AVERROR_INVALIDDATA;
2685  }
2686 
2687  if (mb_y >= s2->mb_height) {
2688  av_log(s2->avctx, AV_LOG_ERROR,
2689  "slice below image (%d >= %d)\n", mb_y, s2->mb_height);
2690  return AVERROR_INVALIDDATA;
2691  }
2692 
2693  if (!s2->last_picture_ptr) {
2694  /* Skip B-frames if we do not have reference frames and
2695  * GOP is not closed. */
2696  if (s2->pict_type == AV_PICTURE_TYPE_B) {
2697  if (!s2->closed_gop) {
2698  skip_frame = 1;
2699  av_log(s2->avctx, AV_LOG_DEBUG,
2700  "Skipping B slice due to open GOP\n");
2701  break;
2702  }
2703  }
2704  }
2705  if (s2->pict_type == AV_PICTURE_TYPE_I || (s2->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL))
2706  s->sync = 1;
2707  if (!s2->next_picture_ptr) {
2708  /* Skip P-frames if we do not have a reference frame or
2709  * we have an invalid header. */
2710  if (s2->pict_type == AV_PICTURE_TYPE_P && !s->sync) {
2711  skip_frame = 1;
2712  av_log(s2->avctx, AV_LOG_DEBUG,
2713  "Skipping P slice due to !sync\n");
2714  break;
2715  }
2716  }
2717  if ((avctx->skip_frame >= AVDISCARD_NONREF &&
2718  s2->pict_type == AV_PICTURE_TYPE_B) ||
2719  (avctx->skip_frame >= AVDISCARD_NONKEY &&
2720  s2->pict_type != AV_PICTURE_TYPE_I) ||
2721  avctx->skip_frame >= AVDISCARD_ALL) {
2722  skip_frame = 1;
2723  break;
2724  }
2725 
2726  if (!s->mpeg_enc_ctx_allocated)
2727  break;
2728 
2729  if (s2->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
2730  if (mb_y < avctx->skip_top ||
2731  mb_y >= s2->mb_height - avctx->skip_bottom)
2732  break;
2733  }
2734 
2735  if (!s2->pict_type) {
2736  av_log(avctx, AV_LOG_ERROR, "Missing picture start code\n");
2737  if (avctx->err_recognition & AV_EF_EXPLODE)
2738  return AVERROR_INVALIDDATA;
2739  break;
2740  }
2741 
2742  if (s->first_slice) {
2743  skip_frame = 0;
2744  s->first_slice = 0;
2745  if ((ret = mpeg_field_start(s2, buf, buf_size)) < 0)
2746  return ret;
2747  }
2748  if (!s2->current_picture_ptr) {
2749  av_log(avctx, AV_LOG_ERROR,
2750  "current_picture not initialized\n");
2751  return AVERROR_INVALIDDATA;
2752  }
2753 
2754  if (HAVE_THREADS &&
2755  (avctx->active_thread_type & FF_THREAD_SLICE) &&
2756  !avctx->hwaccel) {
2757  int threshold = (s2->mb_height * s->slice_count +
2758  s2->slice_context_count / 2) /
2759  s2->slice_context_count;
2760  av_assert0(avctx->thread_count > 1);
2761  if (threshold <= mb_y) {
2762  MpegEncContext *thread_context = s2->thread_context[s->slice_count];
2763 
2764  thread_context->start_mb_y = mb_y;
2765  thread_context->end_mb_y = s2->mb_height;
2766  if (s->slice_count) {
2767  s2->thread_context[s->slice_count - 1]->end_mb_y = mb_y;
2768  ret = ff_update_duplicate_context(thread_context, s2);
2769  if (ret < 0)
2770  return ret;
2771  }
2772  init_get_bits(&thread_context->gb, buf_ptr, input_size * 8);
2773  s->slice_count++;
2774  }
2775  buf_ptr += 2; // FIXME add minimum number of bytes per slice
2776  } else {
2777  ret = mpeg_decode_slice(s2, mb_y, &buf_ptr, input_size);
2778  emms_c();
2779 
2780  if (ret < 0) {
2781  if (avctx->err_recognition & AV_EF_EXPLODE)
2782  return ret;
2783  if (s2->resync_mb_x >= 0 && s2->resync_mb_y >= 0)
2784  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2785  s2->resync_mb_y, s2->mb_x, s2->mb_y,
2787  } else {
2788  ff_er_add_slice(&s2->er, s2->resync_mb_x,
2789  s2->resync_mb_y, s2->mb_x - 1, s2->mb_y,
2791  }
2792  }
2793  }
2794  break;
2795  }
2796  }
2797 }
2798 
2799 static int mpeg_decode_frame(AVCodecContext *avctx, void *data,
2800  int *got_output, AVPacket *avpkt)
2801 {
2802  const uint8_t *buf = avpkt->data;
2803  int ret;
2804  int buf_size = avpkt->size;
2805  Mpeg1Context *s = avctx->priv_data;
2806  AVFrame *picture = data;
2807  MpegEncContext *s2 = &s->mpeg_enc_ctx;
2808 
2809  if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == SEQ_END_CODE)) {
2810  /* special case for last picture */
2811  if (s2->low_delay == 0 && s2->next_picture_ptr) {
2812  int ret = av_frame_ref(picture, s2->next_picture_ptr->f);
2813  if (ret < 0)
2814  return ret;
2815 
2816  s2->next_picture_ptr = NULL;
2817 
2818  *got_output = 1;
2819  }
2820  return buf_size;
2821  }
2822 
2823 #if FF_API_FLAG_TRUNCATED
2824  if (s2->avctx->flags & AV_CODEC_FLAG_TRUNCATED) {
2825  int next = ff_mpeg1_find_frame_end(&s2->parse_context, buf,
2826  buf_size, NULL);
2827 
2828  if (ff_combine_frame(&s2->parse_context, next,
2829  (const uint8_t **) &buf, &buf_size) < 0)
2830  return buf_size;
2831  }
2832 #endif
2833 
2834  s2->codec_tag = avpriv_toupper4(avctx->codec_tag);
2835  if (s->mpeg_enc_ctx_allocated == 0 && ( s2->codec_tag == AV_RL32("VCR2")
2836  || s2->codec_tag == AV_RL32("BW10")
2837  ))
2838  vcr2_init_sequence(avctx);
2839 
2840  s->slice_count = 0;
2841 
2842  if (avctx->extradata && !s->extradata_decoded) {
2843  ret = decode_chunks(avctx, picture, got_output,
2844  avctx->extradata, avctx->extradata_size);
2845  if (*got_output) {
2846  av_log(avctx, AV_LOG_ERROR, "picture in extradata\n");
2847  av_frame_unref(picture);
2848  *got_output = 0;
2849  }
2850  s->extradata_decoded = 1;
2851  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE)) {
2852  s2->current_picture_ptr = NULL;
2853  return ret;
2854  }
2855  }
2856 
2857  ret = decode_chunks(avctx, picture, got_output, buf, buf_size);
2858  if (ret<0 || *got_output) {
2859  s2->current_picture_ptr = NULL;
2860 
2861  if (s2->timecode_frame_start != -1 && *got_output) {
2862  char tcbuf[AV_TIMECODE_STR_SIZE];
2863  AVFrameSideData *tcside = av_frame_new_side_data(picture,
2865  sizeof(int64_t));
2866  if (!tcside)
2867  return AVERROR(ENOMEM);
2868  memcpy(tcside->data, &s2->timecode_frame_start, sizeof(int64_t));
2869 
2870  av_timecode_make_mpeg_tc_string(tcbuf, s2->timecode_frame_start);
2871  av_dict_set(&picture->metadata, "timecode", tcbuf, 0);
2872 
2873  s2->timecode_frame_start = -1;
2874  }
2875  }
2876 
2877  return ret;
2878 }
2879 
2880 static void flush(AVCodecContext *avctx)
2881 {
2882  Mpeg1Context *s = avctx->priv_data;
2883 
2884  s->sync = 0;
2885 
2886  ff_mpeg_flush(avctx);
2887 }
2888 
2890 {
2891  Mpeg1Context *s = avctx->priv_data;
2892 
2893  if (s->mpeg_enc_ctx_allocated)
2894  ff_mpv_common_end(&s->mpeg_enc_ctx);
2895  av_buffer_unref(&s->a53_buf_ref);
2896  return 0;
2897 }
2898 
2900  .name = "mpeg1video",
2901  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2902  .type = AVMEDIA_TYPE_VIDEO,
2903  .id = AV_CODEC_ID_MPEG1VIDEO,
2904  .priv_data_size = sizeof(Mpeg1Context),
2906  .close = mpeg_decode_end,
2910  AV_CODEC_CAP_TRUNCATED |
2911 #endif
2913  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
2915  .flush = flush,
2916  .max_lowres = 3,
2917  .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context),
2918  .hw_configs = (const AVCodecHWConfigInternal *const []) {
2919 #if CONFIG_MPEG1_NVDEC_HWACCEL
2920  HWACCEL_NVDEC(mpeg1),
2921 #endif
2922 #if CONFIG_MPEG1_VDPAU_HWACCEL
2923  HWACCEL_VDPAU(mpeg1),
2924 #endif
2925 #if CONFIG_MPEG1_VIDEOTOOLBOX_HWACCEL
2926  HWACCEL_VIDEOTOOLBOX(mpeg1),
2927 #endif
2928 #if CONFIG_MPEG1_XVMC_HWACCEL
2929  HWACCEL_XVMC(mpeg1),
2930 #endif
2931  NULL
2932  },
2933 };
2934 
2936  .name = "mpeg2video",
2937  .long_name = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
2938  .type = AVMEDIA_TYPE_VIDEO,
2939  .id = AV_CODEC_ID_MPEG2VIDEO,
2940  .priv_data_size = sizeof(Mpeg1Context),
2942  .close = mpeg_decode_end,
2946  AV_CODEC_CAP_TRUNCATED |
2947 #endif
2949  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
2951  .flush = flush,
2952  .max_lowres = 3,
2954  .hw_configs = (const AVCodecHWConfigInternal *const []) {
2955 #if CONFIG_MPEG2_DXVA2_HWACCEL
2956  HWACCEL_DXVA2(mpeg2),
2957 #endif
2958 #if CONFIG_MPEG2_D3D11VA_HWACCEL
2959  HWACCEL_D3D11VA(mpeg2),
2960 #endif
2961 #if CONFIG_MPEG2_D3D11VA2_HWACCEL
2962  HWACCEL_D3D11VA2(mpeg2),
2963 #endif
2964 #if CONFIG_MPEG2_NVDEC_HWACCEL
2965  HWACCEL_NVDEC(mpeg2),
2966 #endif
2967 #if CONFIG_MPEG2_VAAPI_HWACCEL
2968  HWACCEL_VAAPI(mpeg2),
2969 #endif
2970 #if CONFIG_MPEG2_VDPAU_HWACCEL
2971  HWACCEL_VDPAU(mpeg2),
2972 #endif
2973 #if CONFIG_MPEG2_VIDEOTOOLBOX_HWACCEL
2974  HWACCEL_VIDEOTOOLBOX(mpeg2),
2975 #endif
2976 #if CONFIG_MPEG2_XVMC_HWACCEL
2977  HWACCEL_XVMC(mpeg2),
2978 #endif
2979  NULL
2980  },
2981 };
2982 
2983 //legacy decoder
2985  .name = "mpegvideo",
2986  .long_name = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
2987  .type = AVMEDIA_TYPE_VIDEO,
2988  .id = AV_CODEC_ID_MPEG2VIDEO,
2989  .priv_data_size = sizeof(Mpeg1Context),
2991  .close = mpeg_decode_end,
2995  AV_CODEC_CAP_TRUNCATED |
2996 #endif
2998  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
3000  .flush = flush,
3001  .max_lowres = 3,
3002 };
3003 
3004 typedef struct IPUContext {
3006 
3007  int flags;
3008  DECLARE_ALIGNED(32, int16_t, block)[6][64];
3009 } IPUContext;
3010 
3011 static int ipu_decode_frame(AVCodecContext *avctx, void *data,
3012  int *got_frame, AVPacket *avpkt)
3013 {
3014  IPUContext *s = avctx->priv_data;
3015  MpegEncContext *m = &s->m;
3016  GetBitContext *gb = &m->gb;
3017  AVFrame * const frame = data;
3018  int ret;
3019 
3020  ret = ff_get_buffer(avctx, frame, 0);
3021  if (ret < 0)
3022  return ret;
3023 
3024  ret = init_get_bits8(gb, avpkt->data, avpkt->size);
3025  if (ret < 0)
3026  return ret;
3027 
3028  s->flags = get_bits(gb, 8);
3029  m->intra_dc_precision = s->flags & 3;
3030  m->q_scale_type = !!(s->flags & 0x40);
3031  m->intra_vlc_format = !!(s->flags & 0x20);
3032  m->alternate_scan = !!(s->flags & 0x10);
3033 
3034  if (s->flags & 0x10) {
3037  } else {
3040  }
3041 
3042  m->last_dc[0] = m->last_dc[1] = m->last_dc[2] = 1 << (7 + (s->flags & 3));
3043  m->qscale = 1;
3044 
3045  for (int y = 0; y < avctx->height; y += 16) {
3046  int intraquant;
3047 
3048  for (int x = 0; x < avctx->width; x += 16) {
3049  if (x || y) {
3050  if (!get_bits1(gb))
3051  return AVERROR_INVALIDDATA;
3052  }
3053  if (get_bits1(gb)) {
3054  intraquant = 0;
3055  } else {
3056  if (!get_bits1(gb))
3057  return AVERROR_INVALIDDATA;
3058  intraquant = 1;
3059  }
3060 
3061  if (s->flags & 4)
3062  skip_bits1(gb);
3063 
3064  if (intraquant)
3065  m->qscale = mpeg_get_qscale(m);
3066 
3067  memset(s->block, 0, sizeof(s->block));
3068 
3069  for (int n = 0; n < 6; n++) {
3070  if (s->flags & 0x80) {
3072  m->intra_matrix,
3074  m->last_dc, s->block[n],
3075  n, m->qscale);
3076  if (ret >= 0)
3077  m->block_last_index[n] = ret;
3078  } else {
3079  ret = mpeg2_decode_block_intra(m, s->block[n], n);
3080  }
3081 
3082  if (ret < 0)
3083  return ret;
3084  }
3085 
3086  m->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
3087  frame->linesize[0], s->block[0]);
3088  m->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
3089  frame->linesize[0], s->block[1]);
3090  m->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
3091  frame->linesize[0], s->block[2]);
3092  m->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
3093  frame->linesize[0], s->block[3]);
3094  m->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
3095  frame->linesize[1], s->block[4]);
3096  m->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
3097  frame->linesize[2], s->block[5]);
3098  }
3099  }
3100 
3101  align_get_bits(gb);
3102  if (get_bits_left(gb) != 32)
3103  return AVERROR_INVALIDDATA;
3104 
3105  frame->pict_type = AV_PICTURE_TYPE_I;
3106  frame->key_frame = 1;
3107  *got_frame = 1;
3108 
3109  return avpkt->size;
3110 }
3111 
3113 {
3114  IPUContext *s = avctx->priv_data;
3115  MpegEncContext *m = &s->m;
3116 
3117  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
3118 
3119  ff_mpv_decode_init(m, avctx);
3120  ff_mpv_idct_init(m);
3123 
3124  for (int i = 0; i < 64; i++) {
3125  int j = m->idsp.idct_permutation[i];
3127  m->intra_matrix[j] = v;
3128  m->chroma_intra_matrix[j] = v;
3129  }
3130 
3131  for (int i = 0; i < 64; i++) {
3132  int j = m->idsp.idct_permutation[i];
3134  m->inter_matrix[j] = v;
3135  m->chroma_inter_matrix[j] = v;
3136  }
3137 
3138  return 0;
3139 }
3140 
3142 {
3143  IPUContext *s = avctx->priv_data;
3144 
3145  ff_mpv_common_end(&s->m);
3146 
3147  return 0;
3148 }
3149 
3151  .name = "ipu",
3152  .long_name = NULL_IF_CONFIG_SMALL("IPU Video"),
3153  .type = AVMEDIA_TYPE_VIDEO,
3154  .id = AV_CODEC_ID_IPU,
3155  .priv_data_size = sizeof(IPUContext),
3156  .init = ipu_decode_init,
3158  .close = ipu_decode_end,
3159  .capabilities = AV_CODEC_CAP_DR1,
3161 };
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:38
vcr2_init_sequence
static int vcr2_init_sequence(AVCodecContext *avctx)
Definition: mpeg12dec.c:2181
ipu_decode_frame
static int ipu_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mpeg12dec.c:3011
ff_mpv_common_init
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
Definition: mpegvideo.c:913
hwconfig.h
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1359
AVCodec
AVCodec.
Definition: codec.h:202
ff_rl_mpeg2
RLTable ff_rl_mpeg2
Definition: mpeg12data.c:174
MB_TYPE_L0
#define MB_TYPE_L0
Definition: mpegutils.h:66
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:256
Mpeg1Context::has_afd
int has_afd
Definition: mpeg12dec.c:65
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:225
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
Mpeg1Context::a53_buf_ref
AVBufferRef * a53_buf_ref
Definition: mpeg12dec.c:63
ff_mpeg2_aspect
const AVRational ff_mpeg2_aspect[16]
Definition: mpeg12data.c:395
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:603
mpeg_decode_a53_cc
static int mpeg_decode_a53_cc(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition: mpeg12dec.c:2235
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
FMT_MPEG1
@ FMT_MPEG1
Definition: mpegutils.h:123
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AV_STEREO3D_SIDEBYSIDE_QUINCUNX
@ AV_STEREO3D_SIDEBYSIDE_QUINCUNX
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:117
mem_internal.h
MpegEncContext::gb
GetBitContext gb
Definition: mpegvideo.h:442
mpeg_decode_frame
static int mpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_output, AVPacket *avpkt)
Definition: mpeg12dec.c:2799
SEQ_END_CODE
#define SEQ_END_CODE
Definition: mpeg12.h:29
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:605
check_scantable_index
#define check_scantable_index(ctx, x)
Definition: mpeg12dec.c:131
AV_FRAME_DATA_A53_CC
@ AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
MT_FIELD
#define MT_FIELD
Definition: mpeg12dec.c:647
EXT_START_CODE
#define EXT_START_CODE
Definition: cavs.h:35
MV_TYPE_16X8
#define MV_TYPE_16X8
2 vectors, one per 16x8 block
Definition: mpegvideo.h:258
ff_mbincr_vlc
VLC ff_mbincr_vlc
Definition: mpeg12.c:131
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
mpeg_get_qscale
static int mpeg_get_qscale(MpegEncContext *s)
Definition: mpegvideo.h:766
AVPanScan
Pan Scan area.
Definition: defs.h:75
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1324
SLICE_MAX_START_CODE
#define SLICE_MAX_START_CODE
Definition: cavs.h:34
MB_TYPE_16x8
#define MB_TYPE_16x8
Definition: mpegutils.h:54
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
ipu_decode_init
static av_cold int ipu_decode_init(AVCodecContext *avctx)
Definition: mpeg12dec.c:3112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
start_code
static const uint8_t start_code[]
Definition: videotoolboxenc.c:191
ff_mpeg12_common_init
av_cold void ff_mpeg12_common_init(MpegEncContext *s)
Definition: mpeg12.c:106
avpriv_toupper4
unsigned int avpriv_toupper4(unsigned int x)
Definition: utils.c:870
w
uint8_t w
Definition: llviddspenc.c:38
HWACCEL_DXVA2
#define HWACCEL_DXVA2(codec)
Definition: hwconfig.h:67
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
ipu_decode_end
static av_cold int ipu_decode_end(AVCodecContext *avctx)
Definition: mpeg12dec.c:3141
mpeg_decode_mb
static int mpeg_decode_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpeg12dec.c:652
mpeg2_decode_block_intra
static int mpeg2_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:476
HWACCEL_D3D11VA2
#define HWACCEL_D3D11VA2(codec)
Definition: hwconfig.h:69
ff_reverse
const uint8_t ff_reverse[256]
Definition: reverse.c:23
MpegEncContext::last_dc
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:175
data
const char data[16]
Definition: mxf.c:143
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:53
HWACCEL_XVMC
#define HWACCEL_XVMC(codec)
Definition: hwconfig.h:81
AV_PIX_FMT_D3D11VA_VLD
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:219
mpeg2_fast_decode_block_intra
static int mpeg2_fast_decode_block_intra(MpegEncContext *s, int16_t *block, int n)
Changing this would eat up any speed benefits it has.
Definition: mpeg12dec.c:562
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:798
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:37
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition: error_resilience.c:829
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2271
mpegvideo.h
AV_EF_COMPLIANT
#define AV_EF_COMPLIANT
consider all spec non compliances as errors
Definition: avcodec.h:1339
MB_TYPE_L1
#define MB_TYPE_L1
Definition: mpegutils.h:67
avpriv_find_start_code
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:179
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
Mpeg1Context::first_slice
int first_slice
Definition: mpeg12dec.c:73
ER_DC_END
#define ER_DC_END
Definition: error_resilience.h:35
mpeg_decode_postinit
static int mpeg_decode_postinit(AVCodecContext *avctx)
Definition: mpeg12dec.c:1201
ff_add_cpb_side_data
AVCPBProperties * ff_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: utils.c:1002
mpegutils.h
FF_IDCT_AUTO
#define FF_IDCT_AUTO
Definition: avcodec.h:1398
ER_MV_ERROR
#define ER_MV_ERROR
Definition: error_resilience.h:33
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
thread.h
ff_mb_pat_vlc
VLC ff_mb_pat_vlc
Definition: mpeg12.c:134
SEQ_START_CODE
#define SEQ_START_CODE
Definition: mpeg12.h:30
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1303
MV_TYPE_DMV
#define MV_TYPE_DMV
2 vectors, special mpeg2 Dual Prime Vectors
Definition: mpegvideo.h:260
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:216
FF_IDCT_NONE
#define FF_IDCT_NONE
Definition: avcodec.h:1410
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
Mpeg1Context::save_aspect
AVRational save_aspect
Definition: mpeg12dec.c:67
MpegEncContext::intra_scantable
ScanTable intra_scantable
Definition: mpegvideo.h:81
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1710
AV_STEREO3D_SIDEBYSIDE
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:67
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
MB_TYPE_ZERO_MV
#define MB_TYPE_ZERO_MV
Definition: mpeg12dec.c:77
MT_DMV
#define MT_DMV
Definition: mpeg12dec.c:650
ParseContext
Definition: parser.h:28
decode_chunks
static int decode_chunks(AVCodecContext *avctx, AVFrame *picture, int *got_output, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2467
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1673
ff_mpeg1_decode_block_intra
int ff_mpeg1_decode_block_intra(GetBitContext *gb, const uint16_t *quant_matrix, uint8_t *const scantable, int last_dc[3], int16_t *block, int index, int qscale)
Definition: mpeg12.c:239
mpeg_decode_quant_matrix_extension
static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
Definition: mpeg12dec.c:1522
ff_xvmc_init_block
void ff_xvmc_init_block(MpegEncContext *s)
Initialize the block field of the MpegEncContext pointer passed as parameter after making sure that t...
Definition: mpegvideo_xvmc.c:43
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1440
AV_STEREO3D_2D
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:55
wrap
#define wrap(func)
Definition: neontest.h:65
RLTable
RLTable.
Definition: rl.h:39
GetBitContext
Definition: get_bits.h:62
USES_LIST
#define USES_LIST(a, list)
Definition: mpegutils.h:98
ff_mpeg_draw_horiz_band
void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
Definition: mpegvideo.c:2264
slice_decode_thread
static int slice_decode_thread(AVCodecContext *c, void *arg)
Definition: mpeg12dec.c:1988
ff_xvmc_pack_pblocks
void ff_xvmc_pack_pblocks(MpegEncContext *s, int cbp)
Fill individual block pointers, so there are no gaps in the data_block array in case not all blocks i...
Definition: mpegvideo_xvmc.c:64
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
IDCTDSPContext::idct_put
void(* idct_put)(uint8_t *dest, ptrdiff_t line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:72
MB_TYPE_CBP
#define MB_TYPE_CBP
Definition: mpegutils.h:70
val
static double val(void *priv, double ch)
Definition: aeval.c:76
Mpeg1Context::tmpgexs
int tmpgexs
Definition: mpeg12dec.c:72
HWACCEL_VDPAU
#define HWACCEL_VDPAU(codec)
Definition: hwconfig.h:75
AV_CODEC_FLAG_LOW_DELAY
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:264
mpeg12_pixfmt_list_444
static enum AVPixelFormat mpeg12_pixfmt_list_444[]
Definition: mpeg12dec.c:1158
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:571
mpeg1_decode_sequence
static int mpeg1_decode_sequence(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2092
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
HAS_CBP
#define HAS_CBP(a)
Definition: mpegutils.h:100
AVRational::num
int num
Numerator.
Definition: rational.h:59
GOP_START_CODE
#define GOP_START_CODE
Definition: mpeg12.h:31
HWACCEL_VIDEOTOOLBOX
@ HWACCEL_VIDEOTOOLBOX
Definition: ffmpeg.h:63
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: internal.h:62
AV_EF_BITSTREAM
#define AV_EF_BITSTREAM
detect bitstream specification deviations
Definition: avcodec.h:1333
IPUContext
Definition: mpeg12dec.c:3004
mpeg1_hwaccel_pixfmt_list_420
static enum AVPixelFormat mpeg1_hwaccel_pixfmt_list_420[]
Definition: mpeg12dec.c:1112
ff_mpv_common_end
void ff_mpv_common_end(MpegEncContext *s)
Definition: mpegvideo.c:1113
mpeg12.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ER_DC_ERROR
#define ER_DC_ERROR
Definition: error_resilience.h:32
av_cold
#define av_cold
Definition: attributes.h:90
mpeg2_hwaccel_pixfmt_list_420
static enum AVPixelFormat mpeg2_hwaccel_pixfmt_list_420[]
Definition: mpeg12dec.c:1126
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
mpeg1_decode_picture
static int mpeg1_decode_picture(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:1342
flush
static void flush(AVCodecContext *avctx)
Definition: mpeg12dec.c:2880
Mpeg1Context::save_progressive_seq
int save_progressive_seq
Definition: mpeg12dec.c:68
ff_rl_mpeg1
RLTable ff_rl_mpeg1
Definition: mpeg12data.c:166
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:150
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:485
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:679
A53_MAX_CC_COUNT
#define A53_MAX_CC_COUNT
Definition: mpeg12dec.c:54
Mpeg1Context::repeat_field
int repeat_field
Definition: mpeg12dec.c:59
width
#define width
stereo3d.h
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:127
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_mpeg1_aspect
const float ff_mpeg1_aspect[16]
Definition: mpeg12data.c:374
FF_QSCALE_TYPE_MPEG2
#define FF_QSCALE_TYPE_MPEG2
Definition: internal.h:97
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:515
s1
#define s1
Definition: regdef.h:38
slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2041
Mpeg1Context::mpeg_enc_ctx_allocated
int mpeg_enc_ctx_allocated
Definition: mpeg12dec.c:58
SHOW_SBITS
#define SHOW_SBITS(name, gb, num)
Definition: get_bits.h:213
ff_mpeg_er_frame_start
void ff_mpeg_er_frame_start(MpegEncContext *s)
Definition: mpeg_er.c:46
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
mpeg_decode_sequence_display_extension
static void mpeg_decode_sequence_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1441
Mpeg1Context::pan_scan
AVPanScan pan_scan
Definition: mpeg12dec.c:60
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:360
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:36
mpeg12_pixfmt_list_422
static enum AVPixelFormat mpeg12_pixfmt_list_422[]
Definition: mpeg12dec.c:1153
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:194
IS_INTRA
#define IS_INTRA(x, y)
field
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
Definition: writing_filters.txt:78
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCodecContext::rc_max_rate
int64_t rc_max_rate
maximum bitrate
Definition: avcodec.h:1194
ff_mpeg1video_decoder
const AVCodec ff_mpeg1video_decoder
Definition: mpeg12dec.c:2899
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:104
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:393
arg
const char * arg
Definition: jacosubdec.c:67
if
if(ret)
Definition: filter_design.txt:179
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:54
Mpeg1Context::rc_buffer_size
int rc_buffer_size
Definition: mpeg12dec.c:69
MB_PTYPE_VLC_BITS
#define MB_PTYPE_VLC_BITS
Definition: mpeg12vlc.h:39
Mpeg1Context::save_width
int save_width
Definition: mpeg12dec.c:68
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:192
NULL
#define NULL
Definition: coverity.c:32
run
uint8_t run
Definition: svq3.c:203
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:967
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
ER_AC_ERROR
#define ER_AC_ERROR
Definition: error_resilience.h:31
SLICE_MIN_START_CODE
#define SLICE_MIN_START_CODE
Definition: mpeg12.h:33
ff_mpv_idct_init
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:331
Mpeg1Context::sync
int sync
Definition: mpeg12dec.c:71
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:597
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:599
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:433
mpeg_decode_picture_display_extension
static void mpeg_decode_picture_display_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1465
MpegEncContext::inter_matrix
uint16_t inter_matrix[64]
Definition: mpegvideo.h:292
AV_CODEC_FLAG2_FAST
#define AV_CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
Definition: avcodec.h:287
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
profiles.h
AV_CODEC_FLAG_TRUNCATED
#define AV_CODEC_FLAG_TRUNCATED
Input bitstream might be truncated at a random location instead of only at frame boundaries.
Definition: avcodec.h:255
AV_PIX_FMT_XVMC
@ AV_PIX_FMT_XVMC
XVideo Motion Acceleration via common packet passing.
Definition: pixfmt.h:263
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:200
MB_TYPE_QUANT
#define MB_TYPE_QUANT
Definition: mpegutils.h:69
lowres
static int lowres
Definition: ffplay.c:334
av_frame_new_side_data_from_buf
AVFrameSideData * av_frame_new_side_data_from_buf(AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef *buf)
Add a new side data to a frame from an existing AVBufferRef.
Definition: frame.c:573
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:156
MB_BTYPE_VLC_BITS
#define MB_BTYPE_VLC_BITS
Definition: mpeg12vlc.h:40
xvmc_internal.h
ff_mpegvideo_decoder
const AVCodec ff_mpegvideo_decoder
Definition: mpeg12dec.c:2984
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1335
AV_FRAME_DATA_AFD
@ AV_FRAME_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:89
AVCodecContext::level
int level
level
Definition: avcodec.h:1651
Mpeg1Context::save_height
int save_height
Definition: mpeg12dec.c:68
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AV_CODEC_ID_MPEG1VIDEO
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:51
MpegEncContext::idsp
IDCTDSPContext idsp
Definition: mpegvideo.h:220
ff_mb_ptype_vlc
VLC ff_mb_ptype_vlc
Definition: mpeg12.c:132
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
quant_matrix_rebuild
static void quant_matrix_rebuild(uint16_t *matrix, const uint8_t *old_perm, const uint8_t *new_perm)
Definition: mpeg12dec.c:1100
ff_mpeg1_find_frame_end
int ff_mpeg1_find_frame_end(ParseContext *pc, const uint8_t *buf, int buf_size, AVCodecParserContext *s)
Find the end of the current frame in the bitstream.
Definition: mpeg12.c:176
s2
#define s2
Definition: regdef.h:39
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:53
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:470
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:243
AVPacket::size
int size
Definition: packet.h:374
dc
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]
Definition: snow.txt:400
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
MpegEncContext::qscale
int qscale
QP.
Definition: mpegvideo.h:194
AV_CODEC_ID_IPU
@ AV_CODEC_ID_IPU
Definition: codec_id.h:305
AV_FRAME_DATA_PANSCAN
@ AV_FRAME_DATA_PANSCAN
The data is the AVPanScan struct defined in libavcodec.
Definition: frame.h:52
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:327
MT_FRAME
#define MT_FRAME
Definition: mpeg12dec.c:648
IPUContext::flags
int flags
Definition: mpeg12dec.c:3007
MpegEncContext::intra_matrix
uint16_t intra_matrix[64]
matrix transmitted in the bitstream
Definition: mpegvideo.h:290
ff_mpeg1_clean_buffers
void ff_mpeg1_clean_buffers(MpegEncContext *s)
Definition: mpeg12.c:114
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
AVFrameSideData::data
uint8_t * data
Definition: frame.h:211
MB_TYPE_SKIP
#define MB_TYPE_SKIP
Definition: mpegutils.h:61
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1452
PICTURE_START_CODE
#define PICTURE_START_CODE
Definition: mpeg12.h:32
ff_mpeg_flush
void ff_mpeg_flush(AVCodecContext *avctx)
Definition: mpegvideo.c:2304
USER_START_CODE
#define USER_START_CODE
Definition: cavs.h:36
AVCodecContext::skip_bottom
int skip_bottom
Number of macroblock rows at the bottom which are skipped.
Definition: avcodec.h:898
AVCodecHWConfigInternal
Definition: hwconfig.h:29
ff_mpeg1_default_intra_matrix
const uint16_t ff_mpeg1_default_intra_matrix[256]
Definition: mpeg12data.c:30
MB_TYPE_INTERLACED
#define MB_TYPE_INTERLACED
Definition: mpegutils.h:57
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:139
height
#define height
ff_mpeg_update_thread_context
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: mpegvideo.c:524
Mpeg1Context::has_stereo3d
int has_stereo3d
Definition: mpeg12dec.c:62
mpeg_decode_init
static av_cold int mpeg_decode_init(AVCodecContext *avctx)
Definition: mpeg12dec.c:1049
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
HWACCEL_D3D11VA
#define HWACCEL_D3D11VA(codec)
Definition: hwconfig.h:79
mpegvideodata.h
attributes.h
MV_TYPE_FIELD
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:259
ff_mpv_export_qp_table
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
Definition: mpegvideo.c:1424
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:539
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:303
ff_print_debug_info
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
Definition: mpegvideo.c:1417
ff_ipu_decoder
const AVCodec ff_ipu_decoder
Definition: mpeg12dec.c:3150
HWACCEL_NVDEC
#define HWACCEL_NVDEC(codec)
Definition: hwconfig.h:71
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:119
ff_combine_frame
int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
Combine the (truncated) bitstream to a complete frame.
Definition: parser.c:201
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1451
ff_mpeg2_video_profiles
const AVProfile ff_mpeg2_video_profiles[]
Definition: profiles.c:100
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:187
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
MB_TYPE_L0L1
#define MB_TYPE_L0L1
Definition: mpegutils.h:68
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:272
MpegEncContext::block_last_index
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:76
mpeg_decode_gop
static void mpeg_decode_gop(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:2440
setup_hwaccel_for_pixfmt
static void setup_hwaccel_for_pixfmt(AVCodecContext *avctx)
Definition: mpeg12dec.c:1184
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
MpegEncContext::chroma_inter_matrix
uint16_t chroma_inter_matrix[64]
Definition: mpegvideo.h:293
i
int i
Definition: input.c:406
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
AV_CODEC_FLAG2_SHOW_ALL
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition: avcodec.h:315
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1822
ff_alternate_vertical_scan
const uint8_t ff_alternate_vertical_scan[64]
Definition: mpegvideodata.c:95
btype2mb_type
static const uint32_t btype2mb_type[11]
Definition: mpeg12dec.c:89
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:484
AVHWAccel::decode_slice
int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Callback for each slice.
Definition: avcodec.h:2129
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:447
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:50
internal.h
AV_STEREO3D_TOPBOTTOM
@ AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition: stereo3d.h:79
AVCPBProperties::max_bitrate
int64_t max_bitrate
Maximum bitrate of the stream, in bits per second.
Definition: defs.h:109
IS_QUANT
#define IS_QUANT(a)
Definition: mpegutils.h:94
ff_mpeg12_init_vlcs
av_cold void ff_mpeg12_init_vlcs(void)
Definition: mpeg12.c:165
FF_DEBUG_STARTCODE
#define FF_DEBUG_STARTCODE
Definition: avcodec.h:1310
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_d2q
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:106
MB_PAT_VLC_BITS
#define MB_PAT_VLC_BITS
Definition: mpeg12vlc.h:38
mpeg1_decode_block_inter
static int mpeg1_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:140
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:437
AVCodecContext::idct_algo
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1397
ptype2mb_type
static const uint32_t ptype2mb_type[7]
Definition: mpeg12dec.c:79
IPUContext::m
MpegEncContext m
Definition: mpeg12dec.c:3005
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
update_thread_context
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have update_thread_context() run it in the next thread. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. If there are inter-frame dependencies
MpegEncContext::intra_vlc_format
int intra_vlc_format
Definition: mpegvideo.h:464
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:974
MAX_INDEX
#define MAX_INDEX
Definition: mpeg12dec.c:130
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
ff_mpv_frame_end
void ff_mpv_frame_end(MpegEncContext *s)
Definition: mpegvideo.c:1409
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:559
Mpeg1Context::stereo3d
AVStereo3D stereo3d
Definition: mpeg12dec.c:61
idctdsp.h
avcodec.h
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
GET_RL_VLC
#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update)
Definition: get_bits.h:739
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ff_mpeg12_frame_rate_tab
const AVRational ff_mpeg12_frame_rate_tab[]
Definition: mpeg12framerate.c:24
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
AV_FRAME_DATA_GOP_TIMECODE
@ AV_FRAME_DATA_GOP_TIMECODE
The GOP timecode in 25 bit timecode format.
Definition: frame.h:124
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ff_mpeg1_default_non_intra_matrix
const uint16_t ff_mpeg1_default_non_intra_matrix[64]
Definition: mpeg12data.c:41
AVCPBProperties::buffer_size
int64_t buffer_size
The size of the buffer to which the ratecontrol is applied, in bits.
Definition: defs.h:125
mpeg1_fast_decode_block_inter
static int mpeg1_fast_decode_block_inter(MpegEncContext *s, int16_t *block, int n)
Changing this would eat up any speed benefits it has.
Definition: mpeg12dec.c:229
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:694
ff_mpv_frame_start
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
Definition: mpegvideo.c:1185
TEX_VLC_BITS
#define TEX_VLC_BITS
Definition: dvdec.c:132
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
mpeg_get_pixelformat
static enum AVPixelFormat mpeg_get_pixelformat(AVCodecContext *avctx)
Definition: mpeg12dec.c:1163
AV_CODEC_FLAG2_CHUNKS
#define AV_CODEC_FLAG2_CHUNKS
Input bitstream might be truncated at a packet boundaries instead of only at frame boundaries.
Definition: avcodec.h:306
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
mpeg12data.h
mpeg2_fast_decode_block_non_intra
static int mpeg2_fast_decode_block_non_intra(MpegEncContext *s, int16_t *block, int n)
Changing this would eat up any speed benefits it has.
Definition: mpeg12dec.c:404
mpeg_field_start
static int mpeg_field_start(MpegEncContext *s, const uint8_t *buf, int buf_size)
Definition: mpeg12dec.c:1599
skip_1stop_8data_bits
static int skip_1stop_8data_bits(GetBitContext *gb)
Definition: get_bits.h:855
AVCodecContext
main external API structure.
Definition: avcodec.h:383
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1459
av_timecode_make_mpeg_tc_string
char * av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)
Get the timecode string from the 25-bit timecode format (MPEG GOP format).
Definition: timecode.c:165
MpegEncContext::intra_dc_precision
int intra_dc_precision
Definition: mpegvideo.h:458
decode_dc
static int decode_dc(GetBitContext *gb, int component)
Definition: mpeg12.h:50
AVCodecContext::execute
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:1491
ff_update_duplicate_context
int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
Definition: mpegvideo.c:499
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:212
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:598
AVRational::den
int den
Denominator.
Definition: rational.h:60
error_resilience.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1525
AVFrame::metadata
AVDictionary * metadata
metadata.
Definition: frame.h:572
ff_mb_btype_vlc
VLC ff_mb_btype_vlc
Definition: mpeg12.c:133
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
ff_thread_get_format
FF_DISABLE_DEPRECATION_WARNINGS enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: pthread_frame.c:1021
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
ff_mpv_reconstruct_mb
void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
Definition: mpegvideo.c:2252
Mpeg1Context::slice_count
int slice_count
Definition: mpeg12dec.c:66
profiles
static const AVProfile profiles[]
Definition: libfdk-aacenc.c:429
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:82
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:1824
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
av_buffer_realloc
int av_buffer_realloc(AVBufferRef **pbuf, size_t size)
Reallocate a given buffer.
Definition: buffer.c:183
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1302
AV_EF_AGGRESSIVE
#define AV_EF_AGGRESSIVE
consider things that a sane encoder should not do as an error
Definition: avcodec.h:1340
AVHWAccel::start_frame
int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)
Called at the beginning of each frame or field picture.
Definition: avcodec.h:2101
shift
static int shift(int a, int b)
Definition: sonic.c:83
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:571
get_dmv
static int get_dmv(MpegEncContext *s)
Definition: mpeg12dec.c:638
tc
#define tc
Definition: regdef.h:69
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FF_API_FLAG_TRUNCATED
#define FF_API_FLAG_TRUNCATED
Definition: version.h:85
mpeg_decode_end
static av_cold int mpeg_decode_end(AVCodecContext *avctx)
Definition: mpeg12dec.c:2889
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
ff_mpeg2video_decoder
const AVCodec ff_mpeg2video_decoder
Definition: mpeg12dec.c:2935
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:86
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
MpegEncContext::inter_scantable
ScanTable inter_scantable
if inter == intra then intra should be used to reduce the cache usage
Definition: mpegvideo.h:80
IDCTDSPContext::idct_permutation
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:96
av_stereo3d_create_side_data
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition: stereo3d.c:33
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:209
check_marker
static int check_marker(void *logctx, GetBitContext *s, const char *msg)
Definition: get_bits.h:613
ER_MV_END
#define ER_MV_END
Definition: error_resilience.h:36
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
ff_mv_vlc
VLC ff_mv_vlc
Definition: mpeg12.c:126
MpegEncContext::q_scale_type
int q_scale_type
Definition: mpegvideo.h:462
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:408
Mpeg1Context::mpeg_enc_ctx
MpegEncContext mpeg_enc_ctx
Definition: mpeg12dec.c:57
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:205
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
MV_DIR_FORWARD
#define MV_DIR_FORWARD
Definition: mpegvideo.h:252
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
ScanTable::permutated
uint8_t permutated[64]
Definition: idctdsp.h:33
ff_er_frame_end
void ff_er_frame_end(ERContext *s)
Definition: error_resilience.c:899
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
mpeg_decode_sequence_extension
static void mpeg_decode_sequence_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1391
HWACCEL_VAAPI
#define HWACCEL_VAAPI(codec)
Definition: hwconfig.h:73
mpeg_er.h
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
Mpeg1Context::frame_rate_ext
AVRational frame_rate_ext
Definition: mpeg12dec.c:70
mpeg_decode_motion
static int mpeg_decode_motion(MpegEncContext *s, int fcode, int pred)
Definition: mpeg12dec.c:104
ff_mpv_report_decode_progress
void ff_mpv_report_decode_progress(MpegEncContext *s)
Definition: mpegvideo.c:2351
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
IPUContext::block
int16_t block[6][64]
Definition: mpeg12dec.c:3008
mpeg_decode_user_data
static void mpeg_decode_user_data(AVCodecContext *avctx, const uint8_t *p, int buf_size)
Definition: mpeg12dec.c:2370
h
h
Definition: vp9dsp_template.c:2038
MpegEncContext::end_mb_y
int end_mb_y
end mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
Definition: mpegvideo.h:144
ER_AC_END
#define ER_AC_END
Definition: error_resilience.h:34
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
Definition: stereo3d.h:176
av_image_check_sar
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
Definition: imgutils.c:323
MV_VLC_BITS
#define MV_VLC_BITS
Definition: mpeg12vlc.h:34
MpegEncContext::start_mb_y
int start_mb_y
start mb_y of this thread (so current thread should process start_mb_y <= row < end_mb_y)
Definition: mpegvideo.h:143
ff_mpv_decode_init
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
Initialize the given MpegEncContext for decoding.
Definition: mpegvideo.c:699
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:50
MpegEncContext::alternate_scan
int alternate_scan
Definition: mpegvideo.h:465
DECODE_SLICE_OK
#define DECODE_SLICE_OK
Definition: mpeg12dec.c:1703
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:52
DECODE_SLICE_ERROR
#define DECODE_SLICE_ERROR
Definition: mpeg12dec.c:1702
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:71
load_matrix
static int load_matrix(MpegEncContext *s, uint16_t matrix0[64], uint16_t matrix1[64], int intra)
Definition: mpeg12dec.c:1499
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:753
Mpeg1Context::afd
uint8_t afd
Definition: mpeg12dec.c:64
Mpeg1Context
Definition: mpeg12dec.c:56
RLTable::rl_vlc
RL_VLC_ELEM * rl_vlc[32]
decoding only
Definition: rl.h:48
MpegEncContext::chroma_intra_matrix
uint16_t chroma_intra_matrix[64]
Definition: mpegvideo.h:291
mpeg_decode_picture_coding_extension
static int mpeg_decode_picture_coding_extension(Mpeg1Context *s1)
Definition: mpeg12dec.c:1536
Mpeg1Context::extradata_decoded
int extradata_decoded
Definition: mpeg12dec.c:74
video_enc_params.h
mpeg2_decode_block_non_intra
static int mpeg2_decode_block_non_intra(MpegEncContext *s, int16_t *block, int n)
Definition: mpeg12dec.c:314
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:72
MBINCR_VLC_BITS
#define MBINCR_VLC_BITS
Definition: mpeg12vlc.h:37
mpeg_decode_slice
static int mpeg_decode_slice(MpegEncContext *s, int mb_y, const uint8_t **buf, int buf_size)
Decode a slice.
Definition: mpeg12dec.c:1711
re
float re
Definition: fft.c:78