hi_jpegdecode.c

华为 HI3510 BOOTLOADER HIBOOT 源码包

    {
		BitPos--;
		thiscode = (unsigned char)CurByte >> BitPos; /* 取一个比特 */
		CurByte = CurByte & MyAnd[BitPos]; /* 清除取走的比特位 */
	}
	else                                        /* 取出的一个字节已用完 */
    {                                          /* 新取 */
		lastbyte = ReadByte(); /* 读出一个字节 */
		BitPos--;                     /* and[]:=0x0,0x1,0x3,0x7,0xf,0x1f,0x2f,0x3f,0x4f */
		newbyte = CurByte & MyAnd[BitPos];  //
		thiscode = lastbyte >> 7;
		CurByte = newbyte;
	}
	codelen = 1;
/* 与Huffman表中的码字匹配，直自找到为止 */
	while((thiscode < huf_min_value[HufTabIndex][codelen - 1]) ||
		  (code_len_table[HufTabIndex][codelen - 1] == 0) ||
		  (thiscode > huf_max_value[HufTabIndex][codelen - 1])) 
	{
		if(BitPos >= 1)       /* 取出的一个字节还有 */
		{
		   	BitPos--;
			tempcode = (unsigned char)CurByte >> BitPos;
			CurByte = CurByte & MyAnd[BitPos];
		}
		else
        {
			lastbyte = ReadByte();
			BitPos--;
			newbyte = CurByte & MyAnd[BitPos];
			tempcode = (unsigned char)lastbyte >> 7;
			CurByte = newbyte;
		}
		thiscode = (thiscode << 1) + tempcode;
		codelen++;
		if(codelen > 16)
        {
			return FUNC_FORMAT_ERROR;
        }
	}  //while
	temp = thiscode - huf_min_value[HufTabIndex][codelen - 1] + code_pos_table[HufTabIndex][codelen - 1];
	hufexbyte = (unsigned char)code_value_table[HufTabIndex][temp];
	rrun = (int)(hufexbyte >> 4);  /* 一个字节中，高四位是其前面的零的个数。*/
	runsize = hufexbyte & 0x0f;      /* 后四位为后面字的尺寸 */
	if(runsize == 0) 
    {
		vvalue = 0;
		return FUNC_OK;
    }
	tempsize = runsize;
	if(BitPos >= runsize)
    {
		BitPos = BitPos - runsize;
		valueex = (unsigned char)CurByte >> BitPos;
		CurByte = CurByte & MyAnd[BitPos];
	}
	else
    {    
		valueex = CurByte;
		tempsize = tempsize - BitPos;
		while(tempsize > 8) 
        {
			lastbyte = ReadByte();
			valueex = (valueex << 8) + (unsigned char)lastbyte;
			tempsize = tempsize - 8;
		}  //while
		lastbyte = ReadByte();
		BitPos = BitPos - tempsize;
		valueex = (valueex << tempsize) + (lastbyte >> BitPos);
		CurByte = lastbyte & MyAnd[BitPos];
	}  //else
	sign = valueex >> (runsize - 1);
	if(sign != 0) 
	{
		vvalue = valueex;             /* 解出的码值 */
	}
	else
    {
		valueex = valueex ^ 0xffff;
		temp = 0xffff << runsize;
		vvalue = -(int)(valueex ^ temp);
    }
	return FUNC_OK;
}

/************************************************************************************
    反量化MCU中的每个组件   入口 MCUBuffer 出口 QtZzMCUBuffer
*************************************************************************************/
void IQtIZzMCUComponent(int flag)
{
    int H,VV,i,j;
    int *pQtZzMCUBuffer,*tempbuf1;
    int *pMCUBuffer,*tempbuf2;

	switch(flag)
	{
	    case 0:
    		H = SampRate_Y_H;
    		VV = SampRate_Y_V;
    		pMCUBuffer = MCUBuffer;  /* Huffman Decoded */
    		pQtZzMCUBuffer = QtZzMCUBuffer;
            break;
    	case 1:
    		H = SampRate_U_H;
    		VV = SampRate_U_V;
    		pMCUBuffer = MCUBuffer;
            pMCUBuffer += Y_in_MCU << 6;
    		pQtZzMCUBuffer = QtZzMCUBuffer;
            pQtZzMCUBuffer += Y_in_MCU << 6;
            break;
    	case 2:
    		H = SampRate_V_H;
    		VV = SampRate_V_V;
    		pMCUBuffer = MCUBuffer;
            pMCUBuffer += (Y_in_MCU + U_in_MCU) << 6;
    		pQtZzMCUBuffer = QtZzMCUBuffer;
            pQtZzMCUBuffer += (Y_in_MCU + U_in_MCU) << 6;
            break;
        default:
            H = 0;
            pQtZzMCUBuffer = NULL;
            pMCUBuffer = NULL;
            VV = 0;
            break;
    }
	for(i = 0;i < VV;i++)
	{
		for(j = 0;j < H;j++)
        {
            tempbuf2 = pMCUBuffer;
            tempbuf2 += (i * H + j) << 6;
            tempbuf1 = pQtZzMCUBuffer;
            tempbuf1 += (i * H + j) << 6;
		    IQtIZzBlock(tempbuf2,tempbuf1,flag);      /* 8*8DU */
        }
    }
}

             /* 要量化的字 */
