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