hi_jpegdecode.c

华为 HI3510 BOOTLOADER HIBOOT 源码包

	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();
	//printf("funcret_decodemcublock = %x\n",funcret);
	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 = sizej + (UINT32)(SampRate_Y_H << 3);
		if(sizej >= ImgWidth)
        {
			sizej = 0;
			sizei = sizei + (UINT32)(SampRate_Y_V << 3);
		}
		if ((sizej == 0) && (sizei >= ImgHeight)) 
		{
			break;
        }

        funcret = DecodeMCUBlock();
    
    }

	return funcret;	
}

/**********************************************************************
   入口 QtZzMCUBuffer 出口 Y[] U[] V[]
**********************************************************************/
void GetYUV(int flag)
{
    int H,VV,i,j,k,hk;
    int temp;
    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 = pQtZzMCU + (Y_in_MCU << 6);
            break;
        case 2:                            /* 蓝色分量 */
    		H = SampRate_V_H;
    		VV = SampRate_V_V;
    		buf = V;
    		pQtZzMCU = QtZzMCUBuffer;
            pQtZzMCU = 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 = tempbuf + temp;
                   	*tempbuf = (int)(*(pQtZzMCU++));

                }
            }
        }
    }
}

/********************************************************************************
    将解出的字按RGB形式存储 lpbmp (BGR),(BGR) ......入口Y[] U[] V[] 出口lpPtr
*********************************************************************************/
void StoreBuffer(void)
{
    int i,j;
    UINT8 *lprgb;
    UINT8 R,G,B;
    int yy,uu,vv,rr,gg,bb;
    int TempSamp1,TempSamp2;
    TempSamp1 = SampRate_Y_V << 3;
    TempSamp2 = SampRate_Y_H << 3;
    int *pY;
    int *pU;
    int *pV;

    for(i = 0;i < TempSamp1;i++)
   	{                                  /* sizei表示行 sizej 表示列 */
		if((sizei + i) < ImgHeight)
        {
			/*lpbmp = lpPtr + (UINT32)((ImgHeight - sizei - (UINT32)(i) - 1) * LineBytes + sizej * 3);*/
			lprgb = lpPtr + ( (sizei + i) * LineBytes + (sizej << 1) );

			pY=Y+i*TempSamp2;// (i << 3) * SampRate_Y_H;
			pU=U+(i / V_YtoU)*TempSamp2;// << 3) * SampRate_Y_H;
			pV=V+(i / V_YtoV)*TempSamp2;// << 3) * SampRate_Y_H;

			for(j = 0;j < TempSamp2;j++)
            		{
				if((sizej + j) < ImgWidth)
                		{
					yy = *pY++;

					uu = pU[ j/H_YtoU ];  /* 内插 */

					vv = pV[ 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)
{
    int *lpMCUBuffer;
    int i,j;
    int funcret=0;
    int tempX;
	if(IntervalFlag == HI_OK)
    {
		lp += 2;
		ycoef = 0;   /* 差值复位 */
        ucoef = 0;
        vcoef = 0;
		BitPos = 0;
		CurByte = 0;
	}
	//printf("comp_num = %x\n", comp_num); 
	switch(comp_num)
    {                             /* comp_num 指图的类型（彩色图、灰度图）*/
	  
	    case 3:   /* 彩色图 */
    		lpMCUBuffer = MCUBuffer;
    		tempX = SampRate_Y_H * SampRate_Y_V;
    		for(i = 0;i < tempX;i++)   /* Y */
    		{
    			funcret = HufBlock(YDcIndex,YAcIndex);   /* 解码4 * (8*8) */
    			if(funcret != FUNC_OK)
                {
                	printf("funcret1 = %x\n", funcret);
    				return funcret;
                }
                BlockBuffer[0] = BlockBuffer[0] + ycoef;   /* 直流分量是差值，所以要累加。*/
    			ycoef = BlockBuffer[0];
    			for(j = 0;j < 64;j++)
                {
    				*lpMCUBuffer++ = BlockBuffer[j];
                }
    		}
    		tempX = SampRate_U_H * SampRate_U_V;
    		for(i = 0;i < tempX;i++)    /* U */
    		{
    			funcret = HufBlock(UVDcIndex,UVAcIndex);
    			if(funcret != FUNC_OK)
                {
                    printf("funcret2 = %x\n", funcret);
                    return funcret;
                }
    			BlockBuffer[0] = BlockBuffer[0] + ucoef;
    			ucoef = BlockBuffer[0];
    			for(j = 0;j < 64;j++)
                {      
    				*lpMCUBuffer++ = BlockBuffer[j];
                }
    		}
    		tempX = SampRate_V_H * SampRate_V_V;
    		for(i = 0;i < tempX;i++)  /* V */
    		{
    			funcret = HufBlock(UVDcIndex,UVAcIndex);
    			if(funcret != FUNC_OK) 
                {
    				
    				printf("funcret3 = %x\n", funcret);
    				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:
    		// printf("comp_num1 = %x\n", comp_num); 
    		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
        {       
			for(i = 0;i < rrun;i++)    /* 前面的零 */
            {
				BlockBuffer[count++] = 0;
            }
			BlockBuffer[count++] = vvalue;/* 解出的值 */
		}
	}
    return FUNC_OK;
}

/**************************************************************************
   Huffman 解码  每个元素   出口 vvalue 入口 读文件ReadByte
***************************************************************************/
int DecodeElement(void)
{