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