WebSVN - shark - Blame - Rev 2 - /shark/branches/pj/ports/mpeg/decoders.c

Rev	Author	Line No.	Line
2	pj	1	/*
		2	* decoders.c
		3	*
		4	* This file contains all the routines for Huffman decoding required in
		5	* MPEG
		6	*
		7	*/
		8
		9	/*
		10	* Copyright (c) 1995 The Regents of the University of California.
		11	* All rights reserved.
		12	*
		13	* Permission to use, copy, modify, and distribute this software and its
		14	* documentation for any purpose, without fee, and without written agreement is
		15	* hereby granted, provided that the above copyright notice and the following
		16	* two paragraphs appear in all copies of this software.
		17	*
		18	* IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR
		19	* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
		20	* OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
		21	* CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		22	*
		23	* THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
		24	* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
		25	* AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
		26	* ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO
		27	* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
		28	*/
		29
		30	/*
		31	* Portions of this software Copyright (c) 1995 Brown University.
		32	* All rights reserved.
		33	*
		34	* Permission to use, copy, modify, and distribute this software and its
		35	* documentation for any purpose, without fee, and without written agreement
		36	* is hereby granted, provided that the above copyright notice and the
		37	* following two paragraphs appear in all copies of this software.
		38	*
		39	* IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE TO ANY PARTY FOR
		40	* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
		41	* OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF BROWN
		42	* UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		43	*
		44	* BROWN UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
		45	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
		46	* PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"
		47	* BASIS, AND BROWN UNIVERSITY HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
		48	* SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
		49	*/
		50
		51	#include <stdio.h>
		52	#include <assert.h>
		53	#include "decoders.h"
		54	#include "util.h"
		55	#include "video.h"
		56	#include "proto.h"
		57
		58	/*
		59	Changes to make the code reentrant:
		60	curVidStream now not global - DecodeDCT* functioned #ifdef'd out
		61	(are they needed?)
		62	Additional changes:
		63	none
		64	-lsh@cs.brown.edu (Loring Holden)
		65	*/
		66
		67	/* Decoding table for macroblock_address_increment */
		68	mb_addr_inc_entry mb_addr_inc[2048];
		69
		70	/* Decoding table for macroblock_type in predictive-coded pictures */
		71	mb_type_entry mb_type_P[64];
		72
		73	/* Decoding table for macroblock_type in bidirectionally-coded pictures */
		74	mb_type_entry mb_type_B[64];
		75
		76	/* Decoding table for motion vectors */
		77	motion_vectors_entry motion_vectors[2048];
		78
		79	/* Decoding table for coded_block_pattern */
		80
		81	coded_block_pattern_entry coded_block_pattern[512] =
		82	{ {(unsigned int)ERROR, 0}, {(unsigned int)ERROR, 0}, {39, 9}, {27, 9}, {59, 9}, {55, 9}, {47, 9}, {31, 9},
		83	{58, 8}, {58, 8}, {54, 8}, {54, 8}, {46, 8}, {46, 8}, {30, 8}, {30, 8},
		84	{57, 8}, {57, 8}, {53, 8}, {53, 8}, {45, 8}, {45, 8}, {29, 8}, {29, 8},
		85	{38, 8}, {38, 8}, {26, 8}, {26, 8}, {37, 8}, {37, 8}, {25, 8}, {25, 8},
		86	{43, 8}, {43, 8}, {23, 8}, {23, 8}, {51, 8}, {51, 8}, {15, 8}, {15, 8},
		87	{42, 8}, {42, 8}, {22, 8}, {22, 8}, {50, 8}, {50, 8}, {14, 8}, {14, 8},
		88	{41, 8}, {41, 8}, {21, 8}, {21, 8}, {49, 8}, {49, 8}, {13, 8}, {13, 8},
		89	{35, 8}, {35, 8}, {19, 8}, {19, 8}, {11, 8}, {11, 8}, {7, 8}, {7, 8},
		90	{34, 7}, {34, 7}, {34, 7}, {34, 7}, {18, 7}, {18, 7}, {18, 7}, {18, 7},
		91	{10, 7}, {10, 7}, {10, 7}, {10, 7}, {6, 7}, {6, 7}, {6, 7}, {6, 7},
		92	{33, 7}, {33, 7}, {33, 7}, {33, 7}, {17, 7}, {17, 7}, {17, 7}, {17, 7},
		93	{9, 7}, {9, 7}, {9, 7}, {9, 7}, {5, 7}, {5, 7}, {5, 7}, {5, 7},
		94	{63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6}, {63, 6},
		95	{3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6}, {3, 6},
		96	{36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6}, {36, 6},
		97	{24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6}, {24, 6},
		98	{62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5},
		99	{62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5}, {62, 5},
		100	{2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5},
		101	{2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5}, {2, 5},
		102	{61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5},
		103	{61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5}, {61, 5},
		104	{1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5},
		105	{1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5}, {1, 5},
		106	{56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5},
		107	{56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5}, {56, 5},
		108	{52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5},
		109	{52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5}, {52, 5},
		110	{44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5},
		111	{44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5}, {44, 5},
		112	{28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5},
		113	{28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5}, {28, 5},
		114	{40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5},
		115	{40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5}, {40, 5},
		116	{20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5},
		117	{20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5}, {20, 5},
		118	{48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5},
		119	{48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5}, {48, 5},
		120	{12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5},
		121	{12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5}, {12, 5},
		122	{32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
		123	{32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
		124	{32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
		125	{32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4}, {32, 4},
		126	{16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
		127	{16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
		128	{16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
		129	{16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4}, {16, 4},
		130	{8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
		131	{8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
		132	{8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
		133	{8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4}, {8, 4},
		134	{4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
		135	{4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
		136	{4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
		137	{4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4}, {4, 4},
		138	{60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
		139	{60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
		140	{60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
		141	{60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
		142	{60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
		143	{60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
		144	{60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3},
		145	{60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}, {60, 3}
		146	};
		147
		148	/* Decoding tables for dct_dc_size_luminance */
		149	dct_dc_size_entry dct_dc_size_luminance[32] =
		150	{ {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
		151	{2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
		152	{0, 3}, {0, 3}, {0, 3}, {0, 3}, {3, 3}, {3, 3}, {3, 3}, {3, 3},
		153	{4, 3}, {4, 3}, {4, 3}, {4, 3}, {5, 4}, {5, 4}, {6, 5}, {(unsigned int)ERROR, 0}
		154	};
		155
		156	dct_dc_size_entry dct_dc_size_luminance1[16] =
		157	{ {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6}, {7, 6},
		158	{8, 7}, {8, 7}, {8, 7}, {8, 7}, {9, 8}, {9, 8}, {10, 9}, {11, 9}
		159	};
		160
		161	/* Decoding table for dct_dc_size_chrominance */
		162	dct_dc_size_entry dct_dc_size_chrominance[32] =
		163	{ {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2}, {0, 2},
		164	{1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2},
		165	{2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2}, {2, 2},
		166	{3, 3}, {3, 3}, {3, 3}, {3, 3}, {4, 4}, {4, 4}, {5, 5}, {(unsigned int)ERROR, 0}
		167	};
		168
		169	dct_dc_size_entry dct_dc_size_chrominance1[32] =
		170	{ {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6},
		171	{6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6}, {6, 6},
		172	{7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7}, {7, 7},
		173	{8, 8}, {8, 8}, {8, 8}, {8, 8}, {9, 9}, {9, 9}, {10, 10}, {11, 10}
		174	};
		175
		176	/* DCT coeff tables. */
		177
		178	unsigned short int dct_coeff_tbl_0[256] =
		179	{
		180	0xffff, 0xffff, 0xffff, 0xffff,
		181	0xffff, 0xffff, 0xffff, 0xffff,
		182	0xffff, 0xffff, 0xffff, 0xffff,
		183	0xffff, 0xffff, 0xffff, 0xffff,
		184	0x052f, 0x051f, 0x050f, 0x04ff,
		185	0x183f, 0x402f, 0x3c2f, 0x382f,
		186	0x342f, 0x302f, 0x2c2f, 0x7c1f,
		187	0x781f, 0x741f, 0x701f, 0x6c1f,
		188	0x028e, 0x028e, 0x027e, 0x027e,
		189	0x026e, 0x026e, 0x025e, 0x025e,
		190	0x024e, 0x024e, 0x023e, 0x023e,
		191	0x022e, 0x022e, 0x021e, 0x021e,
		192	0x020e, 0x020e, 0x04ee, 0x04ee,
		193	0x04de, 0x04de, 0x04ce, 0x04ce,
		194	0x04be, 0x04be, 0x04ae, 0x04ae,
		195	0x049e, 0x049e, 0x048e, 0x048e,
		196	0x01fd, 0x01fd, 0x01fd, 0x01fd,
		197	0x01ed, 0x01ed, 0x01ed, 0x01ed,
		198	0x01dd, 0x01dd, 0x01dd, 0x01dd,
		199	0x01cd, 0x01cd, 0x01cd, 0x01cd,
		200	0x01bd, 0x01bd, 0x01bd, 0x01bd,
		201	0x01ad, 0x01ad, 0x01ad, 0x01ad,
		202	0x019d, 0x019d, 0x019d, 0x019d,
		203	0x018d, 0x018d, 0x018d, 0x018d,
		204	0x017d, 0x017d, 0x017d, 0x017d,
		205	0x016d, 0x016d, 0x016d, 0x016d,
		206	0x015d, 0x015d, 0x015d, 0x015d,
		207	0x014d, 0x014d, 0x014d, 0x014d,
		208	0x013d, 0x013d, 0x013d, 0x013d,
		209	0x012d, 0x012d, 0x012d, 0x012d,
		210	0x011d, 0x011d, 0x011d, 0x011d,
		211	0x010d, 0x010d, 0x010d, 0x010d,
		212	0x282c, 0x282c, 0x282c, 0x282c,
		213	0x282c, 0x282c, 0x282c, 0x282c,
		214	0x242c, 0x242c, 0x242c, 0x242c,
		215	0x242c, 0x242c, 0x242c, 0x242c,
		216	0x143c, 0x143c, 0x143c, 0x143c,
		217	0x143c, 0x143c, 0x143c, 0x143c,
		218	0x0c4c, 0x0c4c, 0x0c4c, 0x0c4c,
		219	0x0c4c, 0x0c4c, 0x0c4c, 0x0c4c,
		220	0x085c, 0x085c, 0x085c, 0x085c,
		221	0x085c, 0x085c, 0x085c, 0x085c,
		222	0x047c, 0x047c, 0x047c, 0x047c,
		223	0x047c, 0x047c, 0x047c, 0x047c,
		224	0x046c, 0x046c, 0x046c, 0x046c,
		225	0x046c, 0x046c, 0x046c, 0x046c,
		226	0x00fc, 0x00fc, 0x00fc, 0x00fc,
		227	0x00fc, 0x00fc, 0x00fc, 0x00fc,
		228	0x00ec, 0x00ec, 0x00ec, 0x00ec,
		229	0x00ec, 0x00ec, 0x00ec, 0x00ec,
		230	0x00dc, 0x00dc, 0x00dc, 0x00dc,
		231	0x00dc, 0x00dc, 0x00dc, 0x00dc,
		232	0x00cc, 0x00cc, 0x00cc, 0x00cc,
		233	0x00cc, 0x00cc, 0x00cc, 0x00cc,
		234	0x681c, 0x681c, 0x681c, 0x681c,
		235	0x681c, 0x681c, 0x681c, 0x681c,
		236	0x641c, 0x641c, 0x641c, 0x641c,
		237	0x641c, 0x641c, 0x641c, 0x641c,
		238	0x601c, 0x601c, 0x601c, 0x601c,
		239	0x601c, 0x601c, 0x601c, 0x601c,
		240	0x5c1c, 0x5c1c, 0x5c1c, 0x5c1c,
		241	0x5c1c, 0x5c1c, 0x5c1c, 0x5c1c,
		242	0x581c, 0x581c, 0x581c, 0x581c,
		243	0x581c, 0x581c, 0x581c, 0x581c,
		244	};
		245
		246	unsigned short int dct_coeff_tbl_1[16] =
		247	{
		248	0x00bb, 0x202b, 0x103b, 0x00ab,
		249	0x084b, 0x1c2b, 0x541b, 0x501b,
		250	0x009b, 0x4c1b, 0x481b, 0x045b,
		251	0x0c3b, 0x008b, 0x182b, 0x441b,
		252	};
		253
		254	unsigned short int dct_coeff_tbl_2[4] =
		255	{
		256	0x4019, 0x1429, 0x0079, 0x0839,
		257	};
		258
		259	unsigned short int dct_coeff_tbl_3[4] =
		260	{
		261	0x0449, 0x3c19, 0x3819, 0x1029,
		262	};
		263
		264	unsigned short int dct_coeff_next[256] =
		265	{
		266	0xffff, 0xffff, 0xffff, 0xffff,
		267	0xf7d5, 0xf7d5, 0xf7d5, 0xf7d5,
		268	0x0826, 0x0826, 0x2416, 0x2416,
		269	0x0046, 0x0046, 0x2016, 0x2016,
		270	0x1c15, 0x1c15, 0x1c15, 0x1c15,
		271	0x1815, 0x1815, 0x1815, 0x1815,
		272	0x0425, 0x0425, 0x0425, 0x0425,
		273	0x1415, 0x1415, 0x1415, 0x1415,
		274	0x3417, 0x0067, 0x3017, 0x2c17,
		275	0x0c27, 0x0437, 0x0057, 0x2817,
		276	0x0034, 0x0034, 0x0034, 0x0034,
		277	0x0034, 0x0034, 0x0034, 0x0034,
		278	0x1014, 0x1014, 0x1014, 0x1014,
		279	0x1014, 0x1014, 0x1014, 0x1014,
		280	0x0c14, 0x0c14, 0x0c14, 0x0c14,
		281	0x0c14, 0x0c14, 0x0c14, 0x0c14,
		282	0x0023, 0x0023, 0x0023, 0x0023,
		283	0x0023, 0x0023, 0x0023, 0x0023,
		284	0x0023, 0x0023, 0x0023, 0x0023,
		285	0x0023, 0x0023, 0x0023, 0x0023,
		286	0x0813, 0x0813, 0x0813, 0x0813,
		287	0x0813, 0x0813, 0x0813, 0x0813,
		288	0x0813, 0x0813, 0x0813, 0x0813,
		289	0x0813, 0x0813, 0x0813, 0x0813,
		290	0x0412, 0x0412, 0x0412, 0x0412,
		291	0x0412, 0x0412, 0x0412, 0x0412,
		292	0x0412, 0x0412, 0x0412, 0x0412,
		293	0x0412, 0x0412, 0x0412, 0x0412,
		294	0x0412, 0x0412, 0x0412, 0x0412,
		295	0x0412, 0x0412, 0x0412, 0x0412,
		296	0x0412, 0x0412, 0x0412, 0x0412,
		297	0x0412, 0x0412, 0x0412, 0x0412,
		298	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		299	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		300	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		301	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		302	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		303	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		304	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		305	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		306	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		307	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		308	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		309	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		310	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		311	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		312	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		313	0xfbe1, 0xfbe1, 0xfbe1, 0xfbe1,
		314	0x0011, 0x0011, 0x0011, 0x0011,
		315	0x0011, 0x0011, 0x0011, 0x0011,
		316	0x0011, 0x0011, 0x0011, 0x0011,
		317	0x0011, 0x0011, 0x0011, 0x0011,
		318	0x0011, 0x0011, 0x0011, 0x0011,
		319	0x0011, 0x0011, 0x0011, 0x0011,
		320	0x0011, 0x0011, 0x0011, 0x0011,
		321	0x0011, 0x0011, 0x0011, 0x0011,
		322	0x0011, 0x0011, 0x0011, 0x0011,
		323	0x0011, 0x0011, 0x0011, 0x0011,
		324	0x0011, 0x0011, 0x0011, 0x0011,
		325	0x0011, 0x0011, 0x0011, 0x0011,
		326	0x0011, 0x0011, 0x0011, 0x0011,
		327	0x0011, 0x0011, 0x0011, 0x0011,
		328	0x0011, 0x0011, 0x0011, 0x0011,
		329	0x0011, 0x0011, 0x0011, 0x0011,
		330	};
		331
		332	unsigned short int dct_coeff_first[256] =
		333	{
		334	0xffff, 0xffff, 0xffff, 0xffff,
		335	0xf7d5, 0xf7d5, 0xf7d5, 0xf7d5,
		336	0x0826, 0x0826, 0x2416, 0x2416,
		337	0x0046, 0x0046, 0x2016, 0x2016,
		338	0x1c15, 0x1c15, 0x1c15, 0x1c15,
		339	0x1815, 0x1815, 0x1815, 0x1815,
		340	0x0425, 0x0425, 0x0425, 0x0425,
		341	0x1415, 0x1415, 0x1415, 0x1415,
		342	0x3417, 0x0067, 0x3017, 0x2c17,
		343	0x0c27, 0x0437, 0x0057, 0x2817,
		344	0x0034, 0x0034, 0x0034, 0x0034,
		345	0x0034, 0x0034, 0x0034, 0x0034,
		346	0x1014, 0x1014, 0x1014, 0x1014,
		347	0x1014, 0x1014, 0x1014, 0x1014,
		348	0x0c14, 0x0c14, 0x0c14, 0x0c14,
		349	0x0c14, 0x0c14, 0x0c14, 0x0c14,
		350	0x0023, 0x0023, 0x0023, 0x0023,
		351	0x0023, 0x0023, 0x0023, 0x0023,
		352	0x0023, 0x0023, 0x0023, 0x0023,
		353	0x0023, 0x0023, 0x0023, 0x0023,
		354	0x0813, 0x0813, 0x0813, 0x0813,
		355	0x0813, 0x0813, 0x0813, 0x0813,
		356	0x0813, 0x0813, 0x0813, 0x0813,
		357	0x0813, 0x0813, 0x0813, 0x0813,
		358	0x0412, 0x0412, 0x0412, 0x0412,
		359	0x0412, 0x0412, 0x0412, 0x0412,
		360	0x0412, 0x0412, 0x0412, 0x0412,
		361	0x0412, 0x0412, 0x0412, 0x0412,
		362	0x0412, 0x0412, 0x0412, 0x0412,
		363	0x0412, 0x0412, 0x0412, 0x0412,
		364	0x0412, 0x0412, 0x0412, 0x0412,
		365	0x0412, 0x0412, 0x0412, 0x0412,
		366	0x0010, 0x0010, 0x0010, 0x0010,
		367	0x0010, 0x0010, 0x0010, 0x0010,
		368	0x0010, 0x0010, 0x0010, 0x0010,
		369	0x0010, 0x0010, 0x0010, 0x0010,
		370	0x0010, 0x0010, 0x0010, 0x0010,
		371	0x0010, 0x0010, 0x0010, 0x0010,
		372	0x0010, 0x0010, 0x0010, 0x0010,
		373	0x0010, 0x0010, 0x0010, 0x0010,
		374	0x0010, 0x0010, 0x0010, 0x0010,
		375	0x0010, 0x0010, 0x0010, 0x0010,
		376	0x0010, 0x0010, 0x0010, 0x0010,
		377	0x0010, 0x0010, 0x0010, 0x0010,
		378	0x0010, 0x0010, 0x0010, 0x0010,
		379	0x0010, 0x0010, 0x0010, 0x0010,
		380	0x0010, 0x0010, 0x0010, 0x0010,
		381	0x0010, 0x0010, 0x0010, 0x0010,
		382	0x0010, 0x0010, 0x0010, 0x0010,
		383	0x0010, 0x0010, 0x0010, 0x0010,
		384	0x0010, 0x0010, 0x0010, 0x0010,
		385	0x0010, 0x0010, 0x0010, 0x0010,
		386	0x0010, 0x0010, 0x0010, 0x0010,
		387	0x0010, 0x0010, 0x0010, 0x0010,
		388	0x0010, 0x0010, 0x0010, 0x0010,
		389	0x0010, 0x0010, 0x0010, 0x0010,
		390	0x0010, 0x0010, 0x0010, 0x0010,
		391	0x0010, 0x0010, 0x0010, 0x0010,
		392	0x0010, 0x0010, 0x0010, 0x0010,
		393	0x0010, 0x0010, 0x0010, 0x0010,
		394	0x0010, 0x0010, 0x0010, 0x0010,
		395	0x0010, 0x0010, 0x0010, 0x0010,
		396	0x0010, 0x0010, 0x0010, 0x0010,
		397	0x0010, 0x0010, 0x0010, 0x0010,
		398	};
		399
		400	/* Macro for filling up the decoding table for mb_addr_inc */
		401	#define ASSIGN1(start, end, step, val, num) \
		402	for (i = start; i < end; i+= step) { \
		403	for (j = 0; j < step; j++) { \
		404	mb_addr_inc[i+j].value = val; \
		405	mb_addr_inc[i+j].num_bits = num; \
		406	} \
		407	val--; \
		408	}
		409
		410
		411
		412	/*
		413	*--------------------------------------------------------------
		414	*
		415	* init_mb_addr_inc --
		416	*
		417	* Initialize the VLC decoding table for macro_block_address_increment
		418	*
		419	* Results:
		420	* The decoding table for macro_block_address_increment will
		421	* be filled; illegal values will be filled as ERROR.
		422	*
		423	* Side effects:
		424	* The global array mb_addr_inc will be filled.
		425	*
		426	*--------------------------------------------------------------
		427	*/
		428	static void
		429	init_mb_addr_inc()
		430	{
		431	int i, j, val;
		432
		433	for (i = 0; i < 8; i++) {
		434	mb_addr_inc[i].value = ERROR;
		435	mb_addr_inc[i].num_bits = 0;
		436	}
		437
		438	mb_addr_inc[8].value = MACRO_BLOCK_ESCAPE;
		439	mb_addr_inc[8].num_bits = 11;
		440
		441	for (i = 9; i < 15; i++) {
		442	mb_addr_inc[i].value = ERROR;
		443	mb_addr_inc[i].num_bits = 0;
		444	}
		445
		446	mb_addr_inc[15].value = MACRO_BLOCK_STUFFING;
		447	mb_addr_inc[15].num_bits = 11;
		448
		449	for (i = 16; i < 24; i++) {
		450	mb_addr_inc[i].value = ERROR;
		451	mb_addr_inc[i].num_bits = 0;
		452	}
		453
		454	val = 33;
		455
		456	ASSIGN1(24, 36, 1, val, 11);
		457	ASSIGN1(36, 48, 2, val, 10);
		458	ASSIGN1(48, 96, 8, val, 8);
		459	ASSIGN1(96, 128, 16, val, 7);
		460	ASSIGN1(128, 256, 64, val, 5);
		461	ASSIGN1(256, 512, 128, val, 4);
		462	ASSIGN1(512, 1024, 256, val, 3);
		463	ASSIGN1(1024, 2048, 1024, val, 1);
		464	}
		465
		466
		467	/* Macro for filling up the decoding table for mb_type */
		468	#define ASSIGN2(start, end, quant, motion_forward, motion_backward, pattern, intra, num, mb_type) \
		469	for (i = start; i < end; i ++) { \
		470	mb_type[i].mb_quant = quant; \
		471	mb_type[i].mb_motion_forward = motion_forward; \
		472	mb_type[i].mb_motion_backward = motion_backward; \
		473	mb_type[i].mb_pattern = pattern; \
		474	mb_type[i].mb_intra = intra; \
		475	mb_type[i].num_bits = num; \
		476	}
		477
		478
		479
		480	/*
		481	*--------------------------------------------------------------
		482	*
		483	* init_mb_type_P --
		484	*
		485	* Initialize the VLC decoding table for macro_block_type in
		486	* predictive-coded pictures.
		487	*
		488	* Results:
		489	* The decoding table for macro_block_type in predictive-coded
		490	* pictures will be filled; illegal values will be filled as ERROR.
		491	*
		492	* Side effects:
		493	* The global array mb_type_P will be filled.
		494	*
		495	*--------------------------------------------------------------
		496	*/
		497	static void
		498	init_mb_type_P()
		499	{
		500	int i;
		501
		502	mb_type_P[0].mb_quant = mb_type_P[0].mb_motion_forward
		503	= mb_type_P[0].mb_motion_backward = mb_type_P[0].mb_pattern
		504	= mb_type_P[0].mb_intra = ERROR;
		505	mb_type_P[0].num_bits = 0;
		506
		507	ASSIGN2(1, 2, 1, 0, 0, 0, 1, 6, mb_type_P)
		508	ASSIGN2(2, 4, 1, 0, 0, 1, 0, 5, mb_type_P)
		509	ASSIGN2(4, 6, 1, 1, 0, 1, 0, 5, mb_type_P);
		510	ASSIGN2(6, 8, 0, 0, 0, 0, 1, 5, mb_type_P);
		511	ASSIGN2(8, 16, 0, 1, 0, 0, 0, 3, mb_type_P);
		512	ASSIGN2(16, 32, 0, 0, 0, 1, 0, 2, mb_type_P);
		513	ASSIGN2(32, 64, 0, 1, 0, 1, 0, 1, mb_type_P);
		514	}
		515
		516
		517
		518
		519	/*
		520	*--------------------------------------------------------------
		521	*
		522	* init_mb_type_B --
		523	*
		524	* Initialize the VLC decoding table for macro_block_type in
		525	* bidirectionally-coded pictures.
		526	*
		527	* Results:
		528	* The decoding table for macro_block_type in bidirectionally-coded
		529	* pictures will be filled; illegal values will be filled as ERROR.
		530	*
		531	* Side effects:
		532	* The global array mb_type_B will be filled.
		533	*
		534	*--------------------------------------------------------------
		535	*/
		536	static void
		537	init_mb_type_B()
		538	{
		539	int i;
		540
		541	mb_type_B[0].mb_quant = mb_type_B[0].mb_motion_forward
		542	= mb_type_B[0].mb_motion_backward = mb_type_B[0].mb_pattern
		543	= mb_type_B[0].mb_intra = ERROR;
		544	mb_type_B[0].num_bits = 0;
		545
		546	ASSIGN2(1, 2, 1, 0, 0, 0, 1, 6, mb_type_B);
		547	ASSIGN2(2, 3, 1, 0, 1, 1, 0, 6, mb_type_B);
		548	ASSIGN2(3, 4, 1, 1, 0, 1, 0, 6, mb_type_B);
		549	ASSIGN2(4, 6, 1, 1, 1, 1, 0, 5, mb_type_B);
		550	ASSIGN2(6, 8, 0, 0, 0, 0, 1, 5, mb_type_B);
		551	ASSIGN2(8, 12, 0, 1, 0, 0, 0, 4, mb_type_B);
		552	ASSIGN2(12, 16, 0, 1, 0, 1, 0, 4, mb_type_B);
		553	ASSIGN2(16, 24, 0, 0, 1, 0, 0, 3, mb_type_B);
		554	ASSIGN2(24, 32, 0, 0, 1, 1, 0, 3, mb_type_B);
		555	ASSIGN2(32, 48, 0, 1, 1, 0, 0, 2, mb_type_B);
		556	ASSIGN2(48, 64, 0, 1, 1, 1, 0, 2, mb_type_B);
		557	}
		558
		559
		560	/* Macro for filling up the decoding tables for motion_vectors */
		561	#define ASSIGN3(start, end, step, val, num) \
		562	for (i = start; i < end; i+= step) { \
		563	for (j = 0; j < step / 2; j++) { \
		564	motion_vectors[i+j].code = val; \
		565	motion_vectors[i+j].num_bits = num; \
		566	} \
		567	for (j = step / 2; j < step; j++) { \
		568	motion_vectors[i+j].code = -val; \
		569	motion_vectors[i+j].num_bits = num; \
		570	} \
		571	val--; \
		572	}
		573
		574
		575
		576	/*
		577	*--------------------------------------------------------------
		578	*
		579	* init_motion_vectors --
		580	*
		581	* Initialize the VLC decoding table for the various motion
		582	* vectors, including motion_horizontal_forward_code,
		583	* motion_vertical_forward_code, motion_horizontal_backward_code,
		584	* and motion_vertical_backward_code.
		585	*
		586	* Results:
		587	* The decoding table for the motion vectors will be filled;
		588	* illegal values will be filled as ERROR.
		589	*
		590	* Side effects:
		591	* The global array motion_vector will be filled.
		592	*
		593	*--------------------------------------------------------------
		594	*/
		595	static void
		596	init_motion_vectors()
		597	{
		598	int i, j, val = 16;
		599
		600	for (i = 0; i < 24; i++) {
		601	motion_vectors[i].code = ERROR;
		602	motion_vectors[i].num_bits = 0;
		603	}
		604
		605	ASSIGN3(24, 36, 2, val, 11);
		606	ASSIGN3(36, 48, 4, val, 10);
		607	ASSIGN3(48, 96, 16, val, 8);
		608	ASSIGN3(96, 128, 32, val, 7);
		609	ASSIGN3(128, 256, 128, val, 5);
		610	ASSIGN3(256, 512, 256, val, 4);
		611	ASSIGN3(512, 1024, 512, val, 3);
		612	ASSIGN3(1024, 2048, 1024, val, 1);
		613	}
		614
		615
		616
		617	extern void init_pre_idct();
		618
		619
		620	/*
		621	*--------------------------------------------------------------
		622	*
		623	* init_tables --
		624	*
		625	* Initialize all the tables for VLC decoding; this must be
		626	* called when the system is set up before any decoding can
		627	* take place.
		628	*
		629	* Results:
		630	* All the decoding tables will be filled accordingly.
		631	*
		632	* Side effects:
		633	* The corresponding global array for each decoding table
		634	* will be filled.
		635	*
		636	*--------------------------------------------------------------
		637	*/
		638	void
		639	init_tables()
		640	{
		641
		642	init_mb_addr_inc();
		643	init_mb_type_P();
		644	init_mb_type_B();
		645	init_motion_vectors();
		646
		647	#ifdef FLOATDCT
		648	if (qualityFlag)
		649	init_float_idct();
		650	else
		651	#endif
		652	init_pre_idct();
		653
		654	#ifdef ANALYSIS
		655	{
		656	init_stats();
		657	}
		658	#endif
		659	}
		660
		661	#if OLDCODE
		662
		663	/*
		664	*--------------------------------------------------------------
		665	*
		666	* DecodeDCTDCSizeLum --
		667	*
		668	* Huffman Decoder for dct_dc_size_luminance; location where
		669	* the result of decoding will be placed is passed as argument.
		670	* The decoded values are obtained by doing a table lookup on
		671	* dct_dc_size_luminance.
		672	*
		673	* Results:
		674	* The decoded value for dct_dc_size_luminance or ERROR for
		675	* unbound values will be placed in the location specified.
		676	*
		677	* Side effects:
		678	* Bit stream is irreversibly parsed.
		679	*
		680	*--------------------------------------------------------------
		681	*/
		682	void
		683	decodeDCTDCSizeLum(value)
		684	unsigned int *value;
		685	{
		686	unsigned int index;
		687
		688	show_bits5(index);
		689
		690	if (index < 31) {
		691	*value = dct_dc_size_luminance[index].value;
		692	flush_bits(dct_dc_size_luminance[index].num_bits);
		693	}
		694	else {
		695	show_bits9(index);
		696	index -= 0x1f0;
		697	*value = dct_dc_size_luminance1[index].value;
		698	flush_bits(dct_dc_size_luminance1[index].num_bits);
		699	}
		700	}
		701
		702
		703
		704
		705	/*
		706	*--------------------------------------------------------------
		707	*
		708	* DecodeDCTDCSizeChrom --
		709	*
		710	* Huffman Decoder for dct_dc_size_chrominance; location where
		711	* the result of decoding will be placed is passed as argument.
		712	* The decoded values are obtained by doing a table lookup on
		713	* dct_dc_size_chrominance.
		714	*
		715	* Results:
		716	* The decoded value for dct_dc_size_chrominance or ERROR for
		717	* unbound values will be placed in the location specified.
		718	*
		719	* Side effects:
		720	* Bit stream is irreversibly parsed.
		721	*
		722	*--------------------------------------------------------------
		723	*/
		724	void
		725	decodeDCTDCSizeChrom(value)
		726	unsigned int *value;
		727	{
		728	unsigned int index;
		729
		730	show_bits5(index);
		731
		732	if (index < 31) {
		733	*value = dct_dc_size_chrominance[index].value;
		734	flush_bits(dct_dc_size_chrominance[index].num_bits);
		735	}
		736	else {
		737	show_bits10(index);
		738	index -= 0x3e0;
		739	*value = dct_dc_size_chrominance1[index].value;
		740	flush_bits(dct_dc_size_chrominance1[index].num_bits);
		741	}
		742	}
		743
		744
		745
		746	/*
		747	*--------------------------------------------------------------
		748	*
		749	* decodeDCTCoeff --
		750	*
		751	* Huffman Decoder for dct_coeff_first and dct_coeff_next;
		752	* locations where the results of decoding: run and level, are to
		753	* be placed and also the type of DCT coefficients, either
		754	* dct_coeff_first or dct_coeff_next, are being passed as argument.
		755	*
		756	* The decoder first examines the next 8 bits in the input stream,
		757	* and perform according to the following cases:
		758	*
		759	* '0000 0000' - examine 8 more bits (i.e. 16 bits total) and
		760	* perform a table lookup on dct_coeff_tbl_0.
		761	* One more bit is then examined to determine the sign
		762	* of level.
		763	*
		764	* '0000 0001' - examine 4 more bits (i.e. 12 bits total) and
		765	* perform a table lookup on dct_coeff_tbl_1.
		766	* One more bit is then examined to determine the sign
		767	* of level.
		768	*
		769	* '0000 0010' - examine 2 more bits (i.e. 10 bits total) and
		770	* perform a table lookup on dct_coeff_tbl_2.
		771	* One more bit is then examined to determine the sign
		772	* of level.
		773	*
		774	* '0000 0011' - examine 2 more bits (i.e. 10 bits total) and
		775	* perform a table lookup on dct_coeff_tbl_3.
		776	* One more bit is then examined to determine the sign
		777	* of level.
		778	*
		779	* otherwise - perform a table lookup on dct_coeff_tbl. If the
		780	* value of run is not ESCAPE, extract one more bit
		781	* to determine the sign of level; otherwise 6 more
		782	* bits will be extracted to obtain the actual value
		783	* of run , and then 8 or 16 bits to get the value of level.
		784	*
		785	*
		786	*
		787	* Results:
		788	* The decoded values of run and level or ERROR for unbound values
		789	* are placed in the locations specified.
		790	*
		791	* Side effects:
		792	* Bit stream is irreversibly parsed.
		793	*
		794	*--------------------------------------------------------------
		795	*/
		796	static void
		797	decodeDCTCoeff(dct_coeff_tbl, run, level)
		798	unsigned short int *dct_coeff_tbl;
		799	unsigned int *run;
		800	int *level;
		801	{
		802	unsigned int temp, index /, num_bits /;
		803	unsigned int value, next32bits, flushed;
		804
		805	/*
		806	* Grab the next 32 bits and use it to improve performance of
		807	* getting the bits to parse. Thus, calls are translated as:
		808	*
		809	* show_bitsX <--> next32bits >> (32-X)
		810	* get_bitsX <--> val = next32bits >> (32-flushed-X);
		811	* flushed += X;
		812	* next32bits &= bitMask[flushed];
		813	* flush_bitsX <--> flushed += X;
		814	* next32bits &= bitMask[flushed];
		815	*
		816	*/
		817	show_bits32(next32bits);
		818	flushed = 0;
		819
		820	/* show_bits8(index); */
		821	index = next32bits >> 24;
		822
		823	if (index > 3) {
		824	value = dct_coeff_tbl[index];
		825	*run = (value & RUN_MASK) >> RUN_SHIFT;
		826	if (*run == END_OF_BLOCK) {
		827	*level = END_OF_BLOCK;
		828	}
		829	else {
		830	/* num_bits = (value & NUM_MASK) + 1; */
		831	/* flush_bits(num_bits); */
		832	flushed = (value & NUM_MASK) + 1;
		833	next32bits &= bitMask[flushed];
		834	if (*run != ESCAPE) {
		835	*level = (value & LEVEL_MASK) >> LEVEL_SHIFT;
		836	/* get_bits1(value); */
		837	/* if (value) level = -level; */
		838	if (next32bits >> (31-flushed)) level = -level;
		839	flushed++;
		840	/* next32bits &= bitMask[flushed]; last op before update */
		841	}
		842	else { /* run == ESCAPE /
		843	/* get_bits14(temp); */
		844	temp = next32bits >> (18-flushed);
		845	flushed += 14;
		846	next32bits &= bitMask[flushed];
		847	*run = temp >> 8;
		848	temp &= 0xff;
		849	if (temp == 0) {
		850	/* get_bits8(level); /
		851	*level = next32bits >> (24-flushed);
		852	flushed += 8;
		853	/* next32bits &= bitMask[flushed]; last op before update */
		854	assert(*level >= 128);
		855	} else if (temp != 128) {
		856	/* Grab sign bit */
		857	*level = ((int) (temp << 24)) >> 24;
		858	} else {
		859	/* get_bits8(level); /
		860	*level = next32bits >> (24-flushed);
		861	flushed += 8;
		862	/* next32bits &= bitMask[flushed]; last op before update */
		863	level = level - 256;
		864	assert(level <= -128 && level >= -255);
		865	}
		866	}
		867	/* Update bitstream... */
		868	flush_bits(flushed);
		869	}
		870	}
		871	else {
		872	if (index == 2) {
		873	/* show_bits10(index); */
		874	index = next32bits >> 22;
		875	value = dct_coeff_tbl_2[index & 3];
		876	}
		877	else if (index == 3) {
		878	/* show_bits10(index); */
		879	index = next32bits >> 22;
		880	value = dct_coeff_tbl_3[index & 3];
		881	}
		882	else if (index) { /* index == 1 */
		883	/* show_bits12(index); */
		884	index = next32bits >> 20;
		885	value = dct_coeff_tbl_1[index & 15];
		886	}
		887	else { /* index == 0 */
		888	/* show_bits16(index); */
		889	index = next32bits >> 16;
		890	value = dct_coeff_tbl_0[index & 255];
		891	}
		892	*run = (value & RUN_MASK) >> RUN_SHIFT;
		893	*level = (value & LEVEL_MASK) >> LEVEL_SHIFT;
		894
		895	/*
		896	* Fold these operations together to make it fast...
		897	*/
		898	/* num_bits = (value & NUM_MASK) + 1; */
		899	/* flush_bits(num_bits); */
		900	/* get_bits1(value); */
		901	/* if (value) level = -level; */
		902
		903	flushed = (value & NUM_MASK) + 2;
		904	if ((next32bits >> (32-flushed)) & 0x1) level = -level;
		905
		906	/* Update bitstream ... */
		907	flush_bits(flushed);
		908	}
		909	}
		910
		911
		912	/*
		913	*--------------------------------------------------------------
		914	*
		915	* decodeDCTCoeffFirst --
		916	*
		917	* Huffman Decoder for dct_coeff_first. Locations for the
		918	* decoded results: run and level, are being passed as
		919	* arguments. Actual work is being done by calling DecodeDCTCoeff,
		920	* with the table dct_coeff_first.
		921	*
		922	* Results:
		923	* The decoded values of run and level for dct_coeff_first or
		924	* ERROR for unbound values are placed in the locations given.
		925	*
		926	* Side effects:
		927	* Bit stream is irreversibly parsed.
		928	*
		929	*--------------------------------------------------------------
		930	*/
		931	void
		932	decodeDCTCoeffFirst(run, level)
		933	unsigned int *run;
		934	int *level;
		935	{
		936	decodeDCTCoeff(dct_coeff_first, run, level);
		937	}
		938
		939
		940
		941
		942	/*
		943	*--------------------------------------------------------------
		944	*
		945	* decodeDCTCoeffNext --
		946	*
		947	* Huffman Decoder for dct_coeff_first. Locations for the
		948	* decoded results: run and level, are being passed as
		949	* arguments. Actual work is being done by calling DecodeDCTCoeff,
		950	* with the table dct_coeff_next.
		951	*
		952	* Results:
		953	* The decoded values of run and level for dct_coeff_next or
		954	* ERROR for unbound values are placed in the locations given.
		955	*
		956	* Side effects:
		957	* Bit stream is irreversibly parsed.
		958	*
		959	*--------------------------------------------------------------
		960	*/
		961	void
		962	decodeDCTCoeffNext(run, level)
		963	unsigned int *run;
		964	int *level;
		965	{
		966	decodeDCTCoeff(dct_coeff_next, run, level);
		967	}
		968	#endif

Subversion Repositories shark

(root)/shark/branches/pj/ports/mpeg/decoders.c - Rev 2