/**********************************************************************************
   反量化 8*8 DU
***********************************************************************************/
void IQtIZzBlock(int *s,int *d,int flag)
{
    int i,j,tag;
    int *pQt,*temp1,*temp3;
    int buffer2[8][8];
    int *temp2;
    int offset;

	switch(flag)
	{
    	case 0:                /* 亮度 */
    		pQt = YQtTable;      /* 量化表地址 */
        /* ShowMessage(IntTostr(YQtTable^)); */
    		offset = 128;
            break;
    	case 1:                /* 红 */
    		pQt = UQtTable;
    		offset = 0;
            break;
    	case 2:               /* 蓝 */
    		pQt = VQtTable;
            offset = 0;
            break;
        default:
           pQt = NULL;
           offset = 0;
           break;
	}

	for(i = 0;i < 8;i++)
	{
		for(j = 0;j < 8;j++)
		{
            tag = Zig_Zag[i][j];
            temp1 = s;
            temp1 = temp1 + tag;
            temp3 = pQt;
            temp3 = temp3 + tag;
			buffer2[i][j] = (int)((*temp1) * (*temp3));
		}
    }
	Fast_IDCT(&buffer2[0][0]);    /* 反DCT */
	for(i = 0;i < 8;i++)
	{
		for(j = 0;j < 8;j++)
        {
            temp2 = d;
            temp2 = temp2 + (i * 8 +j);
			*temp2 = buffer2[i][j] + offset;
        }
    }
}

void Fast_IDCT(int *block)
{
	int i;
	for(i = 0;i < 8;i++)
	{
    	idctrow(block + 8 * i);
    }
    for(i = 0;i < 8;i++)
    {
    	idctcol(block + i);
	}
}

unsigned char ReadByte(void)
{
	unsigned char i;

	i = *lp; /* lp 为解码的起始位置 */
    lp = lp + 1;
	if(i == 0xff)
	{
		lp = lp + 1;
	}
    BitPos = 8;
	CurByte = i;
	return i;
}

void Initialize_Fast_IDCT(void)
{
	int i;

	for(i = -512;i < 512;i++)
    {
        if(i < -256)
        {
            iclip[512 + i] = -256;
        }
        if(i > 255)
        {
            iclip[512 + i] = 255;
        }
        if(( i >= -256) && (i <= 255))
        {
            iclip[512 + i] = i;
        }
    }
}

void idctrow(int *blk)
{
	int x0, x1, x2, x3, x4, x5, x6, x7, x8;

	//intcut
    x1 = blk[4] << 11;
    x2 = blk[6];
    x3 = blk[2];
    x4 = blk[1];
    x5 = blk[7];
    x6 = blk[5];
    x7 = blk[3];
    if ((x1 || x2 || x3 || x4 || x5 || x6 || x7) == 0) 
    {
        blk[1] = blk[0] << 3;
        blk[2] = blk[0] << 3;
        blk[3] = blk[0] << 3;
        blk[4] = blk[0] << 3;
        blk[5] = blk[0] << 3;
        blk[6] = blk[0] << 3;
        blk[7] = blk[0] << 3;
        blk[0] = blk[0] << 3;
        return;
    }
	x0 = (blk[0] << 11) + 128; /* for proper rounding in the fourth stage */
	/* first stage */
	x8 = W7 * (x4 + x5);
	x4 = x8 + (W1 - W7) * x4;
	x5 = x8 - (W1 + W7) * x5;
	x8 = W3 * (x6 + x7);
	x6 = x8 - (W3 - W5) * x6;
	x7 = x8 - (W3 + W5) * x7;
	/* second stage */
	x8 = x0 + x1;
	x0 = x0 - x1;
	x1 = W6 * (x3 + x2);
	x2 = x1 - (W2 + W6) * x2;
	x3 = x1 + (W2 - W6) * x3;
	x1 = x4 + x6;
	x4 = x4 - x6;
	x6 = x5 + x7;
	x5 = x5 - x7;
	/* third stage */
	x7 = x8 + x3;
	x8 = x8 - x3;
	x3 = x0 + x2;
	x0 = x0 - x2;

        x2 = (181 * (x4 + x5) + 128) >> 8;
        x4 = (181 * (x4 - x5) + 128) >> 8;
/* fourth stage */

        blk[0] = (x7 + x1) >> 8;
	    blk[1] = (x3 + x2) >> 8;
	    blk[2] = (x0 + x4) >> 8;
        blk[3] = (x8 + x6) >> 8;
        blk[4] = (x8 - x6) >> 8;
        blk[5] = (x0 - x4) >> 8;
        blk[6] = (x3 - x2) >> 8;
        blk[7] = (x7 - x1) >> 8;
}

