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