WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/libavcodec/h264_cavlc.c

Rev	Author	Line No.	Line
4349	Serge	1	/*
		2	* H.26L/H.264/AVC/JVT/14496-10/... cavlc bitstream decoding
		3	* Copyright (c) 2003 Michael Niedermayer
		4	*
		5	* This file is part of FFmpeg.
		6	*
		7	* FFmpeg is free software; you can redistribute it and/or
		8	* modify it under the terms of the GNU Lesser General Public
		9	* License as published by the Free Software Foundation; either
		10	* version 2.1 of the License, or (at your option) any later version.
		11	*
		12	* FFmpeg is distributed in the hope that it will be useful,
		13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		15	* Lesser General Public License for more details.
		16	*
		17	* You should have received a copy of the GNU Lesser General Public
		18	* License along with FFmpeg; if not, write to the Free Software
		19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		20	*/
		21
		22	/**
		23	* @file
		24	* H.264 / AVC / MPEG4 part10 cavlc bitstream decoding.
		25	* @author Michael Niedermayer
		26	*/
		27
		28	#define CABAC(h) 0
		29	#define UNCHECKED_BITSTREAM_READER 1
		30
		31	#include "internal.h"
		32	#include "avcodec.h"
		33	#include "mpegvideo.h"
		34	#include "h264.h"
		35	#include "h264data.h" // FIXME FIXME FIXME
		36	#include "h264_mvpred.h"
		37	#include "golomb.h"
		38	#include "libavutil/avassert.h"
		39
		40
		41	static const uint8_t golomb_to_inter_cbp_gray[16]={
		42	0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
		43	};
		44
		45	static const uint8_t golomb_to_intra4x4_cbp_gray[16]={
		46	15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
		47	};
		48
		49	static const uint8_t chroma_dc_coeff_token_len[4*5]={
		50	2, 0, 0, 0,
		51	6, 1, 0, 0,
		52	6, 6, 3, 0,
		53	6, 7, 7, 6,
		54	6, 8, 8, 7,
		55	};
		56
		57	static const uint8_t chroma_dc_coeff_token_bits[4*5]={
		58	1, 0, 0, 0,
		59	7, 1, 0, 0,
		60	4, 6, 1, 0,
		61	3, 3, 2, 5,
		62	2, 3, 2, 0,
		63	};
		64
		65	static const uint8_t chroma422_dc_coeff_token_len[4*9]={
		66	1, 0, 0, 0,
		67	7, 2, 0, 0,
		68	7, 7, 3, 0,
		69	9, 7, 7, 5,
		70	9, 9, 7, 6,
		71	10, 10, 9, 7,
		72	11, 11, 10, 7,
		73	12, 12, 11, 10,
		74	13, 12, 12, 11,
		75	};
		76
		77	static const uint8_t chroma422_dc_coeff_token_bits[4*9]={
		78	1, 0, 0, 0,
		79	15, 1, 0, 0,
		80	14, 13, 1, 0,
		81	7, 12, 11, 1,
		82	6, 5, 10, 1,
		83	7, 6, 4, 9,
		84	7, 6, 5, 8,
		85	7, 6, 5, 4,
		86	7, 5, 4, 4,
		87	};
		88
		89	static const uint8_t coeff_token_len[4][4*17]={
		90	{
		91	1, 0, 0, 0,
		92	6, 2, 0, 0, 8, 6, 3, 0, 9, 8, 7, 5, 10, 9, 8, 6,
		93	11,10, 9, 7, 13,11,10, 8, 13,13,11, 9, 13,13,13,10,
		94	14,14,13,11, 14,14,14,13, 15,15,14,14, 15,15,15,14,
		95	16,15,15,15, 16,16,16,15, 16,16,16,16, 16,16,16,16,
		96	},
		97	{
		98	2, 0, 0, 0,
		99	6, 2, 0, 0, 6, 5, 3, 0, 7, 6, 6, 4, 8, 6, 6, 4,
		100	8, 7, 7, 5, 9, 8, 8, 6, 11, 9, 9, 6, 11,11,11, 7,
		101	12,11,11, 9, 12,12,12,11, 12,12,12,11, 13,13,13,12,
		102	13,13,13,13, 13,14,13,13, 14,14,14,13, 14,14,14,14,
		103	},
		104	{
		105	4, 0, 0, 0,
		106	6, 4, 0, 0, 6, 5, 4, 0, 6, 5, 5, 4, 7, 5, 5, 4,
		107	7, 5, 5, 4, 7, 6, 6, 4, 7, 6, 6, 4, 8, 7, 7, 5,
		108	8, 8, 7, 6, 9, 8, 8, 7, 9, 9, 8, 8, 9, 9, 9, 8,
		109	10, 9, 9, 9, 10,10,10,10, 10,10,10,10, 10,10,10,10,
		110	},
		111	{
		112	6, 0, 0, 0,
		113	6, 6, 0, 0, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6,
		114	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
		115	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
		116	6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
		117	}
		118	};
		119
		120	static const uint8_t coeff_token_bits[4][4*17]={
		121	{
		122	1, 0, 0, 0,
		123	5, 1, 0, 0, 7, 4, 1, 0, 7, 6, 5, 3, 7, 6, 5, 3,
		124	7, 6, 5, 4, 15, 6, 5, 4, 11,14, 5, 4, 8,10,13, 4,
		125	15,14, 9, 4, 11,10,13,12, 15,14, 9,12, 11,10,13, 8,
		126	15, 1, 9,12, 11,14,13, 8, 7,10, 9,12, 4, 6, 5, 8,
		127	},
		128	{
		129	3, 0, 0, 0,
		130	11, 2, 0, 0, 7, 7, 3, 0, 7,10, 9, 5, 7, 6, 5, 4,
		131	4, 6, 5, 6, 7, 6, 5, 8, 15, 6, 5, 4, 11,14,13, 4,
		132	15,10, 9, 4, 11,14,13,12, 8,10, 9, 8, 15,14,13,12,
		133	11,10, 9,12, 7,11, 6, 8, 9, 8,10, 1, 7, 6, 5, 4,
		134	},
		135	{
		136	15, 0, 0, 0,
		137	15,14, 0, 0, 11,15,13, 0, 8,12,14,12, 15,10,11,11,
		138	11, 8, 9,10, 9,14,13, 9, 8,10, 9, 8, 15,14,13,13,
		139	11,14,10,12, 15,10,13,12, 11,14, 9,12, 8,10,13, 8,
		140	13, 7, 9,12, 9,12,11,10, 5, 8, 7, 6, 1, 4, 3, 2,
		141	},
		142	{
		143	3, 0, 0, 0,
		144	0, 1, 0, 0, 4, 5, 6, 0, 8, 9,10,11, 12,13,14,15,
		145	16,17,18,19, 20,21,22,23, 24,25,26,27, 28,29,30,31,
		146	32,33,34,35, 36,37,38,39, 40,41,42,43, 44,45,46,47,
		147	48,49,50,51, 52,53,54,55, 56,57,58,59, 60,61,62,63,
		148	}
		149	};
		150
		151	static const uint8_t total_zeros_len[16][16]= {
		152	{1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
		153	{3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
		154	{4,3,3,3,4,4,3,3,4,5,5,6,5,6},
		155	{5,3,4,4,3,3,3,4,3,4,5,5,5},
		156	{4,4,4,3,3,3,3,3,4,5,4,5},
		157	{6,5,3,3,3,3,3,3,4,3,6},
		158	{6,5,3,3,3,2,3,4,3,6},
		159	{6,4,5,3,2,2,3,3,6},
		160	{6,6,4,2,2,3,2,5},
		161	{5,5,3,2,2,2,4},
		162	{4,4,3,3,1,3},
		163	{4,4,2,1,3},
		164	{3,3,1,2},
		165	{2,2,1},
		166	{1,1},
		167	};
		168
		169	static const uint8_t total_zeros_bits[16][16]= {
		170	{1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
		171	{7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
		172	{5,7,6,5,4,3,4,3,2,3,2,1,1,0},
		173	{3,7,5,4,6,5,4,3,3,2,2,1,0},
		174	{5,4,3,7,6,5,4,3,2,1,1,0},
		175	{1,1,7,6,5,4,3,2,1,1,0},
		176	{1,1,5,4,3,3,2,1,1,0},
		177	{1,1,1,3,3,2,2,1,0},
		178	{1,0,1,3,2,1,1,1},
		179	{1,0,1,3,2,1,1},
		180	{0,1,1,2,1,3},
		181	{0,1,1,1,1},
		182	{0,1,1,1},
		183	{0,1,1},
		184	{0,1},
		185	};
		186
		187	static const uint8_t chroma_dc_total_zeros_len[3][4]= {
		188	{ 1, 2, 3, 3,},
		189	{ 1, 2, 2, 0,},
		190	{ 1, 1, 0, 0,},
		191	};
		192
		193	static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
		194	{ 1, 1, 1, 0,},
		195	{ 1, 1, 0, 0,},
		196	{ 1, 0, 0, 0,},
		197	};
		198
		199	static const uint8_t chroma422_dc_total_zeros_len[7][8]= {
		200	{ 1, 3, 3, 4, 4, 4, 5, 5 },
		201	{ 3, 2, 3, 3, 3, 3, 3 },
		202	{ 3, 3, 2, 2, 3, 3 },
		203	{ 3, 2, 2, 2, 3 },
		204	{ 2, 2, 2, 2 },
		205	{ 2, 2, 1 },
		206	{ 1, 1 },
		207	};
		208
		209	static const uint8_t chroma422_dc_total_zeros_bits[7][8]= {
		210	{ 1, 2, 3, 2, 3, 1, 1, 0 },
		211	{ 0, 1, 1, 4, 5, 6, 7 },
		212	{ 0, 1, 1, 2, 6, 7 },
		213	{ 6, 0, 1, 2, 7 },
		214	{ 0, 1, 2, 3 },
		215	{ 0, 1, 1 },
		216	{ 0, 1 },
		217	};
		218
		219	static const uint8_t run_len[7][16]={
		220	{1,1},
		221	{1,2,2},
		222	{2,2,2,2},
		223	{2,2,2,3,3},
		224	{2,2,3,3,3,3},
		225	{2,3,3,3,3,3,3},
		226	{3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
		227	};
		228
		229	static const uint8_t run_bits[7][16]={
		230	{1,0},
		231	{1,1,0},
		232	{3,2,1,0},
		233	{3,2,1,1,0},
		234	{3,2,3,2,1,0},
		235	{3,0,1,3,2,5,4},
		236	{7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
		237	};
		238
		239	static VLC coeff_token_vlc[4];
		240	static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
		241	static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
		242
		243	static VLC chroma_dc_coeff_token_vlc;
		244	static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
		245	static const int chroma_dc_coeff_token_vlc_table_size = 256;
		246
		247	static VLC chroma422_dc_coeff_token_vlc;
		248	static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2];
		249	static const int chroma422_dc_coeff_token_vlc_table_size = 8192;
		250
		251	static VLC total_zeros_vlc[15];
		252	static VLC_TYPE total_zeros_vlc_tables[15][512][2];
		253	static const int total_zeros_vlc_tables_size = 512;
		254
		255	static VLC chroma_dc_total_zeros_vlc[3];
		256	static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
		257	static const int chroma_dc_total_zeros_vlc_tables_size = 8;
		258
		259	static VLC chroma422_dc_total_zeros_vlc[7];
		260	static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2];
		261	static const int chroma422_dc_total_zeros_vlc_tables_size = 32;
		262
		263	static VLC run_vlc[6];
		264	static VLC_TYPE run_vlc_tables[6][8][2];
		265	static const int run_vlc_tables_size = 8;
		266
		267	static VLC run7_vlc;
		268	static VLC_TYPE run7_vlc_table[96][2];
		269	static const int run7_vlc_table_size = 96;
		270
		271	#define LEVEL_TAB_BITS 8
		272	static int8_t cavlc_level_tab[7][1<
		273
		274	#define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
		275	#define CHROMA422_DC_COEFF_TOKEN_VLC_BITS 13
		276	#define COEFF_TOKEN_VLC_BITS 8
		277	#define TOTAL_ZEROS_VLC_BITS 9
		278	#define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
		279	#define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS 5
		280	#define RUN_VLC_BITS 3
		281	#define RUN7_VLC_BITS 6
		282
		283	/**
		284	* Get the predicted number of non-zero coefficients.
		285	* @param n block index
		286	*/
		287	static inline int pred_non_zero_count(H264Context *h, int n){
		288	const int index8= scan8[n];
		289	const int left= h->non_zero_count_cache[index8 - 1];
		290	const int top = h->non_zero_count_cache[index8 - 8];
		291	int i= left + top;
		292
		293	if(i<64) i= (i+1)>>1;
		294
		295	tprintf(h->avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
		296
		297	return i&31;
		298	}
		299
		300	static av_cold void init_cavlc_level_tab(void){
		301	int suffix_length;
		302	unsigned int i;
		303
		304	for(suffix_length=0; suffix_length<7; suffix_length++){
		305	for(i=0; i<(1<
		306	int prefix= LEVEL_TAB_BITS - av_log2(2*i);
		307
		308	if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
		309	int level_code = (prefix << suffix_length) +
		310	(i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
		311	int mask = -(level_code&1);
		312	level_code = (((2 + level_code) >> 1) ^ mask) - mask;
		313	cavlc_level_tab[suffix_length][i][0]= level_code;
		314	cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
		315	}else if(prefix + 1 <= LEVEL_TAB_BITS){
		316	cavlc_level_tab[suffix_length][i][0]= prefix+100;
		317	cavlc_level_tab[suffix_length][i][1]= prefix + 1;
		318	}else{
		319	cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
		320	cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
		321	}
		322	}
		323	}
		324	}
		325
		326	av_cold void ff_h264_decode_init_vlc(void){
		327	static int done = 0;
		328
		329	if (!done) {
		330	int i;
		331	int offset;
		332	done = 1;
		333
		334	chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
		335	chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
		336	init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
		337	&chroma_dc_coeff_token_len [0], 1, 1,
		338	&chroma_dc_coeff_token_bits[0], 1, 1,
		339	INIT_VLC_USE_NEW_STATIC);
		340
		341	chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
		342	chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
		343	init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
		344	&chroma422_dc_coeff_token_len [0], 1, 1,
		345	&chroma422_dc_coeff_token_bits[0], 1, 1,
		346	INIT_VLC_USE_NEW_STATIC);
		347
		348	offset = 0;
		349	for(i=0; i<4; i++){
		350	coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
		351	coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
		352	init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
		353	&coeff_token_len [i][0], 1, 1,
		354	&coeff_token_bits[i][0], 1, 1,
		355	INIT_VLC_USE_NEW_STATIC);
		356	offset += coeff_token_vlc_tables_size[i];
		357	}
		358	/*
		359	* This is a one time safety check to make sure that
		360	* the packed static coeff_token_vlc table sizes
		361	* were initialized correctly.
		362	*/
		363	av_assert0(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
		364
		365	for(i=0; i<3; i++){
		366	chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
		367	chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
		368	init_vlc(&chroma_dc_total_zeros_vlc[i],
		369	CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
		370	&chroma_dc_total_zeros_len [i][0], 1, 1,
		371	&chroma_dc_total_zeros_bits[i][0], 1, 1,
		372	INIT_VLC_USE_NEW_STATIC);
		373	}
		374
		375	for(i=0; i<7; i++){
		376	chroma422_dc_total_zeros_vlc[i].table = chroma422_dc_total_zeros_vlc_tables[i];
		377	chroma422_dc_total_zeros_vlc[i].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
		378	init_vlc(&chroma422_dc_total_zeros_vlc[i],
		379	CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
		380	&chroma422_dc_total_zeros_len [i][0], 1, 1,
		381	&chroma422_dc_total_zeros_bits[i][0], 1, 1,
		382	INIT_VLC_USE_NEW_STATIC);
		383	}
		384
		385	for(i=0; i<15; i++){
		386	total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
		387	total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
		388	init_vlc(&total_zeros_vlc[i],
		389	TOTAL_ZEROS_VLC_BITS, 16,
		390	&total_zeros_len [i][0], 1, 1,
		391	&total_zeros_bits[i][0], 1, 1,
		392	INIT_VLC_USE_NEW_STATIC);
		393	}
		394
		395	for(i=0; i<6; i++){
		396	run_vlc[i].table = run_vlc_tables[i];
		397	run_vlc[i].table_allocated = run_vlc_tables_size;
		398	init_vlc(&run_vlc[i],
		399	RUN_VLC_BITS, 7,
		400	&run_len [i][0], 1, 1,
		401	&run_bits[i][0], 1, 1,
		402	INIT_VLC_USE_NEW_STATIC);
		403	}
		404	run7_vlc.table = run7_vlc_table,
		405	run7_vlc.table_allocated = run7_vlc_table_size;
		406	init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
		407	&run_len [6][0], 1, 1,
		408	&run_bits[6][0], 1, 1,
		409	INIT_VLC_USE_NEW_STATIC);
		410
		411	init_cavlc_level_tab();
		412	}
		413	}
		414
		415	/**
		416	*
		417	*/
		418	static inline int get_level_prefix(GetBitContext *gb){
		419	unsigned int buf;
		420	int log;
		421
		422	OPEN_READER(re, gb);
		423	UPDATE_CACHE(re, gb);
		424	buf=GET_CACHE(re, gb);
		425
		426	log= 32 - av_log2(buf);
		427	#ifdef TRACE
		428	print_bin(buf>>(32-log), log);
		429	av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__);
		430	#endif
		431
		432	LAST_SKIP_BITS(re, gb, log);
		433	CLOSE_READER(re, gb);
		434
		435	return log-1;
		436	}
		437
		438	/**
		439	* Decode a residual block.
		440	* @param n block index
		441	* @param scantable scantable
		442	* @param max_coeff number of coefficients in the block
		443	* @return <0 if an error occurred
		444	*/
		445	static int decode_residual(H264Context h, GetBitContext gb, int16_t block, int n, const uint8_t scantable, const uint32_t *qmul, int max_coeff){
		446	static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};
		447	int level[16];
		448	int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
		449
		450	//FIXME put trailing_onex into the context
		451
		452	if(max_coeff <= 8){
		453	if (max_coeff == 4)
		454	coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
		455	else
		456	coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
		457	total_coeff= coeff_token>>2;
		458	}else{
		459	if(n >= LUMA_DC_BLOCK_INDEX){
		460	total_coeff= pred_non_zero_count(h, (n - LUMA_DC_BLOCK_INDEX)*16);
		461	coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
		462	total_coeff= coeff_token>>2;
		463	}else{
		464	total_coeff= pred_non_zero_count(h, n);
		465	coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
		466	total_coeff= coeff_token>>2;
		467	}
		468	}
		469	h->non_zero_count_cache[ scan8[n] ]= total_coeff;
		470
		471	//FIXME set last_non_zero?
		472
		473	if(total_coeff==0)
		474	return 0;
		475	if(total_coeff > (unsigned)max_coeff) {
		476	av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", h->mb_x, h->mb_y, total_coeff);
		477	return -1;
		478	}
		479
		480	trailing_ones= coeff_token&3;
		481	tprintf(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
		482	av_assert2(total_coeff<=16);
		483
		484	i = show_bits(gb, 3);
		485	skip_bits(gb, trailing_ones);
		486	level[0] = 1-((i&4)>>1);
		487	level[1] = 1-((i&2) );
		488	level[2] = 1-((i&1)<<1);
		489
		490	if(trailing_ones
		491	int mask, prefix;
		492	int suffix_length = total_coeff > 10 & trailing_ones < 3;
		493	int bitsi= show_bits(gb, LEVEL_TAB_BITS);
		494	int level_code= cavlc_level_tab[suffix_length][bitsi][0];
		495
		496	skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
		497	if(level_code >= 100){
		498	prefix= level_code - 100;
		499	if(prefix == LEVEL_TAB_BITS)
		500	prefix += get_level_prefix(gb);
		501
		502	//first coefficient has suffix_length equal to 0 or 1
		503	if(prefix<14){ //FIXME try to build a large unified VLC table for all this
		504	if(suffix_length)
		505	level_code= (prefix<<1) + get_bits1(gb); //part
		506	else
		507	level_code= prefix; //part
		508	}else if(prefix==14){
		509	if(suffix_length)
		510	level_code= (prefix<<1) + get_bits1(gb); //part
		511	else
		512	level_code= prefix + get_bits(gb, 4); //part
		513	}else{
		514	level_code= 30;
		515	if(prefix>=16){
		516	if(prefix > 25+3){
		517	av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
		518	return -1;
		519	}
		520	level_code += (1<<(prefix-3))-4096;
		521	}
		522	level_code += get_bits(gb, prefix-3); //part
		523	}
		524
		525	if(trailing_ones < 3) level_code += 2;
		526
		527	suffix_length = 2;
		528	mask= -(level_code&1);
		529	level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
		530	}else{
		531	level_code += ((level_code>>31)\|1) & -(trailing_ones < 3);
		532
		533	suffix_length = 1 + (level_code + 3U > 6U);
		534	level[trailing_ones]= level_code;
		535	}
		536
		537	//remaining coefficients have suffix_length > 0
		538	for(i=trailing_ones+1;i
		539	static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
		540	int bitsi= show_bits(gb, LEVEL_TAB_BITS);
		541	level_code= cavlc_level_tab[suffix_length][bitsi][0];
		542
		543	skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
		544	if(level_code >= 100){
		545	prefix= level_code - 100;
		546	if(prefix == LEVEL_TAB_BITS){
		547	prefix += get_level_prefix(gb);
		548	}
		549	if(prefix<15){
		550	level_code = (prefix<
		551	}else{
		552	level_code = 15<
		553	if (prefix>=16) {
		554	if(prefix > 25+3){
		555	av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
		556	return AVERROR_INVALIDDATA;
		557	}
		558	level_code += (1<<(prefix-3))-4096;
		559	}
		560	level_code += get_bits(gb, prefix-3);
		561	}
		562	mask= -(level_code&1);
		563	level_code= (((2+level_code)>>1) ^ mask) - mask;
		564	}
		565	level[i]= level_code;
		566	suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
		567	}
		568	}
		569
		570	if(total_coeff == max_coeff)
		571	zeros_left=0;
		572	else{
		573	if (max_coeff <= 8) {
		574	if (max_coeff == 4)
		575	zeros_left = get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[total_coeff].table,
		576	CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
		577	else
		578	zeros_left = get_vlc2(gb, (chroma422_dc_total_zeros_vlc-1)[total_coeff].table,
		579	CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
		580	} else {
		581	zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
		582	}
		583	}
		584
		585	#define STORE_BLOCK(type) \
		586	scantable += zeros_left + total_coeff - 1; \
		587	if(n >= LUMA_DC_BLOCK_INDEX){ \
		588	((type)block)[scantable] = level[0]; \
		589	for(i=1;i 0;i++) { \
		590	if(zeros_left < 7) \
		591	run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
		592	else \
		593	run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
		594	zeros_left -= run_before; \
		595	scantable -= 1 + run_before; \
		596	((type)block)[scantable]= level[i]; \
		597	} \
		598	for(;i
		599	scantable--; \
		600	((type)block)[scantable]= level[i]; \
		601	} \
		602	}else{ \
		603	((type)block)[scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
		604	for(i=1;i 0;i++) { \
		605	if(zeros_left < 7) \
		606	run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
		607	else \
		608	run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
		609	zeros_left -= run_before; \
		610	scantable -= 1 + run_before; \
		611	((type)block)[scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
		612	} \
		613	for(;i
		614	scantable--; \
		615	((type)block)[scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
		616	} \
		617	}
		618
		619	if (h->pixel_shift) {
		620	STORE_BLOCK(int32_t)
		621	} else {
		622	STORE_BLOCK(int16_t)
		623	}
		624
		625	if(zeros_left<0){
		626	av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", h->mb_x, h->mb_y);
		627	return -1;
		628	}
		629
		630	return 0;
		631	}
		632
		633	static av_always_inline int decode_luma_residual(H264Context h, GetBitContext gb, const uint8_t scan, const uint8_t scan8x8, int pixel_shift, int mb_type, int cbp, int p){
		634	int i4x4, i8x8;
		635	int qscale = p == 0 ? h->qscale : h->chroma_qp[p-1];
		636	if(IS_INTRA16x16(mb_type)){
		637	AV_ZERO128(h->mb_luma_dc[p]+0);
		638	AV_ZERO128(h->mb_luma_dc[p]+8);
		639	AV_ZERO128(h->mb_luma_dc[p]+16);
		640	AV_ZERO128(h->mb_luma_dc[p]+24);
		641	if( decode_residual(h, h->intra_gb_ptr, h->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX+p, scan, NULL, 16) < 0){
		642	return -1; //FIXME continue if partitioned and other return -1 too
		643	}
		644
		645	av_assert2((cbp&15) == 0 \|\| (cbp&15) == 15);
		646
		647	if(cbp&15){
		648	for(i8x8=0; i8x8<4; i8x8++){
		649	for(i4x4=0; i4x4<4; i4x4++){
		650	const int index= i4x4 + 4i8x8 + p16;
		651	if( decode_residual(h, h->intra_gb_ptr, h->mb + (16*index << pixel_shift),
		652	index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
		653	return -1;
		654	}
		655	}
		656	}
		657	return 0xf;
		658	}else{
		659	fill_rectangle(&h->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
		660	return 0;
		661	}
		662	}else{
		663	int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
		664	/* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
		665	int new_cbp = 0;
		666	for(i8x8=0; i8x8<4; i8x8++){
		667	if(cbp & (1<
		668	if(IS_8x8DCT(mb_type)){
		669	int16_t buf = &h->mb[64i8x8+256*p << pixel_shift];
		670	uint8_t *nnz;
		671	for(i4x4=0; i4x4<4; i4x4++){
		672	const int index= i4x4 + 4i8x8 + p16;
		673	if( decode_residual(h, gb, buf, index, scan8x8+16*i4x4,
		674	h->dequant8_coeff[cqm][qscale], 16) < 0 )
		675	return -1;
		676	}
		677	nnz= &h->non_zero_count_cache[ scan8[4i8x8+p16] ];
		678	nnz[0] += nnz[1] + nnz[8] + nnz[9];
		679	new_cbp \|= !!nnz[0] << i8x8;
		680	}else{
		681	for(i4x4=0; i4x4<4; i4x4++){
		682	const int index= i4x4 + 4i8x8 + p16;
		683	if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index,
		684	scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
		685	return -1;
		686	}
		687	new_cbp \|= h->non_zero_count_cache[ scan8[index] ] << i8x8;
		688	}
		689	}
		690	}else{
		691	uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4i8x8+p16] ];
		692	nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
		693	}
		694	}
		695	return new_cbp;
		696	}
		697	}
		698
		699	int ff_h264_decode_mb_cavlc(H264Context *h){
		700	int mb_xy;
		701	int partition_count;
		702	unsigned int mb_type, cbp;
		703	int dct8x8_allowed= h->pps.transform_8x8_mode;
		704	int decode_chroma = h->sps.chroma_format_idc == 1 \|\| h->sps.chroma_format_idc == 2;
		705	const int pixel_shift = h->pixel_shift;
		706	unsigned local_ref_count[2];
		707
		708	mb_xy = h->mb_xy = h->mb_x + h->mb_y*h->mb_stride;
		709
		710	tprintf(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, h->mb_x, h->mb_y);
		711	cbp = 0; /* avoid warning. FIXME: find a solution without slowing
		712	down the code */
		713	if(h->slice_type_nos != AV_PICTURE_TYPE_I){
		714	if(h->mb_skip_run==-1)
		715	h->mb_skip_run= get_ue_golomb_long(&h->gb);
		716
		717	if (h->mb_skip_run--) {
		718	if(FRAME_MBAFF(h) && (h->mb_y&1) == 0){
		719	if(h->mb_skip_run==0)
		720	h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&h->gb);
		721	}
		722	decode_mb_skip(h);
		723	return 0;
		724	}
		725	}
		726	if (FRAME_MBAFF(h)) {
		727	if( (h->mb_y&1) == 0 )
		728	h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&h->gb);
		729	}
		730
		731	h->prev_mb_skipped= 0;
		732
		733	mb_type= get_ue_golomb(&h->gb);
		734	if(h->slice_type_nos == AV_PICTURE_TYPE_B){
		735	if(mb_type < 23){
		736	partition_count= b_mb_type_info[mb_type].partition_count;
		737	mb_type= b_mb_type_info[mb_type].type;
		738	}else{
		739	mb_type -= 23;
		740	goto decode_intra_mb;
		741	}
		742	}else if(h->slice_type_nos == AV_PICTURE_TYPE_P){
		743	if(mb_type < 5){
		744	partition_count= p_mb_type_info[mb_type].partition_count;
		745	mb_type= p_mb_type_info[mb_type].type;
		746	}else{
		747	mb_type -= 5;
		748	goto decode_intra_mb;
		749	}
		750	}else{
		751	av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_I);
		752	if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
		753	mb_type--;
		754	decode_intra_mb:
		755	if(mb_type > 25){
		756	av_log(h->avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_picture_type_char(h->slice_type), h->mb_x, h->mb_y);
		757	return -1;
		758	}
		759	partition_count=0;
		760	cbp= i_mb_type_info[mb_type].cbp;
		761	h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
		762	mb_type= i_mb_type_info[mb_type].type;
		763	}
		764
		765	if(MB_FIELD(h))
		766	mb_type \|= MB_TYPE_INTERLACED;
		767
		768	h->slice_table[ mb_xy ]= h->slice_num;
		769
		770	if(IS_INTRA_PCM(mb_type)){
		771	const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
		772	h->sps.bit_depth_luma;
		773
		774	// We assume these blocks are very rare so we do not optimize it.
		775	h->intra_pcm_ptr = align_get_bits(&h->gb);
		776	skip_bits_long(&h->gb, mb_size);
		777
		778	// In deblocking, the quantizer is 0
		779	h->cur_pic.qscale_table[mb_xy] = 0;
		780	// All coeffs are present
		781	memset(h->non_zero_count[mb_xy], 16, 48);
		782
		783	h->cur_pic.mb_type[mb_xy] = mb_type;
		784	return 0;
		785	}
		786
		787	local_ref_count[0] = h->ref_count[0] << MB_MBAFF(h);
		788	local_ref_count[1] = h->ref_count[1] << MB_MBAFF(h);
		789
		790	fill_decode_neighbors(h, mb_type);
		791	fill_decode_caches(h, mb_type);
		792
		793	//mb_pred
		794	if(IS_INTRA(mb_type)){
		795	int pred_mode;
		796	// init_top_left_availability(h);
		797	if(IS_INTRA4x4(mb_type)){
		798	int i;
		799	int di = 1;
		800	if(dct8x8_allowed && get_bits1(&h->gb)){
		801	mb_type \|= MB_TYPE_8x8DCT;
		802	di = 4;
		803	}
		804
		805	// fill_intra4x4_pred_table(h);
		806	for(i=0; i<16; i+=di){
		807	int mode= pred_intra_mode(h, i);
		808
		809	if(!get_bits1(&h->gb)){
		810	const int rem_mode= get_bits(&h->gb, 3);
		811	mode = rem_mode + (rem_mode >= mode);
		812	}
		813
		814	if(di==4)
		815	fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
		816	else
		817	h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
		818	}
		819	write_back_intra_pred_mode(h);
		820	if( ff_h264_check_intra4x4_pred_mode(h) < 0)
		821	return -1;
		822	}else{
		823	h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode, 0);
		824	if(h->intra16x16_pred_mode < 0)
		825	return -1;
		826	}
		827	if(decode_chroma){
		828	pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&h->gb), 1);
		829	if(pred_mode < 0)
		830	return -1;
		831	h->chroma_pred_mode= pred_mode;
		832	} else {
		833	h->chroma_pred_mode = DC_128_PRED8x8;
		834	}
		835	}else if(partition_count==4){
		836	int i, j, sub_partition_count[4], list, ref[2][4];
		837
		838	if(h->slice_type_nos == AV_PICTURE_TYPE_B){
		839	for(i=0; i<4; i++){
		840	h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
		841	if(h->sub_mb_type[i] >=13){
		842	av_log(h->avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], h->mb_x, h->mb_y);
		843	return -1;
		844	}
		845	sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
		846	h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
		847	}
		848	if( IS_DIRECT(h->sub_mb_type[0]\|h->sub_mb_type[1]\|h->sub_mb_type[2]\|h->sub_mb_type[3])) {
		849	ff_h264_pred_direct_motion(h, &mb_type);
		850	h->ref_cache[0][scan8[4]] =
		851	h->ref_cache[1][scan8[4]] =
		852	h->ref_cache[0][scan8[12]] =
		853	h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
		854	}
		855	}else{
		856	av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
		857	for(i=0; i<4; i++){
		858	h->sub_mb_type[i]= get_ue_golomb_31(&h->gb);
		859	if(h->sub_mb_type[i] >=4){
		860	av_log(h->avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], h->mb_x, h->mb_y);
		861	return -1;
		862	}
		863	sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
		864	h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
		865	}
		866	}
		867
		868	for(list=0; listlist_count; list++){
		869	int ref_count= IS_REF0(mb_type) ? 1 : local_ref_count[list];
		870	for(i=0; i<4; i++){
		871	if(IS_DIRECT(h->sub_mb_type[i])) continue;
		872	if(IS_DIR(h->sub_mb_type[i], 0, list)){
		873	unsigned int tmp;
		874	if(ref_count == 1){
		875	tmp= 0;
		876	}else if(ref_count == 2){
		877	tmp= get_bits1(&h->gb)^1;
		878	}else{
		879	tmp= get_ue_golomb_31(&h->gb);
		880	if(tmp>=ref_count){
		881	av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
		882	return -1;
		883	}
		884	}
		885	ref[list][i]= tmp;
		886	}else{
		887	//FIXME
		888	ref[list][i] = -1;
		889	}
		890	}
		891	}
		892
		893	if(dct8x8_allowed)
		894	dct8x8_allowed = get_dct8x8_allowed(h);
		895
		896	for(list=0; listlist_count; list++){
		897	for(i=0; i<4; i++){
		898	if(IS_DIRECT(h->sub_mb_type[i])) {
		899	h->ref_cache[list][ scan8[4i] ] = h->ref_cache[list][ scan8[4i]+1 ];
		900	continue;
		901	}
		902	h->ref_cache[list][ scan8[4i] ]=h->ref_cache[list][ scan8[4i]+1 ]=
		903	h->ref_cache[list][ scan8[4i]+8 ]=h->ref_cache[list][ scan8[4i]+9 ]= ref[list][i];
		904
		905	if(IS_DIR(h->sub_mb_type[i], 0, list)){
		906	const int sub_mb_type= h->sub_mb_type[i];
		907	const int block_width= (sub_mb_type & (MB_TYPE_16x16\|MB_TYPE_16x8)) ? 2 : 1;
		908	for(j=0; j
		909	int mx, my;
		910	const int index= 4i + block_widthj;
		911	int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
		912	pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
		913	mx += get_se_golomb(&h->gb);
		914	my += get_se_golomb(&h->gb);
		915	tprintf(h->avctx, "final mv:%d %d\n", mx, my);
		916
		917	if(IS_SUB_8X8(sub_mb_type)){
		918	mv_cache[ 1 ][0]=
		919	mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
		920	mv_cache[ 1 ][1]=
		921	mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
		922	}else if(IS_SUB_8X4(sub_mb_type)){
		923	mv_cache[ 1 ][0]= mx;
		924	mv_cache[ 1 ][1]= my;
		925	}else if(IS_SUB_4X8(sub_mb_type)){
		926	mv_cache[ 8 ][0]= mx;
		927	mv_cache[ 8 ][1]= my;
		928	}
		929	mv_cache[ 0 ][0]= mx;
		930	mv_cache[ 0 ][1]= my;
		931	}
		932	}else{
		933	uint32_t p= (uint32_t )&h->mv_cache[list][ scan8[4*i] ][0];
		934	p[0] = p[1]=
		935	p[8] = p[9]= 0;
		936	}
		937	}
		938	}
		939	}else if(IS_DIRECT(mb_type)){
		940	ff_h264_pred_direct_motion(h, &mb_type);
		941	dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
		942	}else{
		943	int list, mx, my, i;
		944	//FIXME we should set ref_idx_l? to 0 if we use that later ...
		945	if(IS_16X16(mb_type)){
		946	for(list=0; listlist_count; list++){
		947	unsigned int val;
		948	if(IS_DIR(mb_type, 0, list)){
		949	if(local_ref_count[list]==1){
		950	val= 0;
		951	}else if(local_ref_count[list]==2){
		952	val= get_bits1(&h->gb)^1;
		953	}else{
		954	val= get_ue_golomb_31(&h->gb);
		955	if(val >= local_ref_count[list]){
		956	av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
		957	return -1;
		958	}
		959	}
		960	fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
		961	}
		962	}
		963	for(list=0; listlist_count; list++){
		964	if(IS_DIR(mb_type, 0, list)){
		965	pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
		966	mx += get_se_golomb(&h->gb);
		967	my += get_se_golomb(&h->gb);
		968	tprintf(h->avctx, "final mv:%d %d\n", mx, my);
		969
		970	fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
		971	}
		972	}
		973	}
		974	else if(IS_16X8(mb_type)){
		975	for(list=0; listlist_count; list++){
		976	for(i=0; i<2; i++){
		977	unsigned int val;
		978	if(IS_DIR(mb_type, i, list)){
		979	if(local_ref_count[list] == 1){
		980	val= 0;
		981	}else if(local_ref_count[list] == 2){
		982	val= get_bits1(&h->gb)^1;
		983	}else{
		984	val= get_ue_golomb_31(&h->gb);
		985	if(val >= local_ref_count[list]){
		986	av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
		987	return -1;
		988	}
		989	}
		990	}else
		991	val= LIST_NOT_USED&0xFF;
		992	fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
		993	}
		994	}
		995	for(list=0; listlist_count; list++){
		996	for(i=0; i<2; i++){
		997	unsigned int val;
		998	if(IS_DIR(mb_type, i, list)){
		999	pred_16x8_motion(h, 8i, list, h->ref_cache[list][scan8[0] + 16i], &mx, &my);
		1000	mx += get_se_golomb(&h->gb);
		1001	my += get_se_golomb(&h->gb);
		1002	tprintf(h->avctx, "final mv:%d %d\n", mx, my);
		1003
		1004	val= pack16to32(mx,my);
		1005	}else
		1006	val=0;
		1007	fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
		1008	}
		1009	}
		1010	}else{
		1011	av_assert2(IS_8X16(mb_type));
		1012	for(list=0; listlist_count; list++){
		1013	for(i=0; i<2; i++){
		1014	unsigned int val;
		1015	if(IS_DIR(mb_type, i, list)){ //FIXME optimize
		1016	if(local_ref_count[list]==1){
		1017	val= 0;
		1018	}else if(local_ref_count[list]==2){
		1019	val= get_bits1(&h->gb)^1;
		1020	}else{
		1021	val= get_ue_golomb_31(&h->gb);
		1022	if(val >= local_ref_count[list]){
		1023	av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
		1024	return -1;
		1025	}
		1026	}
		1027	}else
		1028	val= LIST_NOT_USED&0xFF;
		1029	fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
		1030	}
		1031	}
		1032	for(list=0; listlist_count; list++){
		1033	for(i=0; i<2; i++){
		1034	unsigned int val;
		1035	if(IS_DIR(mb_type, i, list)){
		1036	pred_8x16_motion(h, i4, list, h->ref_cache[list][ scan8[0] + 2i ], &mx, &my);
		1037	mx += get_se_golomb(&h->gb);
		1038	my += get_se_golomb(&h->gb);
		1039	tprintf(h->avctx, "final mv:%d %d\n", mx, my);
		1040
		1041	val= pack16to32(mx,my);
		1042	}else
		1043	val=0;
		1044	fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
		1045	}
		1046	}
		1047	}
		1048	}
		1049
		1050	if(IS_INTER(mb_type))
		1051	write_back_motion(h, mb_type);
		1052
		1053	if(!IS_INTRA16x16(mb_type)){
		1054	cbp= get_ue_golomb(&h->gb);
		1055
		1056	if(decode_chroma){
		1057	if(cbp > 47){
		1058	av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, h->mb_x, h->mb_y);
		1059	return -1;
		1060	}
		1061	if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
		1062	else cbp= golomb_to_inter_cbp [cbp];
		1063	}else{
		1064	if(cbp > 15){
		1065	av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, h->mb_x, h->mb_y);
		1066	return -1;
		1067	}
		1068	if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
		1069	else cbp= golomb_to_inter_cbp_gray[cbp];
		1070	}
		1071	} else {
		1072	if (!decode_chroma && cbp>15) {
		1073	av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
		1074	return AVERROR_INVALIDDATA;
		1075	}
		1076	}
		1077
		1078	if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
		1079	mb_type \|= MB_TYPE_8x8DCT*get_bits1(&h->gb);
		1080	}
		1081	h->cbp=
		1082	h->cbp_table[mb_xy]= cbp;
		1083	h->cur_pic.mb_type[mb_xy] = mb_type;
		1084
		1085	if(cbp \|\| IS_INTRA16x16(mb_type)){
		1086	int i4x4, i8x8, chroma_idx;
		1087	int dquant;
		1088	int ret;
		1089	GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
		1090	const uint8_t scan, scan8x8;
		1091	const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
		1092
		1093	if(IS_INTERLACED(mb_type)){
		1094	scan8x8= h->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
		1095	scan= h->qscale ? h->field_scan : h->field_scan_q0;
		1096	}else{
		1097	scan8x8= h->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
		1098	scan= h->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
		1099	}
		1100
		1101	dquant= get_se_golomb(&h->gb);
		1102
		1103	h->qscale += dquant;
		1104
		1105	if(((unsigned)h->qscale) > max_qp){
		1106	if(h->qscale<0) h->qscale+= max_qp+1;
		1107	else h->qscale-= max_qp+1;
		1108	if(((unsigned)h->qscale) > max_qp){
		1109	av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, h->mb_x, h->mb_y);
		1110	return -1;
		1111	}
		1112	}
		1113
		1114	h->chroma_qp[0]= get_chroma_qp(h, 0, h->qscale);
		1115	h->chroma_qp[1]= get_chroma_qp(h, 1, h->qscale);
		1116
		1117	if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
		1118	return -1;
		1119	}
		1120	h->cbp_table[mb_xy] \|= ret << 12;
		1121	if (CHROMA444(h)) {
		1122	if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
		1123	return -1;
		1124	}
		1125	if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
		1126	return -1;
		1127	}
		1128	} else {
		1129	const int num_c8x8 = h->sps.chroma_format_idc;
		1130
		1131	if(cbp&0x30){
		1132	for(chroma_idx=0; chroma_idx<2; chroma_idx++)
		1133	if (decode_residual(h, gb, h->mb + ((256 + 1616chroma_idx) << pixel_shift),
		1134	CHROMA_DC_BLOCK_INDEX+chroma_idx,
		1135	CHROMA422(h) ? chroma422_dc_scan : chroma_dc_scan,
		1136	NULL, 4*num_c8x8) < 0) {
		1137	return -1;
		1138	}
		1139	}
		1140
		1141	if(cbp&0x20){
		1142	for(chroma_idx=0; chroma_idx<2; chroma_idx++){
		1143	const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
		1144	int16_t mb = h->mb + (16(16 + 16*chroma_idx) << pixel_shift);
		1145	for (i8x8=0; i8x8
		1146	for (i4x4=0; i4x4<4; i4x4++) {
		1147	const int index= 16 + 16chroma_idx + 8i8x8 + i4x4;
		1148	if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)
		1149	return -1;
		1150	mb += 16<
		1151	}
		1152	}
		1153	}
		1154	}else{
		1155	fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
		1156	fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
		1157	}
		1158	}
		1159	}else{
		1160	fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
		1161	fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
		1162	fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
		1163	}
		1164	h->cur_pic.qscale_table[mb_xy] = h->qscale;
		1165	write_back_non_zero_count(h);
		1166
		1167	return 0;
		1168	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/libavcodec/h264_cavlc.c – Rev 4349