WebSVN - shark - Blame - Rev 1288 - /demos/trunk/mpeg2/getblk.c

Rev	Author	Line No.	Line
1085	pj	1	/* getblk.c, DCT block decoding */
		2
		3	/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
		4
		5	/*
		6	* Disclaimer of Warranty
		7	*
		8	* These software programs are available to the user without any license fee or
		9	* royalty on an "as is" basis. The MPEG Software Simulation Group disclaims
		10	* any and all warranties, whether express, implied, or statuary, including any
		11	* implied warranties or merchantability or of fitness for a particular
		12	* purpose. In no event shall the copyright-holder be liable for any
		13	* incidental, punitive, or consequential damages of any kind whatsoever
		14	* arising from the use of these programs.
		15	*
		16	* This disclaimer of warranty extends to the user of these programs and user's
		17	* customers, employees, agents, transferees, successors, and assigns.
		18	*
		19	* The MPEG Software Simulation Group does not represent or warrant that the
		20	* programs furnished hereunder are free of infringement of any third-party
		21	* patents.
		22	*
		23	* Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
		24	* are subject to royalty fees to patent holders. Many of these patents are
		25	* general enough such that they are unavoidable regardless of implementation
		26	* design.
		27	*
		28	*/
		29
		30	#include <stdio.h>
		31
		32	#include "config.h"
		33	#include "global.h"
		34
		35
		36	/* defined in getvlc.h */
		37	typedef struct {
		38	char run, level, len;
		39	} DCTtab;
		40
		41	extern DCTtab DCTtabfirst[],DCTtabnext[],DCTtab0[],DCTtab1[];
		42	extern DCTtab DCTtab2[],DCTtab3[],DCTtab4[],DCTtab5[],DCTtab6[];
		43	extern DCTtab DCTtab0a[],DCTtab1a[];
		44
		45
		46	/* decode one intra coded MPEG-1 block */
		47
		48	void Decode_MPEG1_Intra_Block(comp,dc_dct_pred)
		49	int comp;
		50	int dc_dct_pred[];
		51	{
		52	int val, i, j, sign;
		53	unsigned int code;
		54	DCTtab *tab;
		55	short *bp;
		56
		57	bp = ld->block[comp];
		58
		59	/* ISO/IEC 11172-2 section 2.4.3.7: Block layer. */
		60	/* decode DC coefficients */
		61	if (comp<4)
		62	bp[0] = (dc_dct_pred[0]+=Get_Luma_DC_dct_diff()) << 3;
		63	else if (comp==4)
		64	bp[0] = (dc_dct_pred[1]+=Get_Chroma_DC_dct_diff()) << 3;
		65	else
		66	bp[0] = (dc_dct_pred[2]+=Get_Chroma_DC_dct_diff()) << 3;
		67
		68	if (Fault_Flag) return;
		69
		70	/* D-pictures do not contain AC coefficients */
		71	if(picture_coding_type == D_TYPE)
		72	return;
		73
		74	/* decode AC coefficients */
		75	for (i=1; ; i++)
		76	{
		77	code = Show_Bits(16);
		78	if (code>=16384)
		79	tab = &DCTtabnext[(code>>12)-4];
		80	else if (code>=1024)
		81	tab = &DCTtab0[(code>>8)-4];
		82	else if (code>=512)
		83	tab = &DCTtab1[(code>>6)-8];
		84	else if (code>=256)
		85	tab = &DCTtab2[(code>>4)-16];
		86	else if (code>=128)
		87	tab = &DCTtab3[(code>>3)-16];
		88	else if (code>=64)
		89	tab = &DCTtab4[(code>>2)-16];
		90	else if (code>=32)
		91	tab = &DCTtab5[(code>>1)-16];
		92	else if (code>=16)
		93	tab = &DCTtab6[code-16];
		94	else
		95	{
		96	if (!Quiet_Flag)
		97	printf("invalid Huffman code in Decode_MPEG1_Intra_Block()\n");
		98	Fault_Flag = 1;
		99	return;
		100	}
		101
		102	Flush_Buffer(tab->len);
		103
		104	if (tab->run==64) /* end_of_block */
		105	return;
		106
		107	if (tab->run==65) /* escape */
		108	{
		109	i+= Get_Bits(6);
		110
		111	val = Get_Bits(8);
		112	if (val==0)
		113	val = Get_Bits(8);
		114	else if (val==128)
		115	val = Get_Bits(8) - 256;
		116	else if (val>128)
		117	val -= 256;
		118
		119	if((sign = (val<0)))
		120	val = -val;
		121	}
		122	else
		123	{
		124	i+= tab->run;
		125	val = tab->level;
		126	sign = Get_Bits(1);
		127	}
		128
		129	if (i>=64)
		130	{
		131	if (!Quiet_Flag)
		132	fprintf(stderr,"DCT coeff index (i) out of bounds (intra)\n");
		133	Fault_Flag = 1;
		134	return;
		135	}
		136
		137	j = scan[ZIG_ZAG][i];
		138	val = (valld->quantizer_scaleld->intra_quantizer_matrix[j]) >> 3;
		139
		140	/* mismatch control ('oddification') */
		141	if (val!=0) /* should always be true, but it's not guaranteed */
		142	val = (val-1) \| 1; /* equivalent to: if ((val&1)==0) val = val - 1; */
		143
		144	/* saturation */
		145	if (!sign)
		146	bp[j] = (val>2047) ? 2047 : val; /* positive */
		147	else
		148	bp[j] = (val>2048) ? -2048 : -val; /* negative */
		149	}
		150	}
		151
		152
		153	/* decode one non-intra coded MPEG-1 block */
		154
		155	void Decode_MPEG1_Non_Intra_Block(comp)
		156	int comp;
		157	{
		158	int val, i, j, sign;
		159	unsigned int code;
		160	DCTtab *tab;
		161	short *bp;
		162
		163	bp = ld->block[comp];
		164
		165	/* decode AC coefficients */
		166	for (i=0; ; i++)
		167	{
		168	code = Show_Bits(16);
		169	if (code>=16384)
		170	{
		171	if (i==0)
		172	tab = &DCTtabfirst[(code>>12)-4];
		173	else
		174	tab = &DCTtabnext[(code>>12)-4];
		175	}
		176	else if (code>=1024)
		177	tab = &DCTtab0[(code>>8)-4];
		178	else if (code>=512)
		179	tab = &DCTtab1[(code>>6)-8];
		180	else if (code>=256)
		181	tab = &DCTtab2[(code>>4)-16];
		182	else if (code>=128)
		183	tab = &DCTtab3[(code>>3)-16];
		184	else if (code>=64)
		185	tab = &DCTtab4[(code>>2)-16];
		186	else if (code>=32)
		187	tab = &DCTtab5[(code>>1)-16];
		188	else if (code>=16)
		189	tab = &DCTtab6[code-16];
		190	else
		191	{
		192	if (!Quiet_Flag)
		193	printf("invalid Huffman code in Decode_MPEG1_Non_Intra_Block()\n");
		194	Fault_Flag = 1;
		195	return;
		196	}
		197
		198	Flush_Buffer(tab->len);
		199
		200	if (tab->run==64) /* end_of_block */
		201	return;
		202
		203	if (tab->run==65) /* escape */
		204	{
		205	i+= Get_Bits(6);
		206
		207	val = Get_Bits(8);
		208	if (val==0)
		209	val = Get_Bits(8);
		210	else if (val==128)
		211	val = Get_Bits(8) - 256;
		212	else if (val>128)
		213	val -= 256;
		214
		215	if((sign = (val<0)))
		216	val = -val;
		217	}
		218	else
		219	{
		220	i+= tab->run;
		221	val = tab->level;
		222	sign = Get_Bits(1);
		223	}
		224
		225	if (i>=64)
		226	{
		227	if (!Quiet_Flag)
		228	fprintf(stderr,"DCT coeff index (i) out of bounds (inter)\n");
		229	Fault_Flag = 1;
		230	return;
		231	}
		232
		233	j = scan[ZIG_ZAG][i];
		234	val = (((val<<1)+1)ld->quantizer_scaleld->non_intra_quantizer_matrix[j]) >> 4;
		235
		236	/* mismatch control ('oddification') */
		237	if (val!=0) /* should always be true, but it's not guaranteed */
		238	val = (val-1) \| 1; /* equivalent to: if ((val&1)==0) val = val - 1; */
		239
		240	/* saturation */
		241	if (!sign)
		242	bp[j] = (val>2047) ? 2047 : val; /* positive */
		243	else
		244	bp[j] = (val>2048) ? -2048 : -val; /* negative */
		245	}
		246	}
		247
		248
		249	/* decode one intra coded MPEG-2 block */
		250
		251	void Decode_MPEG2_Intra_Block(comp,dc_dct_pred)
		252	int comp;
		253	int dc_dct_pred[];
		254	{
		255	int val, i, j, sign, nc, cc, run;
		256	unsigned int code;
		257	DCTtab *tab;
		258	short *bp;
		259	int *qmat;
		260	struct layer_data *ld1;
		261
		262	/* with data partitioning, data always goes to base layer */
		263	ld1 = (ld->scalable_mode==SC_DP) ? &base : ld;
		264	bp = ld1->block[comp];
		265
		266	if (base.scalable_mode==SC_DP)
		267	if (base.priority_breakpoint<64)
		268	ld = &enhan;
		269	else
		270	ld = &base;
		271
		272	cc = (comp<4) ? 0 : (comp&1)+1;
		273
		274	qmat = (comp<4 \|\| chroma_format==CHROMA420)
		275	? ld1->intra_quantizer_matrix
		276	: ld1->chroma_intra_quantizer_matrix;
		277
		278	/* ISO/IEC 13818-2 section 7.2.1: decode DC coefficients */
		279	if (cc==0)
		280	val = (dc_dct_pred[0]+= Get_Luma_DC_dct_diff());
		281	else if (cc==1)
		282	val = (dc_dct_pred[1]+= Get_Chroma_DC_dct_diff());
		283	else
		284	val = (dc_dct_pred[2]+= Get_Chroma_DC_dct_diff());
		285
		286	if (Fault_Flag) return;
		287
		288	bp[0] = val << (3-intra_dc_precision);
		289
		290	nc=0;
		291
		292	#ifdef TRACE
		293	if (Trace_Flag)
		294	printf("DCT(%d)i:",comp);
		295	#endif /* TRACE */
		296
		297	/* decode AC coefficients */
		298	for (i=1; ; i++)
		299	{
		300	code = Show_Bits(16);
		301	if (code>=16384 && !intra_vlc_format)
		302	tab = &DCTtabnext[(code>>12)-4];
		303	else if (code>=1024)
		304	{
		305	if (intra_vlc_format)
		306	tab = &DCTtab0a[(code>>8)-4];
		307	else
		308	tab = &DCTtab0[(code>>8)-4];
		309	}
		310	else if (code>=512)
		311	{
		312	if (intra_vlc_format)
		313	tab = &DCTtab1a[(code>>6)-8];
		314	else
		315	tab = &DCTtab1[(code>>6)-8];
		316	}
		317	else if (code>=256)
		318	tab = &DCTtab2[(code>>4)-16];
		319	else if (code>=128)
		320	tab = &DCTtab3[(code>>3)-16];
		321	else if (code>=64)
		322	tab = &DCTtab4[(code>>2)-16];
		323	else if (code>=32)
		324	tab = &DCTtab5[(code>>1)-16];
		325	else if (code>=16)
		326	tab = &DCTtab6[code-16];
		327	else
		328	{
		329	if (!Quiet_Flag)
		330	printf("invalid Huffman code in Decode_MPEG2_Intra_Block()\n");
		331	Fault_Flag = 1;
		332	return;
		333	}
		334
		335	Flush_Buffer(tab->len);
		336
		337	#ifdef TRACE
		338	if (Trace_Flag)
		339	{
		340	printf(" (");
		341	Print_Bits(code,16,tab->len);
		342	}
		343	#endif /* TRACE */
		344
		345	if (tab->run==64) /* end_of_block */
		346	{
		347	#ifdef TRACE
		348	if (Trace_Flag)
		349	printf("): EOB\n");
		350	#endif /* TRACE */
		351	return;
		352	}
		353
		354	if (tab->run==65) /* escape */
		355	{
		356	#ifdef TRACE
		357	if (Trace_Flag)
		358	{
		359	putchar(' ');
		360	Print_Bits(Show_Bits(6),6,6);
		361	}
		362	#endif /* TRACE */
		363
		364	i+= run = Get_Bits(6);
		365
		366	#ifdef TRACE
		367	if (Trace_Flag)
		368	{
		369	putchar(' ');
		370	Print_Bits(Show_Bits(12),12,12);
		371	}
		372	#endif /* TRACE */
		373
		374	val = Get_Bits(12);
		375	if ((val&2047)==0)
		376	{
		377	if (!Quiet_Flag)
		378	printf("invalid escape in Decode_MPEG2_Intra_Block()\n");
		379	Fault_Flag = 1;
		380	return;
		381	}
		382	if((sign = (val>=2048)))
		383	val = 4096 - val;
		384	}
		385	else
		386	{
		387	i+= run = tab->run;
		388	val = tab->level;
		389	sign = Get_Bits(1);
		390
		391	#ifdef TRACE
		392	if (Trace_Flag)
		393	printf("%d",sign);
		394	#endif /* TRACE */
		395	}
		396
		397	if (i>=64)
		398	{
		399	if (!Quiet_Flag)
		400	fprintf(stderr,"DCT coeff index (i) out of bounds (intra2)\n");
		401	Fault_Flag = 1;
		402	return;
		403	}
		404
		405	#ifdef TRACE
		406	if (Trace_Flag)
		407	printf("): %d/%d",run,sign ? -val : val);
		408	#endif /* TRACE */
		409
		410	j = scan[ld1->alternate_scan][i];
		411	val = (val * ld1->quantizer_scale * qmat[j]) >> 4;
		412	bp[j] = sign ? -val : val;
		413	nc++;
		414
		415	if (base.scalable_mode==SC_DP && nc==base.priority_breakpoint-63)
		416	ld = &enhan;
		417	}
		418	}
		419
		420
		421	/* decode one non-intra coded MPEG-2 block */
		422
		423	void Decode_MPEG2_Non_Intra_Block(comp)
		424	int comp;
		425	{
		426	int val, i, j, sign, nc, run;
		427	unsigned int code;
		428	DCTtab *tab;
		429	short *bp;
		430	int *qmat;
		431	struct layer_data *ld1;
		432
		433	/* with data partitioning, data always goes to base layer */
		434	ld1 = (ld->scalable_mode==SC_DP) ? &base : ld;
		435	bp = ld1->block[comp];
		436
		437	if (base.scalable_mode==SC_DP)
		438	if (base.priority_breakpoint<64)
		439	ld = &enhan;
		440	else
		441	ld = &base;
		442
		443	qmat = (comp<4 \|\| chroma_format==CHROMA420)
		444	? ld1->non_intra_quantizer_matrix
		445	: ld1->chroma_non_intra_quantizer_matrix;
		446
		447	nc = 0;
		448
		449	#ifdef TRACE
		450	if (Trace_Flag)
		451	printf("DCT(%d)n:",comp);
		452	#endif /* TRACE */
		453
		454	/* decode AC coefficients */
		455	for (i=0; ; i++)
		456	{
		457	code = Show_Bits(16);
		458	if (code>=16384)
		459	{
		460	if (i==0)
		461	tab = &DCTtabfirst[(code>>12)-4];
		462	else
		463	tab = &DCTtabnext[(code>>12)-4];
		464	}
		465	else if (code>=1024)
		466	tab = &DCTtab0[(code>>8)-4];
		467	else if (code>=512)
		468	tab = &DCTtab1[(code>>6)-8];
		469	else if (code>=256)
		470	tab = &DCTtab2[(code>>4)-16];
		471	else if (code>=128)
		472	tab = &DCTtab3[(code>>3)-16];
		473	else if (code>=64)
		474	tab = &DCTtab4[(code>>2)-16];
		475	else if (code>=32)
		476	tab = &DCTtab5[(code>>1)-16];
		477	else if (code>=16)
		478	tab = &DCTtab6[code-16];
		479	else
		480	{
		481	if (!Quiet_Flag)
		482	printf("invalid Huffman code in Decode_MPEG2_Non_Intra_Block()\n");
		483	Fault_Flag = 1;
		484	return;
		485	}
		486
		487	Flush_Buffer(tab->len);
		488
		489	#ifdef TRACE
		490	if (Trace_Flag)
		491	{
		492	printf(" (");
		493	Print_Bits(code,16,tab->len);
		494	}
		495	#endif /* TRACE */
		496
		497	if (tab->run==64) /* end_of_block */
		498	{
		499	#ifdef TRACE
		500	if (Trace_Flag)
		501	printf("): EOB\n");
		502	#endif /* TRACE */
		503	return;
		504	}
		505
		506	if (tab->run==65) /* escape */
		507	{
		508	#ifdef TRACE
		509	if (Trace_Flag)
		510	{
		511	putchar(' ');
		512	Print_Bits(Show_Bits(6),6,6);
		513	}
		514	#endif /* TRACE */
		515
		516	i+= run = Get_Bits(6);
		517
		518	#ifdef TRACE
		519	if (Trace_Flag)
		520	{
		521	putchar(' ');
		522	Print_Bits(Show_Bits(12),12,12);
		523	}
		524	#endif /* TRACE */
		525
		526	val = Get_Bits(12);
		527	if ((val&2047)==0)
		528	{
		529	if (!Quiet_Flag)
		530	printf("invalid escape in Decode_MPEG2_Intra_Block()\n");
		531	Fault_Flag = 1;
		532	return;
		533	}
		534	if((sign = (val>=2048)))
		535	val = 4096 - val;
		536	}
		537	else
		538	{
		539	i+= run = tab->run;
		540	val = tab->level;
		541	sign = Get_Bits(1);
		542
		543	#ifdef TRACE
		544	if (Trace_Flag)
		545	printf("%d",sign);
		546	#endif /* TRACE */
		547	}
		548
		549	if (i>=64)
		550	{
		551	if (!Quiet_Flag)
		552	fprintf(stderr,"DCT coeff index (i) out of bounds (inter2)\n");
		553	Fault_Flag = 1;
		554	return;
		555	}
		556
		557	#ifdef TRACE
		558	if (Trace_Flag)
		559	printf("): %d/%d",run,sign?-val:val);
		560	#endif /* TRACE */
		561
		562	j = scan[ld1->alternate_scan][i];
		563	val = (((val<<1)+1) * ld1->quantizer_scale * qmat[j]) >> 5;
		564	bp[j] = sign ? -val : val;
		565	nc++;
		566
		567	if (base.scalable_mode==SC_DP && nc==base.priority_breakpoint-63)
		568	ld = &enhan;
		569	}
		570	}

Subversion Repositories shark

(root)/demos/trunk/mpeg2/getblk.c - Rev 1288