void idctcol(int * blk)
{
    int x0, x1, x2, x3, x4, x5, x6, x7, x8;
    int Temp;

	/* intcut */

    x1 = blk[8 * 4] << 8;
    x2 = blk[8 * 6];
    x3 = blk[8 * 2];
    x4 = blk[8 * 1];
    x5 = blk[8 * 7];
    x6 = blk[8 * 5];
    x7 = blk[8 * 3];
	if ((x1 | x2 | x3 | x4 | x5 | x6 | x7) == 0) 
	{
		Temp = (blk[8 * 0] + 32) >> 6;
  /*      if((blk[8 * 0] + 32) < 0)
        {
            Temp = ((blk[8 * 0] + 32) >> 6) | ((!(int)(0)) << (32 - 6));
        }
        else
        {
            Temp = (blk[8 * 0] + 32) >> 6;
        }*/
        blk[8 * 1] = iclip[512 + Temp];
        blk[8 * 2] = iclip[512 + Temp];
        blk[8 * 3] = iclip[512 + Temp];
        blk[8 * 4] = iclip[512 + Temp];
        blk[8 * 5] = iclip[512 + Temp];
        blk[8 * 6] = iclip[512 + Temp];
        blk[8 * 7] = iclip[512 + Temp];
	    blk[8 * 0] = iclip[512 + Temp];
        return;
	}
	x0 = (blk[8 * 0] << 8) + 8192;
	/* first stage */
	x8 = W7 * (x4 + x5) + 4;

        x4 = (x8 + (W1 - W7) * x4) >> 3;
        x5 = (x8 - (W1 + W7) * x5) >> 3;
    	x8 = W3 * (x6 + x7) + 4;

        x6 = (x8 -(W3 - W5) * x6) >> 3;
        x7 = (x8 - (W3 + W5) * x7) >> 3;
	/* second stage */
	x8 = x0 + x1;
	x0 = x0 - x1;
	x1 = W6 * (x3 + x2) + 4;

        x2 = (x1 - (W2 + W6) * x2) >> 3;
        x3 = (x1 + (W2 - W6) * x3) >> 3;

	x1 = x4 + x6;
	x4 = x4 - x6;
	x6 = x5 + x7;
	x5 = x5 - x7;
	/* third stage */
	x7 = x8 + x3;
	x8 = x8 - x3;
	x3 = x0 + x2;
	x0 = x0 - x2;

        x2 = (181 * (x4 + x5) + 128) >> 8;
        x4 = (181 * (x4 - x5) + 128) >> 8;
	/* fourth stage */
        Temp = (x7 + x1) >> 14;

    blk[0] = iclip[512 + Temp];
        Temp = (x3 + x2) >> 14;

    blk[8] = iclip[512 + Temp];
        Temp = (x0 + x4) >> 14;
   
    blk[16] = iclip[512 + Temp];
        Temp = (x8 + x6) >> 14;
  
    blk[24] = iclip[512 + Temp];
        Temp = (x8 - x6) >> 14;
   
    blk[32] = iclip[512 + Temp];
        Temp = (x0 - x4) >> 14;
   
    blk[40] = iclip[512 + Temp];
        Temp = (x3 - x2) >> 14;
  
    blk[48] = iclip[512 + Temp];
        Temp = (x7 - x1) >> 14;
 
    blk[56] = iclip[512 + Temp];

}

#endif