hi_jpegdecode1.c

华为 HI3510 BOOTLOADER HIBOOT 源码包

    			else
    			{
    			    lp += 2;
    			}                
                break;                 
        }  
    }
    return FUNC_OK;      
}

void InitTable(void)
{
    int i,j;  
	sizei = 0;
    sizej = 0;
	ImgWidth = 0;
    ImgHeight = 0;
	rrun = 0;
    vvalue = 0;
	BitPos = 0;
	CurByte = 0;
	IntervalFlag = HI_ERROR;
	restart = 0;  
	for(i = 0;i < 3;i++)
	{
        for(j = 0;j < 64;j++)
        {
		    qt_table[i][j] = 0;           /* 量化表 */
	    }
	}
	comp_num = 0;
	HufTabIndex = 0;
	for(i = 0;i < 3;i++)
	{
		comp_index[i] = 0;
	}
	for(i = 0;i < 4;i++)
	{
	    for(j = 0;j < 16;j++)
        {
	    	code_len_table[i][j] = 0;
	    	code_pos_table[i][j] = 0;
	    	huf_max_value[i][j] = 0;
	    	huf_min_value[i][j] = 0;
	    }
	}
	for(i = 0;i < 4;i++)
	{
	    for(j = 0;j < 256;j++)
	    {
	        code_value_table[i][j] = 0;
        }  	   
    }
	for(i = 0;i< 640;i++)
    {
		MCUBuffer[i] = 0;
		QtZzMCUBuffer[i] = 0;
	}	    
	for(i = 0;i < 64;i++)
    {
		Y[i] = 0;
		U[i] = 0;
		V[i] = 0;
		BlockBuffer[i] = 0;
	}
	ycoef = 0;
	ucoef = 0;
	vcoef = 0;	
}

/*************************************************************************
调用顺序: Initialize_Fast_IDCT() :初始化
          DecodeMCUBlock()       Huffman Decode
          IQtIZzMCUComponent()   反量化、反DCT
          GetYUV()               Get Y U V
          StoreBuffer()          YUV to RGB
*************************************************************************/
int Decode(void)
{
    int funcret;
    Y_in_MCU = SampRate_Y_H * SampRate_Y_V;     /* YDU YDU YDU YDU */
	U_in_MCU = SampRate_U_H * SampRate_U_V;     /* cRDU */
	V_in_MCU = SampRate_V_H * SampRate_V_V;     /* cBDU */
	H_YtoU = SampRate_Y_H / SampRate_U_H;
	V_YtoU = SampRate_Y_V / SampRate_U_V;
	H_YtoV = SampRate_Y_H / SampRate_V_H;
	V_YtoV = SampRate_Y_V / SampRate_V_V;
	Initialize_Fast_IDCT();
	funcret = DecodeMCUBlock();
	while(funcret == FUNC_OK) 
    {                                          /* After Call DecodeMCUBUBlock() */
		interval++;                             /* The Digital has been Huffman Decoded and */
		if((restart != 0) && ((interval % restart) == 0))   /* be stored in MCUBuffer(YDU,YDU,YDU,YDU */
		{
		    IntervalFlag = HI_OK;                          /* UDU,VDU) Every DU := 8*8 */
		}
		else
		{
			IntervalFlag = HI_ERROR;
		}
		IQtIZzMCUComponent(0);   /* 反量化 and IDCT The Data in QtZzMCUBuffer */
		IQtIZzMCUComponent(1);
		IQtIZzMCUComponent(2);
		GetYUV(0);                    /* 得到Y cR cB */
		GetYUV(1);
		GetYUV(2);
		StoreBuffer();               /* To RGB */
		sizej += (UINT32)(SampRate_Y_H << 3);
		if(sizej >= ImgWidth)
        {
			sizej = 0;
			sizei += (UINT32)(SampRate_Y_V << 3);
		}
		if ((sizej == 0) && (sizei >= ImgHeight)) 
		{
			break;
        }
        funcret = DecodeMCUBlock();
    }
	return funcret;	
}

