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