path: root/libavcodec/vp3.c (plain)
blob: 86e5852e32935e8da4a21fe6333c9d11e7efa189

1	/*
2	* Copyright (C) 2003-2004 The FFmpeg project
3	*
4	* This file is part of FFmpeg.
5	*
6	* FFmpeg is free software; you can redistribute it and/or
7	* modify it under the terms of the GNU Lesser General Public
8	* License as published by the Free Software Foundation; either
9	* version 2.1 of the License, or (at your option) any later version.
10	*
11	* FFmpeg is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14	* Lesser General Public License for more details.
15	*
16	* You should have received a copy of the GNU Lesser General Public
17	* License along with FFmpeg; if not, write to the Free Software
18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19	*/
20
21	/**
22	* @file
23	* On2 VP3 Video Decoder
24	*
25	* VP3 Video Decoder by Mike Melanson (mike at multimedia.cx)
26	* For more information about the VP3 coding process, visit:
27	* http://wiki.multimedia.cx/index.php?title=On2_VP3
28	*
29	* Theora decoder by Alex Beregszaszi
30	*/
31
32	#include <stdio.h>
33	#include <stdlib.h>
34	#include <string.h>
35
36	#include "libavutil/imgutils.h"
37
38	#include "avcodec.h"
39	#include "get_bits.h"
40	#include "hpeldsp.h"
41	#include "internal.h"
42	#include "mathops.h"
43	#include "thread.h"
44	#include "videodsp.h"
45	#include "vp3data.h"
46	#include "vp3dsp.h"
47	#include "xiph.h"
48
49	#define FRAGMENT_PIXELS 8
50
51	// FIXME split things out into their own arrays
52	typedef struct Vp3Fragment {
53	int16_t dc;
54	uint8_t coding_method;
55	uint8_t qpi;
56	} Vp3Fragment;
57
58	#define SB_NOT_CODED 0
59	#define SB_PARTIALLY_CODED 1
60	#define SB_FULLY_CODED 2
61
62	// This is the maximum length of a single long bit run that can be encoded
63	// for superblock coding or block qps. Theora special-cases this to read a
64	// bit instead of flipping the current bit to allow for runs longer than 4129.
65	#define MAXIMUM_LONG_BIT_RUN 4129
66
67	#define MODE_INTER_NO_MV 0
68	#define MODE_INTRA 1
69	#define MODE_INTER_PLUS_MV 2
70	#define MODE_INTER_LAST_MV 3
71	#define MODE_INTER_PRIOR_LAST 4
72	#define MODE_USING_GOLDEN 5
73	#define MODE_GOLDEN_MV 6
74	#define MODE_INTER_FOURMV 7
75	#define CODING_MODE_COUNT 8
76
77	/* special internal mode */
78	#define MODE_COPY 8
79
80	static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb);
81	static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb);
82
83
84	/* There are 6 preset schemes, plus a free-form scheme */
85	static const int ModeAlphabet[6][CODING_MODE_COUNT] = {
86	/* scheme 1: Last motion vector dominates */
87	{ MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
88	MODE_INTER_PLUS_MV, MODE_INTER_NO_MV,
89	MODE_INTRA, MODE_USING_GOLDEN,
90	MODE_GOLDEN_MV, MODE_INTER_FOURMV },
91
92	/* scheme 2 */
93	{ MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
94	MODE_INTER_NO_MV, MODE_INTER_PLUS_MV,
95	MODE_INTRA, MODE_USING_GOLDEN,
96	MODE_GOLDEN_MV, MODE_INTER_FOURMV },
97
98	/* scheme 3 */
99	{ MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,
100	MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,
101	MODE_INTRA, MODE_USING_GOLDEN,
102	MODE_GOLDEN_MV, MODE_INTER_FOURMV },
103
104	/* scheme 4 */
105	{ MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,
106	MODE_INTER_NO_MV, MODE_INTER_PRIOR_LAST,
107	MODE_INTRA, MODE_USING_GOLDEN,
108	MODE_GOLDEN_MV, MODE_INTER_FOURMV },
109
110	/* scheme 5: No motion vector dominates */
111	{ MODE_INTER_NO_MV, MODE_INTER_LAST_MV,
112	MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,
113	MODE_INTRA, MODE_USING_GOLDEN,
114	MODE_GOLDEN_MV, MODE_INTER_FOURMV },
115
116	/* scheme 6 */
117	{ MODE_INTER_NO_MV, MODE_USING_GOLDEN,
118	MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
119	MODE_INTER_PLUS_MV, MODE_INTRA,
120	MODE_GOLDEN_MV, MODE_INTER_FOURMV },
121	};
122
123	static const uint8_t hilbert_offset[16][2] = {
124	{ 0, 0 }, { 1, 0 }, { 1, 1 }, { 0, 1 },
125	{ 0, 2 }, { 0, 3 }, { 1, 3 }, { 1, 2 },
126	{ 2, 2 }, { 2, 3 }, { 3, 3 }, { 3, 2 },
127	{ 3, 1 }, { 2, 1 }, { 2, 0 }, { 3, 0 }
128	};
129
130	#define MIN_DEQUANT_VAL 2
131
132	typedef struct Vp3DecodeContext {
133	AVCodecContext *avctx;
134	int theora, theora_tables, theora_header;
135	int version;
136	int width, height;
137	int chroma_x_shift, chroma_y_shift;
138	ThreadFrame golden_frame;
139	ThreadFrame last_frame;
140	ThreadFrame current_frame;
141	int keyframe;
142	uint8_t idct_permutation[64];
143	uint8_t idct_scantable[64];
144	HpelDSPContext hdsp;
145	VideoDSPContext vdsp;
146	VP3DSPContext vp3dsp;
147	DECLARE_ALIGNED(16, int16_t, block)[64];
148	int flipped_image;
149	int last_slice_end;
150	int skip_loop_filter;
151
152	int qps[3];
153	int nqps;
154	int last_qps[3];
155
156	int superblock_count;
157	int y_superblock_width;
158	int y_superblock_height;
159	int y_superblock_count;
160	int c_superblock_width;
161	int c_superblock_height;
162	int c_superblock_count;
163	int u_superblock_start;
164	int v_superblock_start;
165	unsigned char *superblock_coding;
166
167	int macroblock_count;
168	int macroblock_width;
169	int macroblock_height;
170
171	int fragment_count;
172	int fragment_width[2];
173	int fragment_height[2];
174
175	Vp3Fragment *all_fragments;
176	int fragment_start[3];
177	int data_offset[3];
178	uint8_t offset_x;
179	uint8_t offset_y;
180	int offset_x_warned;
181
182	int8_t (*motion_val[2])[2];
183
184	/* tables */
185	uint16_t coded_dc_scale_factor[64];
186	uint32_t coded_ac_scale_factor[64];
187	uint8_t base_matrix[384][64];
188	uint8_t qr_count[2][3];
189	uint8_t qr_size[2][3][64];
190	uint16_t qr_base[2][3][64];
191
192	/**
193	* This is a list of all tokens in bitstream order. Reordering takes place
194	* by pulling from each level during IDCT. As a consequence, IDCT must be
195	* in Hilbert order, making the minimum slice height 64 for 4:2:0 and 32
196	* otherwise. The 32 different tokens with up to 12 bits of extradata are
197	* collapsed into 3 types, packed as follows:
198	* (from the low to high bits)
199	*
200	* 2 bits: type (0,1,2)
201	* 0: EOB run, 14 bits for run length (12 needed)
202	* 1: zero run, 7 bits for run length
203	* 7 bits for the next coefficient (3 needed)
204	* 2: coefficient, 14 bits (11 needed)
205	*
206	* Coefficients are signed, so are packed in the highest bits for automatic
207	* sign extension.
208	*/
209	int16_t *dct_tokens[3][64];
210	int16_t *dct_tokens_base;
211	#define TOKEN_EOB(eob_run) ((eob_run) << 2)
212	#define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) * 512) + ((zero_run) << 2) + 1)
213	#define TOKEN_COEFF(coeff) (((coeff) * 4) + 2)
214
215	/**
216	* number of blocks that contain DCT coefficients at
217	* the given level or higher
218	*/
219	int num_coded_frags[3][64];
220	int total_num_coded_frags;
221
222	/* this is a list of indexes into the all_fragments array indicating
223	* which of the fragments are coded */
224	int *coded_fragment_list[3];
225
226	VLC dc_vlc[16];
227	VLC ac_vlc_1[16];
228	VLC ac_vlc_2[16];
229	VLC ac_vlc_3[16];
230	VLC ac_vlc_4[16];
231
232	VLC superblock_run_length_vlc;
233	VLC fragment_run_length_vlc;
234	VLC mode_code_vlc;
235	VLC motion_vector_vlc;
236
237	/* these arrays need to be on 16-byte boundaries since SSE2 operations
238	* index into them */
239	DECLARE_ALIGNED(16, int16_t, qmat)[3][2][3][64]; ///< qmat[qpi][is_inter][plane]
240
241	/* This table contains superblock_count * 16 entries. Each set of 16
242	* numbers corresponds to the fragment indexes 0..15 of the superblock.
243	* An entry will be -1 to indicate that no entry corresponds to that
244	* index. */
245	int *superblock_fragments;
246
247	/* This is an array that indicates how a particular macroblock
248	* is coded. */
249	unsigned char *macroblock_coding;
250
251	uint8_t *edge_emu_buffer;
252
253	/* Huffman decode */
254	int hti;
255	unsigned int hbits;
256	int entries;
257	int huff_code_size;
258	uint32_t huffman_table[80][32][2];
259
260	uint8_t filter_limit_values[64];
261	DECLARE_ALIGNED(8, int, bounding_values_array)[256 + 2];
262	} Vp3DecodeContext;
263
264	/************************************************************************
265	* VP3 specific functions
266	************************************************************************/
267
268	static av_cold void free_tables(AVCodecContext *avctx)
269	{
270	Vp3DecodeContext *s = avctx->priv_data;
271
272	av_freep(&s->superblock_coding);
273	av_freep(&s->all_fragments);
274	av_freep(&s->coded_fragment_list[0]);
275	av_freep(&s->dct_tokens_base);
276	av_freep(&s->superblock_fragments);
277	av_freep(&s->macroblock_coding);
278	av_freep(&s->motion_val[0]);
279	av_freep(&s->motion_val[1]);
280	}
281
282	static void vp3_decode_flush(AVCodecContext *avctx)
283	{
284	Vp3DecodeContext *s = avctx->priv_data;
285
286	if (s->golden_frame.f)
287	ff_thread_release_buffer(avctx, &s->golden_frame);
288	if (s->last_frame.f)
289	ff_thread_release_buffer(avctx, &s->last_frame);
290	if (s->current_frame.f)
291	ff_thread_release_buffer(avctx, &s->current_frame);
292	}
293
294	static av_cold int vp3_decode_end(AVCodecContext *avctx)
295	{
296	Vp3DecodeContext *s = avctx->priv_data;
297	int i;
298
299	free_tables(avctx);
300	av_freep(&s->edge_emu_buffer);
301
302	s->theora_tables = 0;
303
304	/* release all frames */
305	vp3_decode_flush(avctx);
306	av_frame_free(&s->current_frame.f);
307	av_frame_free(&s->last_frame.f);
308	av_frame_free(&s->golden_frame.f);
309
310	if (avctx->internal->is_copy)
311	return 0;
312
313	for (i = 0; i < 16; i++) {
314	ff_free_vlc(&s->dc_vlc[i]);
315	ff_free_vlc(&s->ac_vlc_1[i]);
316	ff_free_vlc(&s->ac_vlc_2[i]);
317	ff_free_vlc(&s->ac_vlc_3[i]);
318	ff_free_vlc(&s->ac_vlc_4[i]);
319	}
320
321	ff_free_vlc(&s->superblock_run_length_vlc);
322	ff_free_vlc(&s->fragment_run_length_vlc);
323	ff_free_vlc(&s->mode_code_vlc);
324	ff_free_vlc(&s->motion_vector_vlc);
325
326	return 0;
327	}
328
329	/**
330	* This function sets up all of the various blocks mappings:
331	* superblocks <-> fragments, macroblocks <-> fragments,
332	* superblocks <-> macroblocks
333	*
334	* @return 0 is successful; returns 1 if *anything* went wrong.
335	*/
336	static int init_block_mapping(Vp3DecodeContext *s)
337	{
338	int sb_x, sb_y, plane;
339	int x, y, i, j = 0;
340
341	for (plane = 0; plane < 3; plane++) {
342	int sb_width = plane ? s->c_superblock_width
343	: s->y_superblock_width;
344	int sb_height = plane ? s->c_superblock_height
345	: s->y_superblock_height;
346	int frag_width = s->fragment_width[!!plane];
347	int frag_height = s->fragment_height[!!plane];
348
349	for (sb_y = 0; sb_y < sb_height; sb_y++)
350	for (sb_x = 0; sb_x < sb_width; sb_x++)
351	for (i = 0; i < 16; i++) {
352	x = 4 * sb_x + hilbert_offset[i][0];
353	y = 4 * sb_y + hilbert_offset[i][1];
354
355	if (x < frag_width && y < frag_height)
356	s->superblock_fragments[j++] = s->fragment_start[plane] +
357	y * frag_width + x;
358	else
359	s->superblock_fragments[j++] = -1;
360	}
361	}
362
363	return 0; /* successful path out */
364	}
365
366	/*
367	* This function sets up the dequantization tables used for a particular
368	* frame.
369	*/
370	static void init_dequantizer(Vp3DecodeContext *s, int qpi)
371	{
372	int ac_scale_factor = s->coded_ac_scale_factor[s->qps[qpi]];
373	int dc_scale_factor = s->coded_dc_scale_factor[s->qps[qpi]];
374	int i, plane, inter, qri, bmi, bmj, qistart;
375
376	for (inter = 0; inter < 2; inter++) {
377	for (plane = 0; plane < 3; plane++) {
378	int sum = 0;
379	for (qri = 0; qri < s->qr_count[inter][plane]; qri++) {
380	sum += s->qr_size[inter][plane][qri];
381	if (s->qps[qpi] <= sum)
382	break;
383	}
384	qistart = sum - s->qr_size[inter][plane][qri];
385	bmi = s->qr_base[inter][plane][qri];
386	bmj = s->qr_base[inter][plane][qri + 1];
387	for (i = 0; i < 64; i++) {
388	int coeff = (2 * (sum - s->qps[qpi]) * s->base_matrix[bmi][i] -
389	2 * (qistart - s->qps[qpi]) * s->base_matrix[bmj][i] +
390	s->qr_size[inter][plane][qri]) /
391	(2 * s->qr_size[inter][plane][qri]);
392
393	int qmin = 8 << (inter + !i);
394	int qscale = i ? ac_scale_factor : dc_scale_factor;
395
396	s->qmat[qpi][inter][plane][s->idct_permutation[i]] =
397	av_clip((qscale * coeff) / 100 * 4, qmin, 4096);
398	}
399	/* all DC coefficients use the same quant so as not to interfere
400	* with DC prediction */
401	s->qmat[qpi][inter][plane][0] = s->qmat[0][inter][plane][0];
402	}
403	}
404	}
405
406	/*
407	* This function initializes the loop filter boundary limits if the frame's
408	* quality index is different from the previous frame's.
409	*
410	* The filter_limit_values may not be larger than 127.
411	*/
412	static void init_loop_filter(Vp3DecodeContext *s)
413	{
414	int *bounding_values = s->bounding_values_array + 127;
415	int filter_limit;
416	int x;
417	int value;
418
419	filter_limit = s->filter_limit_values[s->qps[0]];
420	av_assert0(filter_limit < 128U);
421
422	/* set up the bounding values */
423	memset(s->bounding_values_array, 0, 256 * sizeof(int));
424	for (x = 0; x < filter_limit; x++) {
425	bounding_values[-x] = -x;
426	bounding_values[x] = x;
427	}
428	for (x = value = filter_limit; x < 128 && value; x++, value--) {
429	bounding_values[ x] = value;
430	bounding_values[-x] = -value;
431	}
432	if (value)
433	bounding_values[128] = value;
434	bounding_values[129] = bounding_values[130] = filter_limit * 0x02020202;
435	}
436
437	/*
438	* This function unpacks all of the superblock/macroblock/fragment coding
439	* information from the bitstream.
440	*/
441	static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
442	{
443	int superblock_starts[3] = {
444	0, s->u_superblock_start, s->v_superblock_start
445	};
446	int bit = 0;
447	int current_superblock = 0;
448	int current_run = 0;
449	int num_partial_superblocks = 0;
450
451	int i, j;
452	int current_fragment;
453	int plane;
454
455	if (s->keyframe) {
456	memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
457	} else {
458	/* unpack the list of partially-coded superblocks */
459	bit = get_bits1(gb) ^ 1;
460	current_run = 0;
461
462	while (current_superblock < s->superblock_count && get_bits_left(gb) > 0) {
463	if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)
464	bit = get_bits1(gb);
465	else
466	bit ^= 1;
467
468	current_run = get_vlc2(gb, s->superblock_run_length_vlc.table,
469	6, 2) + 1;
470	if (current_run == 34)
471	current_run += get_bits(gb, 12);
472
473	if (current_run > s->superblock_count - current_superblock) {
474	av_log(s->avctx, AV_LOG_ERROR,
475	"Invalid partially coded superblock run length\n");
476	return -1;
477	}
478
479	memset(s->superblock_coding + current_superblock, bit, current_run);
480
481	current_superblock += current_run;
482	if (bit)
483	num_partial_superblocks += current_run;
484	}
485
486	/* unpack the list of fully coded superblocks if any of the blocks were
487	* not marked as partially coded in the previous step */
488	if (num_partial_superblocks < s->superblock_count) {
489	int superblocks_decoded = 0;
490
491	current_superblock = 0;
492	bit = get_bits1(gb) ^ 1;
493	current_run = 0;
494
495	while (superblocks_decoded < s->superblock_count - num_partial_superblocks &&
496	get_bits_left(gb) > 0) {
497	if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)
498	bit = get_bits1(gb);
499	else
500	bit ^= 1;
501
502	current_run = get_vlc2(gb, s->superblock_run_length_vlc.table,
503	6, 2) + 1;
504	if (current_run == 34)
505	current_run += get_bits(gb, 12);
506
507	for (j = 0; j < current_run; current_superblock++) {
508	if (current_superblock >= s->superblock_count) {
509	av_log(s->avctx, AV_LOG_ERROR,
510	"Invalid fully coded superblock run length\n");
511	return -1;
512	}
513
514	/* skip any superblocks already marked as partially coded */
515	if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
516	s->superblock_coding[current_superblock] = 2 * bit;
517	j++;
518	}
519	}
520	superblocks_decoded += current_run;
521	}
522	}
523
524	/* if there were partial blocks, initialize bitstream for
525	* unpacking fragment codings */
526	if (num_partial_superblocks) {
527	current_run = 0;
528	bit = get_bits1(gb);
529	/* toggle the bit because as soon as the first run length is
530	* fetched the bit will be toggled again */
531	bit ^= 1;
532	}
533	}
534
535	/* figure out which fragments are coded; iterate through each
536	* superblock (all planes) */
537	s->total_num_coded_frags = 0;
538	memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
539
540	for (plane = 0; plane < 3; plane++) {
541	int sb_start = superblock_starts[plane];
542	int sb_end = sb_start + (plane ? s->c_superblock_count
543	: s->y_superblock_count);
544	int num_coded_frags = 0;
545
546	for (i = sb_start; i < sb_end && get_bits_left(gb) > 0; i++) {
547	/* iterate through all 16 fragments in a superblock */
548	for (j = 0; j < 16; j++) {
549	/* if the fragment is in bounds, check its coding status */
550	current_fragment = s->superblock_fragments[i * 16 + j];
551	if (current_fragment != -1) {
552	int coded = s->superblock_coding[i];
553
554	if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
555	/* fragment may or may not be coded; this is the case
556	* that cares about the fragment coding runs */
557	if (current_run-- == 0) {
558	bit ^= 1;
559	current_run = get_vlc2(gb, s->fragment_run_length_vlc.table, 5, 2);
560	}
561	coded = bit;
562	}
563
564	if (coded) {
565	/* default mode; actual mode will be decoded in
566	* the next phase */
567	s->all_fragments[current_fragment].coding_method =
568	MODE_INTER_NO_MV;
569	s->coded_fragment_list[plane][num_coded_frags++] =
570	current_fragment;
571	} else {
572	/* not coded; copy this fragment from the prior frame */
573	s->all_fragments[current_fragment].coding_method =
574	MODE_COPY;
575	}
576	}
577	}
578	}
579	s->total_num_coded_frags += num_coded_frags;
580	for (i = 0; i < 64; i++)
581	s->num_coded_frags[plane][i] = num_coded_frags;
582	if (plane < 2)
583	s->coded_fragment_list[plane + 1] = s->coded_fragment_list[plane] +
584	num_coded_frags;
585	}
586	return 0;
587	}
588
589	/*
590	* This function unpacks all the coding mode data for individual macroblocks
591	* from the bitstream.
592	*/
593	static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
594	{
595	int i, j, k, sb_x, sb_y;
596	int scheme;
597	int current_macroblock;
598	int current_fragment;
599	int coding_mode;
600	int custom_mode_alphabet[CODING_MODE_COUNT];
601	const int *alphabet;
602	Vp3Fragment *frag;
603
604	if (s->keyframe) {
605	for (i = 0; i < s->fragment_count; i++)
606	s->all_fragments[i].coding_method = MODE_INTRA;
607	} else {
608	/* fetch the mode coding scheme for this frame */
609	scheme = get_bits(gb, 3);
610
611	/* is it a custom coding scheme? */
612	if (scheme == 0) {
613	for (i = 0; i < 8; i++)
614	custom_mode_alphabet[i] = MODE_INTER_NO_MV;
615	for (i = 0; i < 8; i++)
616	custom_mode_alphabet[get_bits(gb, 3)] = i;
617	alphabet = custom_mode_alphabet;
618	} else
619	alphabet = ModeAlphabet[scheme - 1];
620
621	/* iterate through all of the macroblocks that contain 1 or more
622	* coded fragments */
623	for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {
624	for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {
625	if (get_bits_left(gb) <= 0)
626	return -1;
627
628	for (j = 0; j < 4; j++) {
629	int mb_x = 2 * sb_x + (j >> 1);
630	int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
631	current_macroblock = mb_y * s->macroblock_width + mb_x;
632
633	if (mb_x >= s->macroblock_width ||
634	mb_y >= s->macroblock_height)
635	continue;
636
637	#define BLOCK_X (2 * mb_x + (k & 1))
638	#define BLOCK_Y (2 * mb_y + (k >> 1))
639	/* coding modes are only stored if the macroblock has
640	* at least one luma block coded, otherwise it must be
641	* INTER_NO_MV */
642	for (k = 0; k < 4; k++) {
643	current_fragment = BLOCK_Y *
644	s->fragment_width[0] + BLOCK_X;
645	if (s->all_fragments[current_fragment].coding_method != MODE_COPY)
646	break;
647	}
648	if (k == 4) {
649	s->macroblock_coding[current_macroblock] = MODE_INTER_NO_MV;
650	continue;
651	}
652
653	/* mode 7 means get 3 bits for each coding mode */
654	if (scheme == 7)
655	coding_mode = get_bits(gb, 3);
656	else
657	coding_mode = alphabet[get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
658
659	s->macroblock_coding[current_macroblock] = coding_mode;
660	for (k = 0; k < 4; k++) {
661	frag = s->all_fragments + BLOCK_Y * s->fragment_width[0] + BLOCK_X;
662	if (frag->coding_method != MODE_COPY)
663	frag->coding_method = coding_mode;
664	}
665
666	#define SET_CHROMA_MODES \
667	if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \
668	frag[s->fragment_start[1]].coding_method = coding_mode; \
669	if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \
670	frag[s->fragment_start[2]].coding_method = coding_mode;
671
672	if (s->chroma_y_shift) {
673	frag = s->all_fragments + mb_y *
674	s->fragment_width[1] + mb_x;
675	SET_CHROMA_MODES
676	} else if (s->chroma_x_shift) {
677	frag = s->all_fragments +
678	2 * mb_y * s->fragment_width[1] + mb_x;
679	for (k = 0; k < 2; k++) {
680	SET_CHROMA_MODES
681	frag += s->fragment_width[1];
682	}
683	} else {
684	for (k = 0; k < 4; k++) {
685	frag = s->all_fragments +
686	BLOCK_Y * s->fragment_width[1] + BLOCK_X;
687	SET_CHROMA_MODES
688	}
689	}
690	}
691	}
692	}
693	}
694
695	return 0;
696	}
697
698	/*
699	* This function unpacks all the motion vectors for the individual
700	* macroblocks from the bitstream.
701	*/
702	static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
703	{
704	int j, k, sb_x, sb_y;
705	int coding_mode;
706	int motion_x[4];
707	int motion_y[4];
708	int last_motion_x = 0;
709	int last_motion_y = 0;
710	int prior_last_motion_x = 0;
711	int prior_last_motion_y = 0;
712	int current_macroblock;
713	int current_fragment;
714	int frag;
715
716	if (s->keyframe)
717	return 0;
718
719	/* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
720	coding_mode = get_bits1(gb);
721
722	/* iterate through all of the macroblocks that contain 1 or more
723	* coded fragments */
724	for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {
725	for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {
726	if (get_bits_left(gb) <= 0)
727	return -1;
728
729	for (j = 0; j < 4; j++) {
730	int mb_x = 2 * sb_x + (j >> 1);
731	int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
732	current_macroblock = mb_y * s->macroblock_width + mb_x;
733
734	if (mb_x >= s->macroblock_width ||
735	mb_y >= s->macroblock_height ||
736	s->macroblock_coding[current_macroblock] == MODE_COPY)
737	continue;
738
739	switch (s->macroblock_coding[current_macroblock]) {
740	case MODE_INTER_PLUS_MV:
741	case MODE_GOLDEN_MV:
742	/* all 6 fragments use the same motion vector */
743	if (coding_mode == 0) {
744	motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
745	motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
746	} else {
747	motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)];
748	motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)];
749	}
750
751	/* vector maintenance, only on MODE_INTER_PLUS_MV */
752	if (s->macroblock_coding[current_macroblock] == MODE_INTER_PLUS_MV) {
753	prior_last_motion_x = last_motion_x;
754	prior_last_motion_y = last_motion_y;
755	last_motion_x = motion_x[0];
756	last_motion_y = motion_y[0];
757	}
758	break;
759
760	case MODE_INTER_FOURMV:
761	/* vector maintenance */
762	prior_last_motion_x = last_motion_x;
763	prior_last_motion_y = last_motion_y;
764
765	/* fetch 4 vectors from the bitstream, one for each
766	* Y fragment, then average for the C fragment vectors */
767	for (k = 0; k < 4; k++) {
768	current_fragment = BLOCK_Y * s->fragment_width[0] + BLOCK_X;
769	if (s->all_fragments[current_fragment].coding_method != MODE_COPY) {
770	if (coding_mode == 0) {
771	motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
772	motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
773	} else {
774	motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)];
775	motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)];
776	}
777	last_motion_x = motion_x[k];
778	last_motion_y = motion_y[k];
779	} else {
780	motion_x[k] = 0;
781	motion_y[k] = 0;
782	}
783	}
784	break;
785
786	case MODE_INTER_LAST_MV:
787	/* all 6 fragments use the last motion vector */
788	motion_x[0] = last_motion_x;
789	motion_y[0] = last_motion_y;
790
791	/* no vector maintenance (last vector remains the
792	* last vector) */
793	break;
794
795	case MODE_INTER_PRIOR_LAST:
796	/* all 6 fragments use the motion vector prior to the
797	* last motion vector */
798	motion_x[0] = prior_last_motion_x;
799	motion_y[0] = prior_last_motion_y;
800
801	/* vector maintenance */
802	prior_last_motion_x = last_motion_x;
803	prior_last_motion_y = last_motion_y;
804	last_motion_x = motion_x[0];
805	last_motion_y = motion_y[0];
806	break;
807
808	default:
809	/* covers intra, inter without MV, golden without MV */
810	motion_x[0] = 0;
811	motion_y[0] = 0;
812
813	/* no vector maintenance */
814	break;
815	}
816
817	/* assign the motion vectors to the correct fragments */
818	for (k = 0; k < 4; k++) {
819	current_fragment =
820	BLOCK_Y * s->fragment_width[0] + BLOCK_X;
821	if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
822	s->motion_val[0][current_fragment][0] = motion_x[k];
823	s->motion_val[0][current_fragment][1] = motion_y[k];
824	} else {
825	s->motion_val[0][current_fragment][0] = motion_x[0];
826	s->motion_val[0][current_fragment][1] = motion_y[0];
827	}
828	}
829
830	if (s->chroma_y_shift) {
831	if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
832	motion_x[0] = RSHIFT(motion_x[0] + motion_x[1] +
833	motion_x[2] + motion_x[3], 2);
834	motion_y[0] = RSHIFT(motion_y[0] + motion_y[1] +
835	motion_y[2] + motion_y[3], 2);
836	}
837	motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
838	motion_y[0] = (motion_y[0] >> 1) | (motion_y[0] & 1);
839	frag = mb_y * s->fragment_width[1] + mb_x;
840	s->motion_val[1][frag][0] = motion_x[0];
841	s->motion_val[1][frag][1] = motion_y[0];
842	} else if (s->chroma_x_shift) {
843	if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
844	motion_x[0] = RSHIFT(motion_x[0] + motion_x[1], 1);
845	motion_y[0] = RSHIFT(motion_y[0] + motion_y[1], 1);
846	motion_x[1] = RSHIFT(motion_x[2] + motion_x[3], 1);
847	motion_y[1] = RSHIFT(motion_y[2] + motion_y[3], 1);
848	} else {
849	motion_x[1] = motion_x[0];
850	motion_y[1] = motion_y[0];
851	}
852	motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
853	motion_x[1] = (motion_x[1] >> 1) | (motion_x[1] & 1);
854
855	frag = 2 * mb_y * s->fragment_width[1] + mb_x;
856	for (k = 0; k < 2; k++) {
857	s->motion_val[1][frag][0] = motion_x[k];
858	s->motion_val[1][frag][1] = motion_y[k];
859	frag += s->fragment_width[1];
860	}
861	} else {
862	for (k = 0; k < 4; k++) {
863	frag = BLOCK_Y * s->fragment_width[1] + BLOCK_X;
864	if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
865	s->motion_val[1][frag][0] = motion_x[k];
866	s->motion_val[1][frag][1] = motion_y[k];
867	} else {
868	s->motion_val[1][frag][0] = motion_x[0];
869	s->motion_val[1][frag][1] = motion_y[0];
870	}
871	}
872	}
873	}
874	}
875	}
876
877	return 0;
878	}
879
880	static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb)
881	{
882	int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi;
883	int num_blocks = s->total_num_coded_frags;
884
885	for (qpi = 0; qpi < s->nqps - 1 && num_blocks > 0; qpi++) {
886	i = blocks_decoded = num_blocks_at_qpi = 0;
887
888	bit = get_bits1(gb) ^ 1;
889	run_length = 0;
890
891	do {
892	if (run_length == MAXIMUM_LONG_BIT_RUN)
893	bit = get_bits1(gb);
894	else
895	bit ^= 1;
896
897	run_length = get_vlc2(gb, s->superblock_run_length_vlc.table, 6, 2) + 1;
898	if (run_length == 34)
899	run_length += get_bits(gb, 12);
900	blocks_decoded += run_length;
901
902	if (!bit)
903	num_blocks_at_qpi += run_length;
904
905	for (j = 0; j < run_length; i++) {
906	if (i >= s->total_num_coded_frags)
907	return -1;
908
909	if (s->all_fragments[s->coded_fragment_list[0][i]].qpi == qpi) {
910	s->all_fragments[s->coded_fragment_list[0][i]].qpi += bit;
911	j++;
912	}
913	}
914	} while (blocks_decoded < num_blocks && get_bits_left(gb) > 0);
915
916	num_blocks -= num_blocks_at_qpi;
917	}
918
919	return 0;
920	}
921
922	/*
923	* This function is called by unpack_dct_coeffs() to extract the VLCs from
924	* the bitstream. The VLCs encode tokens which are used to unpack DCT
925	* data. This function unpacks all the VLCs for either the Y plane or both
926	* C planes, and is called for DC coefficients or different AC coefficient
927	* levels (since different coefficient types require different VLC tables.
928	*
929	* This function returns a residual eob run. E.g, if a particular token gave
930	* instructions to EOB the next 5 fragments and there were only 2 fragments
931	* left in the current fragment range, 3 would be returned so that it could
932	* be passed into the next call to this same function.
933	*/
934	static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
935	VLC *table, int coeff_index,
936	int plane,
937	int eob_run)
938	{
939	int i, j = 0;
940	int token;
941	int zero_run = 0;
942	int16_t coeff = 0;
943	int bits_to_get;
944	int blocks_ended;
945	int coeff_i = 0;
946	int num_coeffs = s->num_coded_frags[plane][coeff_index];
947	int16_t *dct_tokens = s->dct_tokens[plane][coeff_index];
948
949	/* local references to structure members to avoid repeated dereferences */
950	int *coded_fragment_list = s->coded_fragment_list[plane];
951	Vp3Fragment *all_fragments = s->all_fragments;
952	VLC_TYPE(*vlc_table)[2] = table->table;
953
954	if (num_coeffs < 0)
955	av_log(s->avctx, AV_LOG_ERROR,
956	"Invalid number of coefficients at level %d\n", coeff_index);
957
958	if (eob_run > num_coeffs) {
959	coeff_i =
960	blocks_ended = num_coeffs;
961	eob_run -= num_coeffs;
962	} else {
963	coeff_i =
964	blocks_ended = eob_run;
965	eob_run = 0;
966	}
967
968	// insert fake EOB token to cover the split between planes or zzi
969	if (blocks_ended)
970	dct_tokens[j++] = blocks_ended << 2;
971
972	while (coeff_i < num_coeffs && get_bits_left(gb) > 0) {
973	/* decode a VLC into a token */
974	token = get_vlc2(gb, vlc_table, 11, 3);
975	/* use the token to get a zero run, a coefficient, and an eob run */
976	if ((unsigned) token <= 6U) {
977	eob_run = eob_run_base[token];
978	if (eob_run_get_bits[token])
979	eob_run += get_bits(gb, eob_run_get_bits[token]);
980
981	// record only the number of blocks ended in this plane,
982	// any spill will be recorded in the next plane.
983	if (eob_run > num_coeffs - coeff_i) {
984	dct_tokens[j++] = TOKEN_EOB(num_coeffs - coeff_i);
985	blocks_ended += num_coeffs - coeff_i;
986	eob_run -= num_coeffs - coeff_i;
987	coeff_i = num_coeffs;
988	} else {
989	dct_tokens[j++] = TOKEN_EOB(eob_run);
990	blocks_ended += eob_run;
991	coeff_i += eob_run;
992	eob_run = 0;
993	}
994	} else if (token >= 0) {
995	bits_to_get = coeff_get_bits[token];
996	if (bits_to_get)
997	bits_to_get = get_bits(gb, bits_to_get);
998	coeff = coeff_tables[token][bits_to_get];
999
1000	zero_run = zero_run_base[token];
1001	if (zero_run_get_bits[token])
1002	zero_run += get_bits(gb, zero_run_get_bits[token]);
1003
1004	if (zero_run) {
1005	dct_tokens[j++] = TOKEN_ZERO_RUN(coeff, zero_run);
1006	} else {
1007	// Save DC into the fragment structure. DC prediction is
1008	// done in raster order, so the actual DC can't be in with
1009	// other tokens. We still need the token in dct_tokens[]
1010	// however, or else the structure collapses on itself.
1011	if (!coeff_index)
1012	all_fragments[coded_fragment_list[coeff_i]].dc = coeff;
1013
1014	dct_tokens[j++] = TOKEN_COEFF(coeff);
1015	}
1016
1017	if (coeff_index + zero_run > 64) {
1018	av_log(s->avctx, AV_LOG_DEBUG,
1019	"Invalid zero run of %d with %d coeffs left\n",
1020	zero_run, 64 - coeff_index);
1021	zero_run = 64 - coeff_index;
1022	}
1023
1024	// zero runs code multiple coefficients,
1025	// so don't try to decode coeffs for those higher levels
1026	for (i = coeff_index + 1; i <= coeff_index + zero_run; i++)
1027	s->num_coded_frags[plane][i]--;
1028	coeff_i++;
1029	} else {
1030	av_log(s->avctx, AV_LOG_ERROR, "Invalid token %d\n", token);
1031	return -1;
1032	}
1033	}
1034
1035	if (blocks_ended > s->num_coded_frags[plane][coeff_index])
1036	av_log(s->avctx, AV_LOG_ERROR, "More blocks ended than coded!\n");
1037
1038	// decrement the number of blocks that have higher coefficients for each
1039	// EOB run at this level
1040	if (blocks_ended)
1041	for (i = coeff_index + 1; i < 64; i++)
1042	s->num_coded_frags[plane][i] -= blocks_ended;
1043
1044	// setup the next buffer
1045	if (plane < 2)
1046	s->dct_tokens[plane + 1][coeff_index] = dct_tokens + j;
1047	else if (coeff_index < 63)
1048	s->dct_tokens[0][coeff_index + 1] = dct_tokens + j;
1049
1050	return eob_run;
1051	}
1052
1053	static void reverse_dc_prediction(Vp3DecodeContext *s,
1054	int first_fragment,
1055	int fragment_width,
1056	int fragment_height);
1057	/*
1058	* This function unpacks all of the DCT coefficient data from the
1059	* bitstream.
1060	*/
1061	static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
1062	{
1063	int i;
1064	int dc_y_table;
1065	int dc_c_table;
1066	int ac_y_table;
1067	int ac_c_table;
1068	int residual_eob_run = 0;
1069	VLC *y_tables[64];
1070	VLC *c_tables[64];
1071
1072	s->dct_tokens[0][0] = s->dct_tokens_base;
1073
1074	/* fetch the DC table indexes */
1075	dc_y_table = get_bits(gb, 4);
1076	dc_c_table = get_bits(gb, 4);
1077
1078	/* unpack the Y plane DC coefficients */
1079	residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0,
1080	0, residual_eob_run);
1081	if (residual_eob_run < 0)
1082	return residual_eob_run;
1083
1084	/* reverse prediction of the Y-plane DC coefficients */
1085	reverse_dc_prediction(s, 0, s->fragment_width[0], s->fragment_height[0]);
1086
1087	/* unpack the C plane DC coefficients */
1088	residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1089	1, residual_eob_run);
1090	if (residual_eob_run < 0)
1091	return residual_eob_run;
1092	residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1093	2, residual_eob_run);
1094	if (residual_eob_run < 0)
1095	return residual_eob_run;
1096
1097	/* reverse prediction of the C-plane DC coefficients */
1098	if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
1099	reverse_dc_prediction(s, s->fragment_start[1],
1100	s->fragment_width[1], s->fragment_height[1]);
1101	reverse_dc_prediction(s, s->fragment_start[2],
1102	s->fragment_width[1], s->fragment_height[1]);
1103	}
1104
1105	/* fetch the AC table indexes */
1106	ac_y_table = get_bits(gb, 4);
1107	ac_c_table = get_bits(gb, 4);
1108
1109	/* build tables of AC VLC tables */
1110	for (i = 1; i <= 5; i++) {
1111	y_tables[i] = &s->ac_vlc_1[ac_y_table];
1112	c_tables[i] = &s->ac_vlc_1[ac_c_table];
1113	}
1114	for (i = 6; i <= 14; i++) {
1115	y_tables[i] = &s->ac_vlc_2[ac_y_table];
1116	c_tables[i] = &s->ac_vlc_2[ac_c_table];
1117	}
1118	for (i = 15; i <= 27; i++) {
1119	y_tables[i] = &s->ac_vlc_3[ac_y_table];
1120	c_tables[i] = &s->ac_vlc_3[ac_c_table];
1121	}
1122	for (i = 28; i <= 63; i++) {
1123	y_tables[i] = &s->ac_vlc_4[ac_y_table];
1124	c_tables[i] = &s->ac_vlc_4[ac_c_table];
1125	}
1126
1127	/* decode all AC coefficients */
1128	for (i = 1; i <= 63; i++) {
1129	residual_eob_run = unpack_vlcs(s, gb, y_tables[i], i,
1130	0, residual_eob_run);
1131	if (residual_eob_run < 0)
1132	return residual_eob_run;
1133
1134	residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i,
1135	1, residual_eob_run);
1136	if (residual_eob_run < 0)
1137	return residual_eob_run;
1138	residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i,
1139	2, residual_eob_run);
1140	if (residual_eob_run < 0)
1141	return residual_eob_run;
1142	}
1143
1144	return 0;
1145	}
1146
1147	/*
1148	* This function reverses the DC prediction for each coded fragment in
1149	* the frame. Much of this function is adapted directly from the original
1150	* VP3 source code.
1151	*/
1152	#define COMPATIBLE_FRAME(x) \
1153	(compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1154	#define DC_COEFF(u) s->all_fragments[u].dc
1155
1156	static void reverse_dc_prediction(Vp3DecodeContext *s,
1157	int first_fragment,
1158	int fragment_width,
1159	int fragment_height)
1160	{
1161	#define PUL 8
1162	#define PU 4
1163	#define PUR 2
1164	#define PL 1
1165
1166	int x, y;
1167	int i = first_fragment;
1168
1169	int predicted_dc;
1170
1171	/* DC values for the left, up-left, up, and up-right fragments */
1172	int vl, vul, vu, vur;
1173
1174	/* indexes for the left, up-left, up, and up-right fragments */
1175	int l, ul, u, ur;
1176
1177	/*
1178	* The 6 fields mean:
1179	* 0: up-left multiplier
1180	* 1: up multiplier
1181	* 2: up-right multiplier
1182	* 3: left multiplier
1183	*/
1184	static const int predictor_transform[16][4] = {
1185	{ 0, 0, 0, 0 },
1186	{ 0, 0, 0, 128 }, // PL
1187	{ 0, 0, 128, 0 }, // PUR
1188	{ 0, 0, 53, 75 }, // PUR|PL
1189	{ 0, 128, 0, 0 }, // PU
1190	{ 0, 64, 0, 64 }, // PU |PL
1191	{ 0, 128, 0, 0 }, // PU |PUR
1192	{ 0, 0, 53, 75 }, // PU |PUR|PL
1193	{ 128, 0, 0, 0 }, // PUL
1194	{ 0, 0, 0, 128 }, // PUL|PL
1195	{ 64, 0, 64, 0 }, // PUL|PUR
1196	{ 0, 0, 53, 75 }, // PUL|PUR|PL
1197	{ 0, 128, 0, 0 }, // PUL|PU
1198	{ -104, 116, 0, 116 }, // PUL|PU |PL
1199	{ 24, 80, 24, 0 }, // PUL|PU |PUR
1200	{ -104, 116, 0, 116 } // PUL|PU |PUR|PL
1201	};
1202
1203	/* This table shows which types of blocks can use other blocks for
1204	* prediction. For example, INTRA is the only mode in this table to
1205	* have a frame number of 0. That means INTRA blocks can only predict
1206	* from other INTRA blocks. There are 2 golden frame coding types;
1207	* blocks encoding in these modes can only predict from other blocks
1208	* that were encoded with these 1 of these 2 modes. */
1209	static const unsigned char compatible_frame[9] = {
1210	1, /* MODE_INTER_NO_MV */
1211	0, /* MODE_INTRA */
1212	1, /* MODE_INTER_PLUS_MV */
1213	1, /* MODE_INTER_LAST_MV */
1214	1, /* MODE_INTER_PRIOR_MV */
1215	2, /* MODE_USING_GOLDEN */
1216	2, /* MODE_GOLDEN_MV */
1217	1, /* MODE_INTER_FOUR_MV */
1218	3 /* MODE_COPY */
1219	};
1220	int current_frame_type;
1221
1222	/* there is a last DC predictor for each of the 3 frame types */
1223	short last_dc[3];
1224
1225	int transform = 0;
1226
1227	vul =
1228	vu =
1229	vur =
1230	vl = 0;
1231	last_dc[0] =
1232	last_dc[1] =
1233	last_dc[2] = 0;
1234
1235	/* for each fragment row... */
1236	for (y = 0; y < fragment_height; y++) {
1237	/* for each fragment in a row... */
1238	for (x = 0; x < fragment_width; x++, i++) {
1239
1240	/* reverse prediction if this block was coded */
1241	if (s->all_fragments[i].coding_method != MODE_COPY) {
1242	current_frame_type =
1243	compatible_frame[s->all_fragments[i].coding_method];
1244
1245	transform = 0;
1246	if (x) {
1247	l = i - 1;
1248	vl = DC_COEFF(l);
1249	if (COMPATIBLE_FRAME(l))
1250	transform |= PL;
1251	}
1252	if (y) {
1253	u = i - fragment_width;
1254	vu = DC_COEFF(u);
1255	if (COMPATIBLE_FRAME(u))
1256	transform |= PU;
1257	if (x) {
1258	ul = i - fragment_width - 1;
1259	vul = DC_COEFF(ul);
1260	if (COMPATIBLE_FRAME(ul))
1261	transform |= PUL;
1262	}
1263	if (x + 1 < fragment_width) {
1264	ur = i - fragment_width + 1;
1265	vur = DC_COEFF(ur);
1266	if (COMPATIBLE_FRAME(ur))
1267	transform |= PUR;
1268	}
1269	}
1270
1271	if (transform == 0) {
1272	/* if there were no fragments to predict from, use last
1273	* DC saved */
1274	predicted_dc = last_dc[current_frame_type];
1275	} else {
1276	/* apply the appropriate predictor transform */
1277	predicted_dc =
1278	(predictor_transform[transform][0] * vul) +
1279	(predictor_transform[transform][1] * vu) +
1280	(predictor_transform[transform][2] * vur) +
1281	(predictor_transform[transform][3] * vl);
1282
1283	predicted_dc /= 128;
1284
1285	/* check for outranging on the [ul u l] and
1286	* [ul u ur l] predictors */
1287	if ((transform == 15) || (transform == 13)) {
1288	if (FFABS(predicted_dc - vu) > 128)
1289	predicted_dc = vu;
1290	else if (FFABS(predicted_dc - vl) > 128)
1291	predicted_dc = vl;
1292	else if (FFABS(predicted_dc - vul) > 128)
1293	predicted_dc = vul;
1294	}
1295	}
1296
1297	/* at long last, apply the predictor */
1298	DC_COEFF(i) += predicted_dc;
1299	/* save the DC */
1300	last_dc[current_frame_type] = DC_COEFF(i);
1301	}
1302	}
1303	}
1304	}
1305
1306	static void apply_loop_filter(Vp3DecodeContext *s, int plane,
1307	int ystart, int yend)
1308	{
1309	int x, y;
1310	int *bounding_values = s->bounding_values_array + 127;
1311
1312	int width = s->fragment_width[!!plane];
1313	int height = s->fragment_height[!!plane];
1314	int fragment = s->fragment_start[plane] + ystart * width;
1315	ptrdiff_t stride = s->current_frame.f->linesize[plane];
1316	uint8_t *plane_data = s->current_frame.f->data[plane];
1317	if (!s->flipped_image)
1318	stride = -stride;
1319	plane_data += s->data_offset[plane] + 8 * ystart * stride;
1320
1321	for (y = ystart; y < yend; y++) {
1322	for (x = 0; x < width; x++) {
1323	/* This code basically just deblocks on the edges of coded blocks.
1324	* However, it has to be much more complicated because of the
1325	* brain damaged deblock ordering used in VP3/Theora. Order matters
1326	* because some pixels get filtered twice. */
1327	if (s->all_fragments[fragment].coding_method != MODE_COPY) {
1328	/* do not perform left edge filter for left columns frags */
1329	if (x > 0) {
1330	s->vp3dsp.h_loop_filter(
1331	plane_data + 8 * x,
1332	stride, bounding_values);
1333	}
1334
1335	/* do not perform top edge filter for top row fragments */
1336	if (y > 0) {
1337	s->vp3dsp.v_loop_filter(
1338	plane_data + 8 * x,
1339	stride, bounding_values);
1340	}
1341
1342	/* do not perform right edge filter for right column
1343	* fragments or if right fragment neighbor is also coded
1344	* in this frame (it will be filtered in next iteration) */
1345	if ((x < width - 1) &&
1346	(s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {
1347	s->vp3dsp.h_loop_filter(
1348	plane_data + 8 * x + 8,
1349	stride, bounding_values);
1350	}
1351
1352	/* do not perform bottom edge filter for bottom row
1353	* fragments or if bottom fragment neighbor is also coded
1354	* in this frame (it will be filtered in the next row) */
1355	if ((y < height - 1) &&
1356	(s->all_fragments[fragment + width].coding_method == MODE_COPY)) {
1357	s->vp3dsp.v_loop_filter(
1358	plane_data + 8 * x + 8 * stride,
1359	stride, bounding_values);
1360	}
1361	}
1362
1363	fragment++;
1364	}
1365	plane_data += 8 * stride;
1366	}
1367	}
1368
1369	/**
1370	* Pull DCT tokens from the 64 levels to decode and dequant the coefficients
1371	* for the next block in coding order
1372	*/
1373	static inline int vp3_dequant(Vp3DecodeContext *s, Vp3Fragment *frag,
1374	int plane, int inter, int16_t block[64])
1375	{
1376	int16_t *dequantizer = s->qmat[frag->qpi][inter][plane];
1377	uint8_t *perm = s->idct_scantable;
1378	int i = 0;
1379
1380	do {
1381	int token = *s->dct_tokens[plane][i];
1382	switch (token & 3) {
1383	case 0: // EOB
1384	if (--token < 4) // 0-3 are token types so the EOB run must now be 0
1385	s->dct_tokens[plane][i]++;
1386	else
1387	*s->dct_tokens[plane][i] = token & ~3;
1388	goto end;
1389	case 1: // zero run
1390	s->dct_tokens[plane][i]++;
1391	i += (token >> 2) & 0x7f;
1392	if (i > 63) {
1393	av_log(s->avctx, AV_LOG_ERROR, "Coefficient index overflow\n");
1394	return i;
1395	}
1396	block[perm[i]] = (token >> 9) * dequantizer[perm[i]];
1397	i++;
1398	break;
1399	case 2: // coeff
1400	block[perm[i]] = (token >> 2) * dequantizer[perm[i]];
1401	s->dct_tokens[plane][i++]++;
1402	break;
1403	default: // shouldn't happen
1404	return i;
1405	}
1406	} while (i < 64);
1407	// return value is expected to be a valid level
1408	i--;
1409	end:
1410	// the actual DC+prediction is in the fragment structure
1411	block[0] = frag->dc * s->qmat[0][inter][plane][0];
1412	return i;
1413	}
1414
1415	/**
1416	* called when all pixels up to row y are complete
1417	*/
1418	static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y)
1419	{
1420	int h, cy, i;
1421	int offset[AV_NUM_DATA_POINTERS];
1422
1423	if (HAVE_THREADS && s->avctx->active_thread_type & FF_THREAD_FRAME) {
1424	int y_flipped = s->flipped_image ? s->height - y : y;
1425
1426	/* At the end of the frame, report INT_MAX instead of the height of
1427	* the frame. This makes the other threads' ff_thread_await_progress()
1428	* calls cheaper, because they don't have to clip their values. */
1429	ff_thread_report_progress(&s->current_frame,
1430	y_flipped == s->height ? INT_MAX
1431	: y_flipped - 1,
1432	0);
1433	}
1434
1435	if (!s->avctx->draw_horiz_band)
1436	return;
1437
1438	h = y - s->last_slice_end;
1439	s->last_slice_end = y;
1440	y -= h;
1441
1442	if (!s->flipped_image)
1443	y = s->height - y - h;
1444
1445	cy = y >> s->chroma_y_shift;
1446	offset[0] = s->current_frame.f->linesize[0] * y;
1447	offset[1] = s->current_frame.f->linesize[1] * cy;
1448	offset[2] = s->current_frame.f->linesize[2] * cy;
1449	for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
1450	offset[i] = 0;
1451
1452	emms_c();
1453	s->avctx->draw_horiz_band(s->avctx, s->current_frame.f, offset, y, 3, h);
1454	}
1455
1456	/**
1457	* Wait for the reference frame of the current fragment.
1458	* The progress value is in luma pixel rows.
1459	*/
1460	static void await_reference_row(Vp3DecodeContext *s, Vp3Fragment *fragment,
1461	int motion_y, int y)
1462	{
1463	ThreadFrame *ref_frame;
1464	int ref_row;
1465	int border = motion_y & 1;
1466
1467	if (fragment->coding_method == MODE_USING_GOLDEN ||
1468	fragment->coding_method == MODE_GOLDEN_MV)
1469	ref_frame = &s->golden_frame;
1470	else
1471	ref_frame = &s->last_frame;
1472
1473	ref_row = y + (motion_y >> 1);
1474	ref_row = FFMAX(FFABS(ref_row), ref_row + 8 + border);
1475
1476	ff_thread_await_progress(ref_frame, ref_row, 0);
1477	}
1478
1479	/*
1480	* Perform the final rendering for a particular slice of data.
1481	* The slice number ranges from 0..(c_superblock_height - 1).
1482	*/
1483	static void render_slice(Vp3DecodeContext *s, int slice)
1484	{
1485	int x, y, i, j, fragment;
1486	int16_t *block = s->block;
1487	int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
1488	int motion_halfpel_index;
1489	uint8_t *motion_source;
1490	int plane, first_pixel;
1491
1492	if (slice >= s->c_superblock_height)
1493	return;
1494
1495	for (plane = 0; plane < 3; plane++) {
1496	uint8_t *output_plane = s->current_frame.f->data[plane] +
1497	s->data_offset[plane];
1498	uint8_t *last_plane = s->last_frame.f->data[plane] +
1499	s->data_offset[plane];
1500	uint8_t *golden_plane = s->golden_frame.f->data[plane] +
1501	s->data_offset[plane];
1502	ptrdiff_t stride = s->current_frame.f->linesize[plane];
1503	int plane_width = s->width >> (plane && s->chroma_x_shift);
1504	int plane_height = s->height >> (plane && s->chroma_y_shift);
1505	int8_t(*motion_val)[2] = s->motion_val[!!plane];
1506
1507	int sb_x, sb_y = slice << (!plane && s->chroma_y_shift);
1508	int slice_height = sb_y + 1 + (!plane && s->chroma_y_shift);
1509	int slice_width = plane ? s->c_superblock_width
1510	: s->y_superblock_width;
1511
1512	int fragment_width = s->fragment_width[!!plane];
1513	int fragment_height = s->fragment_height[!!plane];
1514	int fragment_start = s->fragment_start[plane];
1515
1516	int do_await = !plane && HAVE_THREADS &&
1517	(s->avctx->active_thread_type & FF_THREAD_FRAME);
1518
1519	if (!s->flipped_image)
1520	stride = -stride;
1521	if (CONFIG_GRAY && plane && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
1522	continue;
1523
1524	/* for each superblock row in the slice (both of them)... */
1525	for (; sb_y < slice_height; sb_y++) {
1526	/* for each superblock in a row... */
1527	for (sb_x = 0; sb_x < slice_width; sb_x++) {
1528	/* for each block in a superblock... */
1529	for (j = 0; j < 16; j++) {
1530	x = 4 * sb_x + hilbert_offset[j][0];
1531	y = 4 * sb_y + hilbert_offset[j][1];
1532	fragment = y * fragment_width + x;
1533
1534	i = fragment_start + fragment;
1535
1536	// bounds check
1537	if (x >= fragment_width || y >= fragment_height)
1538	continue;
1539
1540	first_pixel = 8 * y * stride + 8 * x;
1541
1542	if (do_await &&
1543	s->all_fragments[i].coding_method != MODE_INTRA)
1544	await_reference_row(s, &s->all_fragments[i],
1545	motion_val[fragment][1],
1546	(16 * y) >> s->chroma_y_shift);
1547
1548	/* transform if this block was coded */
1549	if (s->all_fragments[i].coding_method != MODE_COPY) {
1550	if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
1551	(s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
1552	motion_source = golden_plane;
1553	else
1554	motion_source = last_plane;
1555
1556	motion_source += first_pixel;
1557	motion_halfpel_index = 0;
1558
1559	/* sort out the motion vector if this fragment is coded
1560	* using a motion vector method */
1561	if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
1562	(s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
1563	int src_x, src_y;
1564	motion_x = motion_val[fragment][0];
1565	motion_y = motion_val[fragment][1];
1566
1567	src_x = (motion_x >> 1) + 8 * x;
1568	src_y = (motion_y >> 1) + 8 * y;
1569
1570	motion_halfpel_index = motion_x & 0x01;
1571	motion_source += (motion_x >> 1);
1572
1573	motion_halfpel_index |= (motion_y & 0x01) << 1;
1574	motion_source += ((motion_y >> 1) * stride);
1575
1576	if (src_x < 0 || src_y < 0 ||
1577	src_x + 9 >= plane_width ||
1578	src_y + 9 >= plane_height) {
1579	uint8_t *temp = s->edge_emu_buffer;
1580	if (stride < 0)
1581	temp -= 8 * stride;
1582
1583	s->vdsp.emulated_edge_mc(temp, motion_source,
1584	stride, stride,
1585	9, 9, src_x, src_y,
1586	plane_width,
1587	plane_height);
1588	motion_source = temp;
1589	}
1590	}
1591
1592	/* first, take care of copying a block from either the
1593	* previous or the golden frame */
1594	if (s->all_fragments[i].coding_method != MODE_INTRA) {
1595	/* Note, it is possible to implement all MC cases
1596	* with put_no_rnd_pixels_l2 which would look more
1597	* like the VP3 source but this would be slower as
1598	* put_no_rnd_pixels_tab is better optimized */
1599	if (motion_halfpel_index != 3) {
1600	s->hdsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
1601	output_plane + first_pixel,
1602	motion_source, stride, 8);
1603	} else {
1604	/* d is 0 if motion_x and _y have the same sign,
1605	* else -1 */
1606	int d = (motion_x ^ motion_y) >> 31;
1607	s->vp3dsp.put_no_rnd_pixels_l2(output_plane + first_pixel,
1608	motion_source - d,
1609	motion_source + stride + 1 + d,
1610	stride, 8);
1611	}
1612	}
1613
1614	/* invert DCT and place (or add) in final output */
1615
1616	if (s->all_fragments[i].coding_method == MODE_INTRA) {
1617	vp3_dequant(s, s->all_fragments + i,
1618	plane, 0, block);
1619	s->vp3dsp.idct_put(output_plane + first_pixel,
1620	stride,
1621	block);
1622	} else {
1623	if (vp3_dequant(s, s->all_fragments + i,
1624	plane, 1, block)) {
1625	s->vp3dsp.idct_add(output_plane + first_pixel,
1626	stride,
1627	block);
1628	} else {
1629	s->vp3dsp.idct_dc_add(output_plane + first_pixel,
1630	stride, block);
1631	}
1632	}
1633	} else {
1634	/* copy directly from the previous frame */
1635	s->hdsp.put_pixels_tab[1][0](
1636	output_plane + first_pixel,
1637	last_plane + first_pixel,
1638	stride, 8);
1639	}
1640	}
1641	}
1642
1643	// Filter up to the last row in the superblock row
1644	if (!s->skip_loop_filter)
1645	apply_loop_filter(s, plane, 4 * sb_y - !!sb_y,
1646	FFMIN(4 * sb_y + 3, fragment_height - 1));
1647	}
1648	}
1649
1650	/* this looks like a good place for slice dispatch... */
1651	/* algorithm:
1652	* if (slice == s->macroblock_height - 1)
1653	* dispatch (both last slice & 2nd-to-last slice);
1654	* else if (slice > 0)
1655	* dispatch (slice - 1);
1656	*/
1657
1658	vp3_draw_horiz_band(s, FFMIN((32 << s->chroma_y_shift) * (slice + 1) - 16,
1659	s->height - 16));
1660	}
1661
1662	/// Allocate tables for per-frame data in Vp3DecodeContext
1663	static av_cold int allocate_tables(AVCodecContext *avctx)
1664	{
1665	Vp3DecodeContext *s = avctx->priv_data;
1666	int y_fragment_count, c_fragment_count;
1667
1668	free_tables(avctx);
1669
1670	y_fragment_count = s->fragment_width[0] * s->fragment_height[0];
1671	c_fragment_count = s->fragment_width[1] * s->fragment_height[1];
1672
1673	s->superblock_coding = av_mallocz(s->superblock_count);
1674	s->all_fragments = av_mallocz_array(s->fragment_count, sizeof(Vp3Fragment));
1675
1676	s->coded_fragment_list[0] = av_mallocz_array(s->fragment_count, sizeof(int));
1677
1678	s->dct_tokens_base = av_mallocz_array(s->fragment_count,
1679	64 * sizeof(*s->dct_tokens_base));
1680	s->motion_val[0] = av_mallocz_array(y_fragment_count, sizeof(*s->motion_val[0]));
1681	s->motion_val[1] = av_mallocz_array(c_fragment_count, sizeof(*s->motion_val[1]));
1682
1683	/* work out the block mapping tables */
1684	s->superblock_fragments = av_mallocz_array(s->superblock_count, 16 * sizeof(int));
1685	s->macroblock_coding = av_mallocz(s->macroblock_count + 1);
1686
1687	if (!s->superblock_coding || !s->all_fragments ||
1688	!s->dct_tokens_base || !s->coded_fragment_list[0] ||
1689	!s->superblock_fragments || !s->macroblock_coding ||
1690	!s->motion_val[0] || !s->motion_val[1]) {
1691	vp3_decode_end(avctx);
1692	return -1;
1693	}
1694
1695	init_block_mapping(s);
1696
1697	return 0;
1698	}
1699
1700	static av_cold int init_frames(Vp3DecodeContext *s)
1701	{
1702	s->current_frame.f = av_frame_alloc();
1703	s->last_frame.f = av_frame_alloc();
1704	s->golden_frame.f = av_frame_alloc();
1705
1706	if (!s->current_frame.f || !s->last_frame.f || !s->golden_frame.f) {
1707	av_frame_free(&s->current_frame.f);
1708	av_frame_free(&s->last_frame.f);
1709	av_frame_free(&s->golden_frame.f);
1710	return AVERROR(ENOMEM);
1711	}
1712
1713	return 0;
1714	}
1715
1716	static av_cold int vp3_decode_init(AVCodecContext *avctx)
1717	{
1718	Vp3DecodeContext *s = avctx->priv_data;
1719	int i, inter, plane, ret;
1720	int c_width;
1721	int c_height;
1722	int y_fragment_count, c_fragment_count;
1723
1724	ret = init_frames(s);
1725	if (ret < 0)
1726	return ret;
1727
1728	avctx->internal->allocate_progress = 1;
1729
1730	if (avctx->codec_tag == MKTAG('V', 'P', '3', '0'))
1731	s->version = 0;
1732	else
1733	s->version = 1;
1734
1735	s->avctx = avctx;
1736	s->width = FFALIGN(avctx->coded_width, 16);
1737	s->height = FFALIGN(avctx->coded_height, 16);
1738	if (avctx->codec_id != AV_CODEC_ID_THEORA)
1739	avctx->pix_fmt = AV_PIX_FMT_YUV420P;
1740	avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1741	ff_hpeldsp_init(&s->hdsp, avctx->flags | AV_CODEC_FLAG_BITEXACT);
1742	ff_videodsp_init(&s->vdsp, 8);
1743	ff_vp3dsp_init(&s->vp3dsp, avctx->flags);
1744
1745	for (i = 0; i < 64; i++) {
1746	#define TRANSPOSE(x) (((x) >> 3) | (((x) & 7) << 3))
1747	s->idct_permutation[i] = TRANSPOSE(i);
1748	s->idct_scantable[i] = TRANSPOSE(ff_zigzag_direct[i]);
1749	#undef TRANSPOSE
1750	}
1751
1752	/* initialize to an impossible value which will force a recalculation
1753	* in the first frame decode */
1754	for (i = 0; i < 3; i++)
1755	s->qps[i] = -1;
1756
1757	avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
1758
1759	s->y_superblock_width = (s->width + 31) / 32;
1760	s->y_superblock_height = (s->height + 31) / 32;
1761	s->y_superblock_count = s->y_superblock_width * s->y_superblock_height;
1762
1763	/* work out the dimensions for the C planes */
1764	c_width = s->width >> s->chroma_x_shift;
1765	c_height = s->height >> s->chroma_y_shift;
1766	s->c_superblock_width = (c_width + 31) / 32;
1767	s->c_superblock_height = (c_height + 31) / 32;
1768	s->c_superblock_count = s->c_superblock_width * s->c_superblock_height;
1769
1770	s->superblock_count = s->y_superblock_count + (s->c_superblock_count * 2);
1771	s->u_superblock_start = s->y_superblock_count;
1772	s->v_superblock_start = s->u_superblock_start + s->c_superblock_count;
1773
1774	s->macroblock_width = (s->width + 15) / 16;
1775	s->macroblock_height = (s->height + 15) / 16;
1776	s->macroblock_count = s->macroblock_width * s->macroblock_height;
1777
1778	s->fragment_width[0] = s->width / FRAGMENT_PIXELS;
1779	s->fragment_height[0] = s->height / FRAGMENT_PIXELS;
1780	s->fragment_width[1] = s->fragment_width[0] >> s->chroma_x_shift;
1781	s->fragment_height[1] = s->fragment_height[0] >> s->chroma_y_shift;
1782
1783	/* fragment count covers all 8x8 blocks for all 3 planes */
1784	y_fragment_count = s->fragment_width[0] * s->fragment_height[0];
1785	c_fragment_count = s->fragment_width[1] * s->fragment_height[1];
1786	s->fragment_count = y_fragment_count + 2 * c_fragment_count;
1787	s->fragment_start[1] = y_fragment_count;
1788	s->fragment_start[2] = y_fragment_count + c_fragment_count;
1789
1790	if (!s->theora_tables) {
1791	for (i = 0; i < 64; i++) {
1792	s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];
1793	s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];
1794	s->base_matrix[0][i] = vp31_intra_y_dequant[i];
1795	s->base_matrix[1][i] = vp31_intra_c_dequant[i];
1796	s->base_matrix[2][i] = vp31_inter_dequant[i];
1797	s->filter_limit_values[i] = vp31_filter_limit_values[i];
1798	}
1799
1800	for (inter = 0; inter < 2; inter++) {
1801	for (plane = 0; plane < 3; plane++) {
1802	s->qr_count[inter][plane] = 1;
1803	s->qr_size[inter][plane][0] = 63;
1804	s->qr_base[inter][plane][0] =
1805	s->qr_base[inter][plane][1] = 2 * inter + (!!plane) * !inter;
1806	}
1807	}
1808
1809	/* init VLC tables */
1810	for (i = 0; i < 16; i++) {
1811	/* DC histograms */
1812	init_vlc(&s->dc_vlc[i], 11, 32,
1813	&dc_bias[i][0][1], 4, 2,
1814	&dc_bias[i][0][0], 4, 2, 0);
1815
1816	/* group 1 AC histograms */
1817	init_vlc(&s->ac_vlc_1[i], 11, 32,
1818	&ac_bias_0[i][0][1], 4, 2,
1819	&ac_bias_0[i][0][0], 4, 2, 0);
1820
1821	/* group 2 AC histograms */
1822	init_vlc(&s->ac_vlc_2[i], 11, 32,
1823	&ac_bias_1[i][0][1], 4, 2,
1824	&ac_bias_1[i][0][0], 4, 2, 0);
1825
1826	/* group 3 AC histograms */
1827	init_vlc(&s->ac_vlc_3[i], 11, 32,
1828	&ac_bias_2[i][0][1], 4, 2,
1829	&ac_bias_2[i][0][0], 4, 2, 0);
1830
1831	/* group 4 AC histograms */
1832	init_vlc(&s->ac_vlc_4[i], 11, 32,
1833	&ac_bias_3[i][0][1], 4, 2,
1834	&ac_bias_3[i][0][0], 4, 2, 0);
1835	}
1836	} else {
1837	for (i = 0; i < 16; i++) {
1838	/* DC histograms */
1839	if (init_vlc(&s->dc_vlc[i], 11, 32,
1840	&s->huffman_table[i][0][1], 8, 4,
1841	&s->huffman_table[i][0][0], 8, 4, 0) < 0)
1842	goto vlc_fail;
1843
1844	/* group 1 AC histograms */
1845	if (init_vlc(&s->ac_vlc_1[i], 11, 32,
1846	&s->huffman_table[i + 16][0][1], 8, 4,
1847	&s->huffman_table[i + 16][0][0], 8, 4, 0) < 0)
1848	goto vlc_fail;
1849
1850	/* group 2 AC histograms */
1851	if (init_vlc(&s->ac_vlc_2[i], 11, 32,
1852	&s->huffman_table[i + 16 * 2][0][1], 8, 4,
1853	&s->huffman_table[i + 16 * 2][0][0], 8, 4, 0) < 0)
1854	goto vlc_fail;
1855
1856	/* group 3 AC histograms */
1857	if (init_vlc(&s->ac_vlc_3[i], 11, 32,
1858	&s->huffman_table[i + 16 * 3][0][1], 8, 4,
1859	&s->huffman_table[i + 16 * 3][0][0], 8, 4, 0) < 0)
1860	goto vlc_fail;
1861
1862	/* group 4 AC histograms */
1863	if (init_vlc(&s->ac_vlc_4[i], 11, 32,
1864	&s->huffman_table[i + 16 * 4][0][1], 8, 4,
1865	&s->huffman_table[i + 16 * 4][0][0], 8, 4, 0) < 0)
1866	goto vlc_fail;
1867	}
1868	}
1869
1870	init_vlc(&s->superblock_run_length_vlc, 6, 34,
1871	&superblock_run_length_vlc_table[0][1], 4, 2,
1872	&superblock_run_length_vlc_table[0][0], 4, 2, 0);
1873
1874	init_vlc(&s->fragment_run_length_vlc, 5, 30,
1875	&fragment_run_length_vlc_table[0][1], 4, 2,
1876	&fragment_run_length_vlc_table[0][0], 4, 2, 0);
1877
1878	init_vlc(&s->mode_code_vlc, 3, 8,
1879	&mode_code_vlc_table[0][1], 2, 1,
1880	&mode_code_vlc_table[0][0], 2, 1, 0);
1881
1882	init_vlc(&s->motion_vector_vlc, 6, 63,
1883	&motion_vector_vlc_table[0][1], 2, 1,
1884	&motion_vector_vlc_table[0][0], 2, 1, 0);
1885
1886	return allocate_tables(avctx);
1887
1888	vlc_fail:
1889	av_log(avctx, AV_LOG_FATAL, "Invalid huffman table\n");
1890	return -1;
1891	}
1892
1893	/// Release and shuffle frames after decode finishes
1894	static int update_frames(AVCodecContext *avctx)
1895	{
1896	Vp3DecodeContext *s = avctx->priv_data;
1897	int ret = 0;
1898
1899	/* shuffle frames (last = current) */
1900	ff_thread_release_buffer(avctx, &s->last_frame);
1901	ret = ff_thread_ref_frame(&s->last_frame, &s->current_frame);
1902	if (ret < 0)
1903	goto fail;
1904
1905	if (s->keyframe) {
1906	ff_thread_release_buffer(avctx, &s->golden_frame);
1907	ret = ff_thread_ref_frame(&s->golden_frame, &s->current_frame);
1908	}
1909
1910	fail:
1911	ff_thread_release_buffer(avctx, &s->current_frame);
1912	return ret;
1913	}
1914
1915	static int ref_frame(Vp3DecodeContext *s, ThreadFrame *dst, ThreadFrame *src)
1916	{
1917	ff_thread_release_buffer(s->avctx, dst);
1918	if (src->f->data[0])
1919	return ff_thread_ref_frame(dst, src);
1920	return 0;
1921	}
1922
1923	static int ref_frames(Vp3DecodeContext *dst, Vp3DecodeContext *src)
1924	{
1925	int ret;
1926	if ((ret = ref_frame(dst, &dst->current_frame, &src->current_frame)) < 0 ||
1927	(ret = ref_frame(dst, &dst->golden_frame, &src->golden_frame)) < 0 ||
1928	(ret = ref_frame(dst, &dst->last_frame, &src->last_frame)) < 0)
1929	return ret;
1930	return 0;
1931	}
1932
1933	#if HAVE_THREADS
1934	static int vp3_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
1935	{
1936	Vp3DecodeContext *s = dst->priv_data, *s1 = src->priv_data;
1937	int qps_changed = 0, i, err;
1938
1939	#define copy_fields(to, from, start_field, end_field) \
1940	memcpy(&to->start_field, &from->start_field, \
1941	(char *) &to->end_field - (char *) &to->start_field)
1942
1943	if (!s1->current_frame.f->data[0] ||
1944	s->width != s1->width || s->height != s1->height) {
1945	if (s != s1)
1946	ref_frames(s, s1);
1947	return -1;
1948	}
1949
1950	if (s != s1) {
1951	if (!s->current_frame.f)
1952	return AVERROR(ENOMEM);
1953	// init tables if the first frame hasn't been decoded
1954	if (!s->current_frame.f->data[0]) {
1955	int y_fragment_count, c_fragment_count;
1956	s->avctx = dst;
1957	err = allocate_tables(dst);
1958	if (err)
1959	return err;
1960	y_fragment_count = s->fragment_width[0] * s->fragment_height[0];
1961	c_fragment_count = s->fragment_width[1] * s->fragment_height[1];
1962	memcpy(s->motion_val[0], s1->motion_val[0],
1963	y_fragment_count * sizeof(*s->motion_val[0]));
1964	memcpy(s->motion_val[1], s1->motion_val[1],
1965	c_fragment_count * sizeof(*s->motion_val[1]));
1966	}
1967
1968	// copy previous frame data
1969	if ((err = ref_frames(s, s1)) < 0)
1970	return err;
1971
1972	s->keyframe = s1->keyframe;
1973
1974	// copy qscale data if necessary
1975	for (i = 0; i < 3; i++) {
1976	if (s->qps[i] != s1->qps[1]) {
1977	qps_changed = 1;
1978	memcpy(&s->qmat[i], &s1->qmat[i], sizeof(s->qmat[i]));
1979	}
1980	}
1981
1982	if (s->qps[0] != s1->qps[0])
1983	memcpy(&s->bounding_values_array, &s1->bounding_values_array,
1984	sizeof(s->bounding_values_array));
1985
1986	if (qps_changed)
1987	copy_fields(s, s1, qps, superblock_count);
1988	#undef copy_fields
1989	}
1990
1991	return update_frames(dst);
1992	}
1993	#endif
1994
1995	static int vp3_decode_frame(AVCodecContext *avctx,
1996	void *data, int *got_frame,
1997	AVPacket *avpkt)
1998	{
1999	const uint8_t *buf = avpkt->data;
2000	int buf_size = avpkt->size;
2001	Vp3DecodeContext *s = avctx->priv_data;
2002	GetBitContext gb;
2003	int i, ret;
2004
2005	if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)
2006	return ret;
2007
2008	#if CONFIG_THEORA_DECODER
2009	if (s->theora && get_bits1(&gb)) {
2010	int type = get_bits(&gb, 7);
2011	skip_bits_long(&gb, 6*8); /* "theora" */
2012
2013	if (s->avctx->active_thread_type&FF_THREAD_FRAME) {
2014	av_log(avctx, AV_LOG_ERROR, "midstream reconfiguration with multithreading is unsupported, try -threads 1\n");
2015	return AVERROR_PATCHWELCOME;
2016	}
2017	if (type == 0) {
2018	vp3_decode_end(avctx);
2019	ret = theora_decode_header(avctx, &gb);
2020
2021	if (ret >= 0)
2022	ret = vp3_decode_init(avctx);
2023	if (ret < 0) {
2024	vp3_decode_end(avctx);
2025	return ret;
2026	}
2027	return buf_size;
2028	} else if (type == 2) {
2029	vp3_decode_end(avctx);
2030	ret = theora_decode_tables(avctx, &gb);
2031	if (ret >= 0)
2032	ret = vp3_decode_init(avctx);
2033	if (ret < 0) {
2034	vp3_decode_end(avctx);
2035	return ret;
2036	}
2037	return buf_size;
2038	}
2039
2040	av_log(avctx, AV_LOG_ERROR,
2041	"Header packet passed to frame decoder, skipping\n");
2042	return -1;
2043	}
2044	#endif
2045
2046	s->keyframe = !get_bits1(&gb);
2047	if (!s->all_fragments) {
2048	av_log(avctx, AV_LOG_ERROR, "Data packet without prior valid headers\n");
2049	return -1;
2050	}
2051	if (!s->theora)
2052	skip_bits(&gb, 1);
2053	for (i = 0; i < 3; i++)
2054	s->last_qps[i] = s->qps[i];
2055
2056	s->nqps = 0;
2057	do {
2058	s->qps[s->nqps++] = get_bits(&gb, 6);
2059	} while (s->theora >= 0x030200 && s->nqps < 3 && get_bits1(&gb));
2060	for (i = s->nqps; i < 3; i++)
2061	s->qps[i] = -1;
2062
2063	if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2064	av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",
2065	s->keyframe ? "key" : "", avctx->frame_number + 1, s->qps[0]);
2066
2067	s->skip_loop_filter = !s->filter_limit_values[s->qps[0]] ||
2068	avctx->skip_loop_filter >= (s->keyframe ? AVDISCARD_ALL
2069	: AVDISCARD_NONKEY);
2070
2071	if (s->qps[0] != s->last_qps[0])
2072	init_loop_filter(s);
2073
2074	for (i = 0; i < s->nqps; i++)
2075	// reinit all dequantizers if the first one changed, because
2076	// the DC of the first quantizer must be used for all matrices
2077	if (s->qps[i] != s->last_qps[i] || s->qps[0] != s->last_qps[0])
2078	init_dequantizer(s, i);
2079
2080	if (avctx->skip_frame >= AVDISCARD_NONKEY && !s->keyframe)
2081	return buf_size;
2082
2083	s->current_frame.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I
2084	: AV_PICTURE_TYPE_P;
2085	s->current_frame.f->key_frame = s->keyframe;
2086	if (ff_thread_get_buffer(avctx, &s->current_frame, AV_GET_BUFFER_FLAG_REF) < 0)
2087	goto error;
2088
2089	if (!s->edge_emu_buffer)
2090	s->edge_emu_buffer = av_malloc(9 * FFABS(s->current_frame.f->linesize[0]));
2091
2092	if (s->keyframe) {
2093	if (!s->theora) {
2094	skip_bits(&gb, 4); /* width code */
2095	skip_bits(&gb, 4); /* height code */
2096	if (s->version) {
2097	s->version = get_bits(&gb, 5);
2098	if (avctx->frame_number == 0)
2099	av_log(s->avctx, AV_LOG_DEBUG,
2100	"VP version: %d\n", s->version);
2101	}
2102	}
2103	if (s->version || s->theora) {
2104	if (get_bits1(&gb))
2105	av_log(s->avctx, AV_LOG_ERROR,
2106	"Warning, unsupported keyframe coding type?!\n");
2107	skip_bits(&gb, 2); /* reserved? */
2108	}
2109	} else {
2110	if (!s->golden_frame.f->data[0]) {
2111	av_log(s->avctx, AV_LOG_WARNING,
2112	"vp3: first frame not a keyframe\n");
2113
2114	s->golden_frame.f->pict_type = AV_PICTURE_TYPE_I;
2115	if (ff_thread_get_buffer(avctx, &s->golden_frame,
2116	AV_GET_BUFFER_FLAG_REF) < 0)
2117	goto error;
2118	ff_thread_release_buffer(avctx, &s->last_frame);
2119	if ((ret = ff_thread_ref_frame(&s->last_frame,
2120	&s->golden_frame)) < 0)
2121	goto error;
2122	ff_thread_report_progress(&s->last_frame, INT_MAX, 0);
2123	}
2124	}
2125
2126	memset(s->all_fragments, 0, s->fragment_count * sizeof(Vp3Fragment));
2127	ff_thread_finish_setup(avctx);
2128
2129	if (unpack_superblocks(s, &gb)) {
2130	av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");
2131	goto error;
2132	}
2133	if (unpack_modes(s, &gb)) {
2134	av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");
2135	goto error;
2136	}
2137	if (unpack_vectors(s, &gb)) {
2138	av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");
2139	goto error;
2140	}
2141	if (unpack_block_qpis(s, &gb)) {
2142	av_log(s->avctx, AV_LOG_ERROR, "error in unpack_block_qpis\n");
2143	goto error;
2144	}
2145	if (unpack_dct_coeffs(s, &gb)) {
2146	av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");
2147	goto error;
2148	}
2149
2150	for (i = 0; i < 3; i++) {
2151	int height = s->height >> (i && s->chroma_y_shift);
2152	if (s->flipped_image)
2153	s->data_offset[i] = 0;
2154	else
2155	s->data_offset[i] = (height - 1) * s->current_frame.f->linesize[i];
2156	}
2157
2158	s->last_slice_end = 0;
2159	for (i = 0; i < s->c_superblock_height; i++)
2160	render_slice(s, i);
2161
2162	// filter the last row
2163	for (i = 0; i < 3; i++) {
2164	int row = (s->height >> (3 + (i && s->chroma_y_shift))) - 1;
2165	apply_loop_filter(s, i, row, row + 1);
2166	}
2167	vp3_draw_horiz_band(s, s->height);
2168
2169	/* output frame, offset as needed */
2170	if ((ret = av_frame_ref(data, s->current_frame.f)) < 0)
2171	return ret;
2172	for (i = 0; i < 3; i++) {
2173	AVFrame *dst = data;
2174	int off = (s->offset_x >> (i && s->chroma_y_shift)) +
2175	(s->offset_y >> (i && s->chroma_y_shift)) * dst->linesize[i];
2176	dst->data[i] += off;
2177	}
2178	*got_frame = 1;
2179
2180	if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME)) {
2181	ret = update_frames(avctx);
2182	if (ret < 0)
2183	return ret;
2184	}
2185
2186	return buf_size;
2187
2188	error:
2189	ff_thread_report_progress(&s->current_frame, INT_MAX, 0);
2190
2191	if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME))
2192	av_frame_unref(s->current_frame.f);
2193
2194	return -1;
2195	}
2196
2197	static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)
2198	{
2199	Vp3DecodeContext *s = avctx->priv_data;
2200
2201	if (get_bits1(gb)) {
2202	int token;
2203	if (s->entries >= 32) { /* overflow */
2204	av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2205	return -1;
2206	}
2207	token = get_bits(gb, 5);
2208	ff_dlog(avctx, "hti %d hbits %x token %d entry : %d size %d\n",
2209	s->hti, s->hbits, token, s->entries, s->huff_code_size);
2210	s->huffman_table[s->hti][token][0] = s->hbits;
2211	s->huffman_table[s->hti][token][1] = s->huff_code_size;
2212	s->entries++;
2213	} else {
2214	if (s->huff_code_size >= 32) { /* overflow */
2215	av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2216	return -1;
2217	}
2218	s->huff_code_size++;
2219	s->hbits <<= 1;
2220	if (read_huffman_tree(avctx, gb))
2221	return -1;
2222	s->hbits |= 1;
2223	if (read_huffman_tree(avctx, gb))
2224	return -1;
2225	s->hbits >>= 1;
2226	s->huff_code_size--;
2227	}
2228	return 0;
2229	}
2230
2231	#if HAVE_THREADS
2232	static int vp3_init_thread_copy(AVCodecContext *avctx)
2233	{
2234	Vp3DecodeContext *s = avctx->priv_data;
2235
2236	s->superblock_coding = NULL;
2237	s->all_fragments = NULL;
2238	s->coded_fragment_list[0] = NULL;
2239	s->dct_tokens_base = NULL;
2240	s->superblock_fragments = NULL;
2241	s->macroblock_coding = NULL;
2242	s->motion_val[0] = NULL;
2243	s->motion_val[1] = NULL;
2244	s->edge_emu_buffer = NULL;
2245
2246	return init_frames(s);
2247	}
2248	#endif
2249
2250	#if CONFIG_THEORA_DECODER
2251	static const enum AVPixelFormat theora_pix_fmts[4] = {
2252	AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P
2253	};
2254
2255	static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
2256	{
2257	Vp3DecodeContext *s = avctx->priv_data;
2258	int visible_width, visible_height, colorspace;
2259	uint8_t offset_x = 0, offset_y = 0;
2260	int ret;
2261	AVRational fps, aspect;
2262
2263	s->theora_header = 0;
2264	s->theora = get_bits_long(gb, 24);
2265	av_log(avctx, AV_LOG_DEBUG, "Theora bitstream version %X\n", s->theora);
2266
2267	/* 3.2.0 aka alpha3 has the same frame orientation as original vp3
2268	* but previous versions have the image flipped relative to vp3 */
2269	if (s->theora < 0x030200) {
2270	s->flipped_image = 1;
2271	av_log(avctx, AV_LOG_DEBUG,
2272	"Old (<alpha3) Theora bitstream, flipped image\n");
2273	}
2274
2275	visible_width =
2276	s->width = get_bits(gb, 16) << 4;
2277	visible_height =
2278	s->height = get_bits(gb, 16) << 4;
2279
2280	if (s->theora >= 0x030200) {
2281	visible_width = get_bits_long(gb, 24);
2282	visible_height = get_bits_long(gb, 24);
2283
2284	offset_x = get_bits(gb, 8); /* offset x */
2285	offset_y = get_bits(gb, 8); /* offset y, from bottom */
2286	}
2287
2288	/* sanity check */
2289	if (av_image_check_size(visible_width, visible_height, 0, avctx) < 0 ||
2290	visible_width + offset_x > s->width ||
2291	visible_height + offset_y > s->height) {
2292	av_log(avctx, AV_LOG_ERROR,
2293	"Invalid frame dimensions - w:%d h:%d x:%d y:%d (%dx%d).\n",
2294	visible_width, visible_height, offset_x, offset_y,
2295	s->width, s->height);
2296	return AVERROR_INVALIDDATA;
2297	}
2298
2299	fps.num = get_bits_long(gb, 32);
2300	fps.den = get_bits_long(gb, 32);
2301	if (fps.num && fps.den) {
2302	if (fps.num < 0 || fps.den < 0) {
2303	av_log(avctx, AV_LOG_ERROR, "Invalid framerate\n");
2304	return AVERROR_INVALIDDATA;
2305	}
2306	av_reduce(&avctx->framerate.den, &avctx->framerate.num,
2307	fps.den, fps.num, 1 << 30);
2308	}
2309
2310	aspect.num = get_bits_long(gb, 24);
2311	aspect.den = get_bits_long(gb, 24);
2312	if (aspect.num && aspect.den) {
2313	av_reduce(&avctx->sample_aspect_ratio.num,
2314	&avctx->sample_aspect_ratio.den,
2315	aspect.num, aspect.den, 1 << 30);
2316	ff_set_sar(avctx, avctx->sample_aspect_ratio);
2317	}
2318
2319	if (s->theora < 0x030200)
2320	skip_bits(gb, 5); /* keyframe frequency force */
2321	colorspace = get_bits(gb, 8);
2322	skip_bits(gb, 24); /* bitrate */
2323
2324	skip_bits(gb, 6); /* quality hint */
2325
2326	if (s->theora >= 0x030200) {
2327	skip_bits(gb, 5); /* keyframe frequency force */
2328	avctx->pix_fmt = theora_pix_fmts[get_bits(gb, 2)];
2329	if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
2330	av_log(avctx, AV_LOG_ERROR, "Invalid pixel format\n");
2331	return AVERROR_INVALIDDATA;
2332	}
2333	skip_bits(gb, 3); /* reserved */
2334	} else
2335	avctx->pix_fmt = AV_PIX_FMT_YUV420P;
2336
2337	ret = ff_set_dimensions(avctx, s->width, s->height);
2338	if (ret < 0)
2339	return ret;
2340	if (!(avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP)) {
2341	avctx->width = visible_width;
2342	avctx->height = visible_height;
2343	// translate offsets from theora axis ([0,0] lower left)
2344	// to normal axis ([0,0] upper left)
2345	s->offset_x = offset_x;
2346	s->offset_y = s->height - visible_height - offset_y;
2347
2348	if ((s->offset_x & 0x1F) && !(avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
2349	s->offset_x &= ~0x1F;
2350	if (!s->offset_x_warned) {
2351	s->offset_x_warned = 1;
2352	av_log(avctx, AV_LOG_WARNING, "Reducing offset_x from %d to %d"
2353	"chroma samples to preserve alignment.\n",
2354	offset_x, s->offset_x);
2355	}
2356	}
2357	}
2358
2359	if (colorspace == 1)
2360	avctx->color_primaries = AVCOL_PRI_BT470M;
2361	else if (colorspace == 2)
2362	avctx->color_primaries = AVCOL_PRI_BT470BG;
2363
2364	if (colorspace == 1 || colorspace == 2) {
2365	avctx->colorspace = AVCOL_SPC_BT470BG;
2366	avctx->color_trc = AVCOL_TRC_BT709;
2367	}
2368
2369	s->theora_header = 1;
2370	return 0;
2371	}
2372
2373	static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
2374	{
2375	Vp3DecodeContext *s = avctx->priv_data;
2376	int i, n, matrices, inter, plane;
2377
2378	if (!s->theora_header)
2379	return AVERROR_INVALIDDATA;
2380
2381	if (s->theora >= 0x030200) {
2382	n = get_bits(gb, 3);
2383	/* loop filter limit values table */
2384	if (n)
2385	for (i = 0; i < 64; i++)
2386	s->filter_limit_values[i] = get_bits(gb, n);
2387	}
2388
2389	if (s->theora >= 0x030200)
2390	n = get_bits(gb, 4) + 1;
2391	else
2392	n = 16;
2393	/* quality threshold table */
2394	for (i = 0; i < 64; i++)
2395	s->coded_ac_scale_factor[i] = get_bits(gb, n);
2396
2397	if (s->theora >= 0x030200)
2398	n = get_bits(gb, 4) + 1;
2399	else
2400	n = 16;
2401	/* dc scale factor table */
2402	for (i = 0; i < 64; i++)
2403	s->coded_dc_scale_factor[i] = get_bits(gb, n);
2404
2405	if (s->theora >= 0x030200)
2406	matrices = get_bits(gb, 9) + 1;
2407	else
2408	matrices = 3;
2409
2410	if (matrices > 384) {
2411	av_log(avctx, AV_LOG_ERROR, "invalid number of base matrixes\n");
2412	return -1;
2413	}
2414
2415	for (n = 0; n < matrices; n++)
2416	for (i = 0; i < 64; i++)
2417	s->base_matrix[n][i] = get_bits(gb, 8);
2418
2419	for (inter = 0; inter <= 1; inter++) {
2420	for (plane = 0; plane <= 2; plane++) {
2421	int newqr = 1;
2422	if (inter || plane > 0)
2423	newqr = get_bits1(gb);
2424	if (!newqr) {
2425	int qtj, plj;
2426	if (inter && get_bits1(gb)) {
2427	qtj = 0;
2428	plj = plane;
2429	} else {
2430	qtj = (3 * inter + plane - 1) / 3;
2431	plj = (plane + 2) % 3;
2432	}
2433	s->qr_count[inter][plane] = s->qr_count[qtj][plj];
2434	memcpy(s->qr_size[inter][plane], s->qr_size[qtj][plj],
2435	sizeof(s->qr_size[0][0]));
2436	memcpy(s->qr_base[inter][plane], s->qr_base[qtj][plj],
2437	sizeof(s->qr_base[0][0]));
2438	} else {
2439	int qri = 0;
2440	int qi = 0;
2441
2442	for (;;) {
2443	i = get_bits(gb, av_log2(matrices - 1) + 1);
2444	if (i >= matrices) {
2445	av_log(avctx, AV_LOG_ERROR,
2446	"invalid base matrix index\n");
2447	return -1;
2448	}
2449	s->qr_base[inter][plane][qri] = i;
2450	if (qi >= 63)
2451	break;
2452	i = get_bits(gb, av_log2(63 - qi) + 1) + 1;
2453	s->qr_size[inter][plane][qri++] = i;
2454	qi += i;
2455	}
2456
2457	if (qi > 63) {
2458	av_log(avctx, AV_LOG_ERROR, "invalid qi %d > 63\n", qi);
2459	return -1;
2460	}
2461	s->qr_count[inter][plane] = qri;
2462	}
2463	}
2464	}
2465
2466	/* Huffman tables */
2467	for (s->hti = 0; s->hti < 80; s->hti++) {
2468	s->entries = 0;
2469	s->huff_code_size = 1;
2470	if (!get_bits1(gb)) {
2471	s->hbits = 0;
2472	if (read_huffman_tree(avctx, gb))
2473	return -1;
2474	s->hbits = 1;
2475	if (read_huffman_tree(avctx, gb))
2476	return -1;
2477	}
2478	}
2479
2480	s->theora_tables = 1;
2481
2482	return 0;
2483	}
2484
2485	static av_cold int theora_decode_init(AVCodecContext *avctx)
2486	{
2487	Vp3DecodeContext *s = avctx->priv_data;
2488	GetBitContext gb;
2489	int ptype;
2490	const uint8_t *header_start[3];
2491	int header_len[3];
2492	int i;
2493	int ret;
2494
2495	avctx->pix_fmt = AV_PIX_FMT_YUV420P;
2496
2497	s->theora = 1;
2498
2499	if (!avctx->extradata_size) {
2500	av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n");
2501	return -1;
2502	}
2503
2504	if (avpriv_split_xiph_headers(avctx->extradata, avctx->extradata_size,
2505	42, header_start, header_len) < 0) {
2506	av_log(avctx, AV_LOG_ERROR, "Corrupt extradata\n");
2507	return -1;
2508	}
2509
2510	for (i = 0; i < 3; i++) {
2511	if (header_len[i] <= 0)
2512	continue;
2513	ret = init_get_bits8(&gb, header_start[i], header_len[i]);
2514	if (ret < 0)
2515	return ret;
2516
2517	ptype = get_bits(&gb, 8);
2518
2519	if (!(ptype & 0x80)) {
2520	av_log(avctx, AV_LOG_ERROR, "Invalid extradata!\n");
2521	// return -1;
2522	}
2523
2524	// FIXME: Check for this as well.
2525	skip_bits_long(&gb, 6 * 8); /* "theora" */
2526
2527	switch (ptype) {
2528	case 0x80:
2529	if (theora_decode_header(avctx, &gb) < 0)
2530	return -1;
2531	break;
2532	case 0x81:
2533	// FIXME: is this needed? it breaks sometimes
2534	// theora_decode_comments(avctx, gb);
2535	break;
2536	case 0x82:
2537	if (theora_decode_tables(avctx, &gb))
2538	return -1;
2539	break;
2540	default:
2541	av_log(avctx, AV_LOG_ERROR,
2542	"Unknown Theora config packet: %d\n", ptype & ~0x80);
2543	break;
2544	}
2545	if (ptype != 0x81 && 8 * header_len[i] != get_bits_count(&gb))
2546	av_log(avctx, AV_LOG_WARNING,
2547	"%d bits left in packet %X\n",
2548	8 * header_len[i] - get_bits_count(&gb), ptype);
2549	if (s->theora < 0x030200)
2550	break;
2551	}
2552
2553	return vp3_decode_init(avctx);
2554	}
2555
2556	AVCodec ff_theora_decoder = {
2557	.name = "theora",
2558	.long_name = NULL_IF_CONFIG_SMALL("Theora"),
2559	.type = AVMEDIA_TYPE_VIDEO,
2560	.id = AV_CODEC_ID_THEORA,
2561	.priv_data_size = sizeof(Vp3DecodeContext),
2562	.init = theora_decode_init,
2563	.close = vp3_decode_end,
2564	.decode = vp3_decode_frame,
2565	.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
2566	AV_CODEC_CAP_FRAME_THREADS,
2567	.flush = vp3_decode_flush,
2568	.init_thread_copy = ONLY_IF_THREADS_ENABLED(vp3_init_thread_copy),
2569	.update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context)
2570	};
2571	#endif
2572
2573	AVCodec ff_vp3_decoder = {
2574	.name = "vp3",
2575	.long_name = NULL_IF_CONFIG_SMALL("On2 VP3"),
2576	.type = AVMEDIA_TYPE_VIDEO,
2577	.id = AV_CODEC_ID_VP3,
2578	.priv_data_size = sizeof(Vp3DecodeContext),
2579	.init = vp3_decode_init,
2580	.close = vp3_decode_end,
2581	.decode = vp3_decode_frame,
2582	.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
2583	AV_CODEC_CAP_FRAME_THREADS,
2584	.flush = vp3_decode_flush,
2585	.init_thread_copy = ONLY_IF_THREADS_ENABLED(vp3_init_thread_copy),
2586	.update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context),
2587	};
2588