/**********************************************************************
   入口 QtZzMCUBuffer 出口 Y[] U[] V[]
**********************************************************************/
void GetYUV(short flag)
{
    short H,VV;
    int temp,i,j,k,hk;
    int *buf,*tempbuf,*pQtZzMCU;
    switch(flag)
    {
        case 0:                             /* 亮度分量 */
    		H = SampRate_Y_H;
    		VV = SampRate_Y_V;
    		buf = Y;
    		pQtZzMCU = QtZzMCUBuffer;
            break;
        case 1:                             /* 红色分量 */
    		H = SampRate_U_H;
    		VV = SampRate_U_V;
    		buf = U;
    		pQtZzMCU = QtZzMCUBuffer;
            pQtZzMCU += Y_in_MCU << 6;
            break;
        case 2:                            /* 蓝色分量 */
    		H = SampRate_V_H;
    		VV = SampRate_V_V;
    		buf = V;
    		pQtZzMCU = QtZzMCUBuffer;
            pQtZzMCU += (Y_in_MCU + U_in_MCU) << 6;
            break;
        default:
            H = 0;
            VV = 0;
            buf = NULL;
            pQtZzMCU = NULL;
            break;
    }
    for(i = 0;i < VV;i++)
    {
        for(j = 0;j < H;j++)
        {   
            for(k = 0;k < 8;k++)
            {
                for(hk = 0;hk < 8;hk++)
                {
                    temp = ((i << 3) + k) * (SampRate_Y_H << 3) + (j << 3) + hk;
                    tempbuf = buf;
                    tempbuf += temp;
                   	*tempbuf = (int)(*(pQtZzMCU++));

                }
            }
        }
    }
}

/********************************************************************************
    将解出的字按RGB形式存储 lpbmp (BGR),(BGR) ......入口Y[] U[] V[] 出口lpPtr
*********************************************************************************/
void StoreBuffer(void)
{
    int i,j,tempSamp1,tempSamp2;
    UINT8 *lprgb;
    UINT8 R,G,B;
    int yy,uu,vv,rr,gg,bb;
    tempSamp1 = SampRate_Y_V << 3;
    tempSamp2 = SampRate_Y_H << 3;
	for(i = 0;i < tempSamp1;i++)
    {                                  /* sizei表示行 sizej 表示列 */
		if((sizei + (UINT32)(i)) < ImgHeight)
        {
			/*lpbmp = lpPtr + (UINT32)((ImgHeight - sizei - (UINT32)(i) - 1) * LineBytes + sizej * 3);*/
			lprgb = lpPtr + (UINT32)((sizei + i) * LineBytes + (sizej << 1));
			for(j = 0;j < tempSamp2;j++)
            {
				if((sizej + (UINT32)(j)) < ImgWidth)
                {
					yy = Y[(i << 3) * SampRate_Y_H + j];
					uu = U[((i / V_YtoU) << 3) * SampRate_Y_H + j / H_YtoU];  /* 内插 */
					vv = V[((i / V_YtoV) << 3) * SampRate_Y_H + j / H_YtoV];
					rr = ((yy << 8) + 18 * uu + 367 * vv) >> 8;
					gg = ((yy << 8) - 159 * uu - 220 * vv) >> 8;   
					bb = ((yy << 8) + 411 * uu - 29 * vv) >> 8;
					R = (UINT8)(rr);
					G = (UINT8)(gg);
					B = (UINT8)(bb);
					if((rr && 0xffffff00) != 0) 
					{
                        if (rr > 255)
                        { 
                            R = 255;
                        }
                        else
                        {
                            if(rr < 0) 
                            {
                                R = 0;
                            }
                        }
					}
					if((gg && 0xffffff00) != 0)
					{
                        if(gg > 255)
                        {
                            G = 255;
                        }
                        else
                        {
                            if(gg < 0)
                            {
                                G = 0;
                            }
                        }
                    }
					if((bb && 0xffffff00) != 0)
                    {
                        if(bb > 255)
                        {
                            B = 255;
                        }
                        else
                        {
                            if(bb < 0)
                            { 
                                B = 0;
                            }
                        }
					}
					*lprgb++ = (UINT8)(B >> 3) + (UINT8)((G << 2) & 0xe0);
					*lprgb++ = (UINT8)(G >> 6) + (UINT8)((R >> 1) & 0x7c);
				}
				else
				{
				    break;
				}
			}
		}
		else
		{
		    break;
		}
	}
}

