path: root/libavcodec/mpeg12dec.c (plain)
blob: 82b503d7173f8538d2ab9fe03421a50c1b0b85d3

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