parse.c

jpeg快速算法,用于TI和philips的DSP开发

/*
 *********************************************************************
 * File name: parse.c
 * Version: 5.0(release v1.0)    Date: Jan 12, 2006
 * Author:  xiezm                Email: [e-mail]
 * Company: Wuxi Intech co., ltd.
 *
 * Project: Jpeg Decoder for Trio
 *********************************************************************
 */
#define PARSE_GLOBALS

#include "cf6_chess.h"

#include "djpg.h"

const int aanscales[DCT_SIZE2] =
{
	4096, 5681, 5681, 5351, 7880, 5351, 4816, 7423,
	7423, 4816, 4096, 6680, 6992, 6680, 4096, 3218,
	5681, 6293, 6293, 5681, 3218, 2216, 4463, 5351,
	5663, 5351, 4463, 2216, 1130, 3074, 4204, 4816,
	4816, 4204, 3074, 1130, 1567, 2896, 3784, 4096,
	3784, 2896, 1567, 1476, 2606, 3218, 3218, 2606,
	1476, 1328, 2216, 2528, 2216, 1328, 1130, 1741,
	1741, 1130, 888,  1199, 888,  611,  611,  311
};

extern int jpegFrameSymbol;


void derive_huffman_tbl(void);
void derive_quant_tbl(void);

void parse_initial(void)
{
	dri_rst_interval = 0;
}

void parse_header(void)
{
	unsigned int i;
	unsigned int marker;
	unsigned int f;
	unsigned int s;

	marker = 0;

	
	/* parse other headers */
	do
	{
		if(0xff != get_byte())
		{
			error(2);
		}
		marker = get_byte();
		switch(marker)
		{
			case DHT:
				derive_huffman_tbl();
				break;
			case DQT:
				derive_quant_tbl();
				break;
			case DRI:
				get_word();			//DRI length
				dri_rst_interval = get_word();
				break;
			case SOF0:
				get_word();			//frame header length
				if(8 != get_byte())
				{
				   	error(3);
				}
				Y = get_word();
				X = get_word();
				Nf = get_byte();
				if((1!=Nf) && (3!=Nf))
				{
					error(4);
				}
				for(f=0; f<Nf; f++)
				{
					unsigned int hv;
					Ci[f] = get_byte();
					hv = get_byte();
					Hi[f] = hv >> 4;
					Vi[f] = hv & 0x0f;
					hv = Tqi[f] = get_byte();
					if(hv>3)
					{
						error(5);
					}
				}
				num_mcu = ((X-1)/(8*Hi[0]) + 1) * ((Y-1)/(8*Vi[0]) + 1);	//
				break;
			case SOS:
				get_word();			//scan header length
				Ns = get_byte();
				if(Nf != Ns)
				{
					error(6);
				}
				for(s=0; s<Ns; s++)
				{
					unsigned int da;
					Csi[s] = get_byte();
					da = get_byte();
					Tdi[s] = da >> 4;
					Tai[s] = da & 0x0f;
					if((Tdi[s]>1) || (Tai[s]>1))
					{
						error(7);
					}
				}
				if(0 != get_byte())
				{
					error(8);
				}
				if(63 != get_byte())
				{
					error(9);
				}
				if(0 != get_byte())
				{
					error(10);
				}
				return;
			default:
				for(i = get_word() - 2; i>0; i--)
				{
					get_byte();
				}
				break;
		}
		
	}while(1);
}