/******************************************************************************
  Huffman Decode   MCU 出口 MCUBuffer  入口Blockbuffer[  ]
*******************************************************************************/
int DecodeMCUBlock(void)
{
    short *lpMCUBuffer;
    int i,j,tempSamp;
    int funcret;
    
	if(IntervalFlag == HI_OK)
    {
		lp += 2;
		ycoef = 0;   /* 差值复位 */
        ucoef = 0;
        vcoef = 0;
		BitPos = 0;
		CurByte = 0;
	}
	switch(comp_num)
    {                             /* comp_num 指图的类型（彩色图、灰度图）*/
	    case 3:   /* 彩色图 */
    		lpMCUBuffer = MCUBuffer;
    		tempSamp = SampRate_Y_H * SampRate_Y_V;
    		for(i = 0;i < tempSamp;i++)   /* Y */
    		{
    			funcret = HufBlock(YDcIndex,YAcIndex);   /* 解码4 * (8*8) */
    			if(funcret != FUNC_OK)
                {
    				return funcret;
                }
                BlockBuffer[0] = BlockBuffer[0] + ycoef;   /* 直流分量是差值，所以要累加。*/
    			ycoef = BlockBuffer[0];
    			for(j = 0;j < 64;j++)
                {
    				*lpMCUBuffer++ = BlockBuffer[j];
                }
    		}
    		tempSamp = SampRate_U_H * SampRate_U_V;
    		for(i = 0;i < tempSamp;i++)    /* U */
    		{
    			funcret = HufBlock(UVDcIndex,UVAcIndex);
    			if(funcret != FUNC_OK)
                {
                    return funcret;
                }
    			BlockBuffer[0] = BlockBuffer[0] + ucoef;
    			ucoef = BlockBuffer[0];
    			for(j = 0;j < 64;j++)
                {      
    				*lpMCUBuffer++ = BlockBuffer[j];
                }
    		}
    		tempSamp = SampRate_V_H * SampRate_V_V;
    		for(i = 0;i < tempSamp;i++)  /* V */
    		{
    			funcret = HufBlock(UVDcIndex,UVAcIndex);
    			if(funcret != FUNC_OK) 
                {
    				return funcret;
                }
    			BlockBuffer[0] = BlockBuffer[0] + vcoef;
    			vcoef = BlockBuffer[0];
    			for(j = 0;j < 64;j++)
                {
    				*lpMCUBuffer++ = BlockBuffer[j];
                }
    		}
            break;
        case 1:   /* Gray Picture */
    		lpMCUBuffer = MCUBuffer;
    		funcret = HufBlock(YDcIndex,YAcIndex);
    		if(funcret != FUNC_OK)
            {
    			return funcret;
            } 
    		BlockBuffer[0] = BlockBuffer[0] + ycoef;
    		ycoef = BlockBuffer[0];
    		for(j = 0;j < 64;j++)
    		{                
    			*lpMCUBuffer++ = BlockBuffer[j];
            }
    		for(i = 0;i < 128;i++)
            {
    			*lpMCUBuffer++ = 0;
            }
            break;
        default:
    		return FUNC_FORMAT_ERROR;
	}
	return FUNC_OK;
}

/*****************************************************************
   Huffman Decode （8*8） DU   出口 Blockbuffer[ ] 入口 vvalue
******************************************************************/
int HufBlock(UINT8 dchufindex,UINT8 achufindex)
{
    int count,i;
    int funcret;

    count = 0;
	/* dc */
	HufTabIndex = dchufindex;
	funcret = DecodeElement();  /* Read Byte Dc */
	if(funcret != FUNC_OK)
    {
		return funcret;
    }
	BlockBuffer[count++] = vvalue;/* 解出的直流系数 */

	/* ac */
	HufTabIndex = achufindex;
	while(count < 64)
    {         /* 63 Bytes AC */
		funcret = DecodeElement();
		if(funcret != FUNC_OK)
        {
			return funcret;
        }
		if((rrun == 0) && (vvalue == 0))
        {
			for(i = count;i < 64;i++)
			{
				BlockBuffer[i] = 0;
			}
			count = 64;
		}
		else