void derive_huffman_tbl(void)
{
	unsigned int Lh;
	unsigned int Tc;
	unsigned int Th;
	unsigned int Li[17];
	DERIVED_H_TBL *dtbl;
	
	unsigned int Lsum;
	unsigned int i;
	unsigned int Huffsize[257];
	unsigned int code;
	unsigned int si;
	unsigned int p;
	unsigned int l;
	unsigned int Huffcode[257];
	
	for(Lh=get_word()-2;Lh>0;Lh-=17)
	{
		unsigned int Tch;
		Tch = get_byte();
		Tc = Tch >> 4;
		Th = Tch & 0x0f;
		if(Tc)
		{				//AC huffman table
			dtbl = &ac_huff_tbl[Th];
		}
		else
		{				//DC huffman table
			dtbl = &dc_huff_tbl[Th];
		}
		for(i=1;i<=16;i++)
		{
			Li[i] = get_byte();
		}
		for(Lsum=0,i=1;i<=16;i++)
		{
			unsigned int L;
			L = Li[i];
			while(L--)
			{
				dtbl->symbol[Lsum] = get_byte();
				Huffsize[Lsum++] = i;
			}
		}
		Lh -= Lsum;			//length
		if(Lsum>256)
		{
			error(11);
		}
		Huffsize[Lsum] = 0;
		
		code = 0;
		si = Huffsize[0];
		i = 0;
		while (Huffsize[i])
		{
			while (Huffsize[i] == si)
			{
				Huffcode[i++] = code;
				code++;
			}
			if ( code >= (unsigned int)(1 << si))
			{
				error(12);
			}
			code <<= 1;
			si++;
		}

		p = 0;
		for (i=1;i<=16;i++)
		{
			if (Li[i])
			{
				dtbl->valoffset[i] = (int) p - (int) Huffcode[p];
				p += Li[i];
				dtbl->maxcode[i] = Huffcode[p - 1];
			}
			else
			{
				dtbl->maxcode[i] = -1;
			}
		}
		dtbl->maxcode[17] = 0x0FFFFF;
		
		//look ahead
		for(i=0;i<256;i++)
		{
			dtbl->look_nbits[i] = 0;
		}

		p = 0;
		for (l = 1; l<=8; l++)
		{
			for (i = 1; i <= Li[l]; i++, p++)
			{
				unsigned int lookbits;
				unsigned int ctr;
				lookbits = Huffcode[p] << (8 - l);
				for (ctr = 1 << (8 - l); ctr > 0; ctr--)
				{
					dtbl->look_nbits[lookbits] = l;
					dtbl->look_sym[lookbits] = dtbl->symbol[p];
					lookbits++;
				}
			}
		}

		if(!Tc)
		{
			for (i = 0; i < Lsum; i++)
			{
				if (dtbl->symbol[i] > 15)
				{
					error(13);
				}
			}
		}
	}
}

void derive_quant_tbl(void)
{
	unsigned int Lq;
	unsigned int Pq;
	unsigned int Tq;
	unsigned int i;

	for(Lq=get_word()-2;Lq>0;Lq-=65)
	{
		unsigned int PTq;
		PTq = get_byte();
		Pq = PTq >> 4;
		if(Pq)
		{
			error(14);
		}
		Tq = PTq & 0x0f;
		for(i=0; i<DCT_SIZE2; i++)
		{	
			//lost precision here!!
			quant_tbl[Tq][i] = ((get_byte() * aanscales[i]));
		}
	}
}
/********************End of file*************************************/

/*************************************************************
 *  functionname: find_ffd8()			
 *  return value :
 *  0, normal
 *  nonzero, can not header mark 0xffd8 normally 
*************************************************************/
int find_ffd8(void)
{

	int iRet = 0;
	int findCount = 0;
	int jpegFrameSymbol1,jpegFrameSymbol2,jpegFrameSymbol3;
	int header1, header2, header3, header4;

//	header1 = get_byte();
//	header2 = get_byte();
	header3 = get_byte();
	header4 = get_byte();

	// parse SOI 
	while(1)
	{
		if((0xff == header3) && (SOI == header4))
		{
	//		if((header1==0) && (header2==0)) 
			{
				jpegFrameSymbol1 = get_byte();
				jpegFrameSymbol2 = get_byte();
				jpegFrameSymbol3 = get_byte();
				jpegFrameSymbol = jpegFrameSymbol1 + (jpegFrameSymbol2<<8) + (jpegFrameSymbol3<<16);
				break;
			}
		}
	//	header1 = header2;
	//	header2 = header3;
		header3 = header4;
		header4 = get_byte();
		findCount++;
		if(findCount>0x4000)
		{
			iRet = 1;//error(1);
			return iRet;
		}
	}
	return iRet;
}