?? jpegbianma.txt
字號:
{
DHT.huffCode = STD_AC_UV_NRCODES[i + 1];
}
fwrite(&DHT,sizeof(DHT),1,this->pOutFile);
for (i = 0; i <= 161; i++)
{
WriteByte(STD_AC_UV_VALUES);
}
}
//寫入SOS段
void WriteSOS(void)
{
JPEGSOS_24BITS SOS;
SOS.segmentTag = 0xDAFF;
SOS.length = 0x0C00;
SOS.sigNum = 0x03;
SOS.YID = 0x01;
SOS.HTY = 0x00;
SOS.UID = 0x02;
SOS.HTU = 0x11;
SOS.VID = 0x03;
SOS.HTV = 0x11;
SOS.Se = 0x3F;
SOS.Ss = 0x00;
SOS.Bf = 0x00;
fwrite(&SOS,sizeof(SOS),1,this->pOutFile);
}
//寫入文件結束標記
void WriteEOI(void)
{
fwrite(&EOITAG,sizeof(EOITAG),1,this->pOutFile);
}
// 將高8位和低8位交換
USHORT Intel2Moto(USHORT val)
{
BYTE highBits = BYTE(val / 256);
BYTE lowBits = BYTE(val % 256);
return lowBits * 256 + highBits;
}
//寫1字節到文件
void WriteByte(BYTE val)
{
fwrite(&val,sizeof(val),1,this->pOutFile);
}
// 生成標準Huffman表
void BuildSTDHuffTab(BYTE* nrcodes,BYTE* stdTab,HUFFCODE* huffCode)
{
BYTE i = 0; //臨時變量
BYTE j = 0;
BYTE k = 0;
USHORT code = 0;
for (i = 1; i <= 16; i++)
{
for (j = 1; j <= nrcodes; j++)
{
huffCode[stdTab[k]].code = code;
huffCode[stdTab[k]].length = i;
++k;
++code;
}
code*=2;
}
for (i = 0; i < k; i++)
{
huffCode.val = stdTab;
}
}
// 處理DU(數據單元)
void ProcessDU(FLOAT* lpBuf,FLOAT* quantTab,HUFFCODE* dcHuffTab,HUFFCODE* acHuffTab,SHORT* DC)
{
BYTE i = 0; //臨時變量
UINT j = 0;
SHORT diffVal = 0; //DC差異值
BYTE acLen = 0; //熵編碼后AC中間符號的數量
SHORT sigBuf[DCTBLOCKSIZE]; //量化后信號緩沖
ACSYM acSym[DCTBLOCKSIZE]; //AC中間符號緩沖
FDCT(lpBuf); //離散余弦變換
for (i = 0; i < DCTBLOCKSIZE; i++) //量化操作
{
sigBuf[FZBT] = (lpBuf * quantTab + 16384.5) - 16384;
}
//-----------------------------------------------------
//對DC信號編碼，寫入文件
//DPCM編碼
diffVal = sigBuf[0] - *DC;
*DC = sigBuf[0];
//搜索Huffman表，寫入相應的碼字
if (diffVal == 0)
{
WriteBits(dcHuffTab[0]);
}
else
{
WriteBits(dcHuffTab[pVLITAB[diffVal]]);
WriteBits(BuildSym2(diffVal));
}
//-------------------------------------------------------
//對AC信號編碼并寫入文件
for (i = 63; (i > 0) && (sigBuf == 0); i--) //判斷ac信號是否全為0
{
//注意，空循環
}
if (i == 0) //如果全為0
{
WriteBits(acHuffTab[0x00]); //寫入塊結束標記
}
else
{
RLEComp(sigBuf,&acSym[0],acLen); //對AC運行長度編碼
for (j = 0; j < acLen; j++) //依次對AC中間符號Huffman編碼
{
if (acSym[j].codeLen == 0) //是否有連續16個0
{
WriteBits(acHuffTab[0xF0]); //寫入(15,0)
}
else
{
WriteBits(acHuffTab[acSym[j].zeroLen * 16 + acSym[j].codeLen]); //
WriteBits(BuildSym2(acSym[j].amplitude));
}
}
if (i != 63) //如果最后位以0結束就寫入EOB
{
WriteBits(acHuffTab[0x00]);
}
}
}
//********************************************************** **********
// 方法名稱:ProcessData
//
// 方法說明:處理圖像數據FDCT-QUANT-HUFFMAN
//
// 參數說明:
// lpYBuf:亮度Y信號輸入緩沖
// lpUBuf:色差U信號輸入緩沖
// lpVBuf:色差V信號輸入緩沖
//********************************************************** **********
void ProcessData(BYTE* lpYBuf,BYTE* lpUBuf,BYTE* lpVBuf)
{
size_t yBufLen = _msize(lpYBuf); //亮度Y緩沖長度
size_t uBufLen = _msize(lpUBuf); //色差U緩沖長度
size_t vBufLen = _msize(lpVBuf); //色差V緩沖長度
FLOAT dctYBuf[DCTBLOCKSIZE]; //Y信號FDCT編碼臨時緩沖
FLOAT dctUBuf[DCTBLOCKSIZE]; //U信號FDCT編碼臨時緩沖
FLOAT dctVBuf[DCTBLOCKSIZE]; //V信號FDCT編碼臨時緩沖
UINT mcuNum = 0; //存放MCU的數量
SHORT yDC = 0; //Y信號的當前塊的DC
SHORT uDC = 0; //U信號的當前塊的DC
SHORT vDC = 0; //V信號的當前塊的DC
BYTE yCounter = 0; //YUV信號各自的寫入計數器
BYTE uCounter = 0;
BYTE vCounter = 0;
UINT i = 0; //臨時變量
UINT j = 0;
UINT k = 0;
UINT p = 0;
UINT m = 0;
UINT n = 0;
UINT s = 0;
mcuNum = (this->buffHeight * this->buffWidth * 3)
/ (DCTBLOCKSIZE * 3); //計算MCU的數量
for (p = 0;p < mcuNum; p++) //依次生成MCU并寫入
{
yCounter = 1;//MCUIndex[SamplingType][0]; //按采樣方式初始化各信號計數器
uCounter = 1;//MCUIndex[SamplingType][1];
vCounter = 1;//MCUIndex[SamplingType][2];
for (; i < yBufLen; i += DCTBLOCKSIZE)
{
for (j = 0; j < DCTBLOCKSIZE; j++)
{
dctYBuf[j] = FLOAT(lpYBuf[i + j] - 128);
}
if (yCounter > 0)
{
--yCounter;
ProcessDU(dctYBuf,YQT_DCT,STD_DC_Y_HT,STD_AC_Y_HT,&yDC);
}
else
{
break;
}
}
//---------------------------------------------------------- --------
for (; m < uBufLen; m += DCTBLOCKSIZE)
{
for (n = 0; n < DCTBLOCKSIZE; n++)
{
dctUBuf[n] = FLOAT(lpUBuf[m + n] - 128);
}
if (uCounter > 0)
{
--uCounter;
ProcessDU(dctUBuf,UVQT_DCT,STD_DC_UV_HT,STD_AC_UV_HT,&uD C);
}
else
{
break;
}
}
//---------------------------------------------------------- ---------
for (; s < vBufLen; s += DCTBLOCKSIZE)
{
for (k = 0; k < DCTBLOCKSIZE; k++)
{
dctVBuf[k] = FLOAT(lpVBuf[s + k] - 128);
}
if (vCounter > 0)
{
--vCounter;
ProcessDU(dctVBuf,UVQT_DCT,STD_DC_UV_HT,STD_AC_UV_HT,&vD C);
}
else
{
break;
}
}
}
}
// 8x8的浮點離散余弦變換
void FDCT(FLOAT* lpBuff)
{
FLOAT tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
FLOAT tmp10, tmp11, tmp12, tmp13;
FLOAT z1, z2, z3, z4, z5, z11, z13;
FLOAT* dataptr;
int ctr;
/* 第一部分，對行進行計算 */
dataptr = lpBuff;
for (ctr = DCTSIZE-1; ctr >= 0; ctr--)
{
tmp0 = dataptr[0] + dataptr[7];
tmp7 = dataptr[0] - dataptr[7];
tmp1 = dataptr[1] + dataptr[6];
tmp6 = dataptr[1] - dataptr[6];
tmp2 = dataptr[2] + dataptr[5];
tmp5 = dataptr[2] - dataptr[5];
tmp3 = dataptr[3] + dataptr[4];
tmp4 = dataptr[3] - dataptr[4];
/* 對偶數項進行運算 */
tmp10 = tmp0 + tmp3; /* phase 2 */
tmp13 = tmp0 - tmp3;
tmp11 = tmp1 + tmp2;
tmp12 = tmp1 - tmp2;
dataptr[0] = tmp10 + tmp11; /* phase 3 */
dataptr[4] = tmp10 - tmp11;
z1 = (tmp12 + tmp13) * (0.707106781); /* c4 */
dataptr[2] = tmp13 + z1; /* phase 5 */
dataptr[6] = tmp13 - z1;
/* 對奇數項進行計算 */
tmp10 = tmp4 + tmp5; /* phase 2 */
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;
z5 = (tmp10 - tmp12) * ( 0.382683433); /* c6 */
z2 = (0.541196100) * tmp10 + z5; /* c2-c6 */
z4 = (1.306562965) * tmp12 + z5; /* c2+c6 */
z3 = tmp11 * (0.707106781); /* c4 */
z11 = tmp7 + z3; /* phase 5 */
z13 = tmp7 - z3;
dataptr[5] = z13 + z2; /* phase 6 */
dataptr[3] = z13 - z2;
dataptr[1] = z11 + z4;
dataptr[7] = z11 - z4;
dataptr += DCTSIZE; /* 將指針指向下一行 */
}
/* 第二部分，對列進行計算 */
dataptr = lpBuff;
for (ctr = DCTSIZE-1; ctr >= 0; ctr--)
{
tmp0 = dataptr[DCTSIZE*0] + dataptr[DCTSIZE*7];
tmp7 = dataptr[DCTSIZE*0] - dataptr[DCTSIZE*7];
tmp1 = dataptr[DCTSIZE*1] + dataptr[DCTSIZE*6];
tmp6 = dataptr[DCTSIZE*1] - dataptr[DCTSIZE*6];
tmp2 = dataptr[DCTSIZE*2] + dataptr[DCTSIZE*5];
tmp5 = dataptr[DCTSIZE*2] - dataptr[DCTSIZE*5];
tmp3 = dataptr[DCTSIZE*3] + dataptr[DCTSIZE*4];
tmp4 = dataptr[DCTSIZE*3] - dataptr[DCTSIZE*4];
/* 對偶數項進行運算 */
tmp10 = tmp0 + tmp3; /* phase 2 */
tmp13 = tmp0 - tmp3;
tmp11 = tmp1 + tmp2;
tmp12 = tmp1 - tmp2;
dataptr[DCTSIZE*0] = tmp10 + tmp11; /* phase 3 */
dataptr[DCTSIZE*4] = tmp10 - tmp11;
z1 = (tmp12 + tmp13) * (0.707106781); /* c4 */
dataptr[DCTSIZE*2] = tmp13 + z1; /* phase 5 */
dataptr[DCTSIZE*6] = tmp13 - z1;
/* 對奇數項進行計算 */
tmp10 = tmp4 + tmp5; /* phase 2 */
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;
z5 = (tmp10 - tmp12) * (0.382683433); /* c6 */
z2 = (0.541196100) * tmp10 + z5; /* c2-c6 */
z4 = (1.306562965) * tmp12 + z5; /* c2+c6 */
z3 = tmp11 * (0.707106781); /* c4 */
z11 = tmp7 + z3; /* phase 5 */
z13 = tmp7 - z3;
dataptr[DCTSIZE*5] = z13 + z2; /* phase 6 */
dataptr[DCTSIZE*3] = z13 - z2;
dataptr[DCTSIZE*1] = z11 + z4;
dataptr[DCTSIZE*7] = z11 - z4;
++dataptr; /* 將指針指向下一列 */
}
}
//********************************************************** **********
// 方法名稱:WriteBits
//
// 方法說明:寫入二進制流
//
// 參數說明:
// value:AC/DC信號的振幅
//********************************************************** **********
void WriteBits(HUFFCODE huffCode)
{
WriteBitsStream(huffCode.code,huffCode.length);
}
void WriteBits(SYM2 sym)
{
WriteBitsStream(sym.amplitude,sym.codeLen);
}
//********************************************************** **********
// 方法名稱:WriteBitsStream
//
// 方法說明:寫入二進制流
//
// 參數說明:
// value:需要寫入的值
// codeLen:二進制長度
//********************************************************** **********
void WriteBitsStream(USHORT value,BYTE codeLen)
{
CHAR posval;//bit position in the bitstring we read, should be<=15 and >=0
posval=codeLen-1;
while (posval>=0)
{
if (value & mask[posval])
{
bytenew|=mask[bytepos];
}
posval--;bytepos--;
if (bytepos<0)
{
if (bytenew==0xFF)
{
WriteByte(0xFF);
WriteByte(0);
}
else
{
WriteByte(bytenew);
}
bytepos=7;bytenew=0;
}
}
}
//********************************************************** **********
// 方法名稱:RLEComp
//
// 方法說明:使用RLE算法對AC壓縮,假設輸入數據1,0,0,0,3,0,5
// 輸出為(0,1)(3,3)(1,5),左位表示右位數據前0的個數
// 左位用4bits表示,0的個數超過表示范圍則輸出為(15,0)
// 其余的0數據在下一個符號中表示.
//
// 參數說明:
// lpbuf:輸入緩沖,8x8變換信號緩沖
// lpOutBuf:輸出緩沖,結構數組,結構信息見頭文件
// resultLen:輸出緩沖長度,即編碼后符號的數量
//********************************************************** **********
void RLEComp(SHORT* lpbuf,ACSYM* lpOutBuf,BYTE &resultLen)
{
BYTE zeroNum = 0; //0行程計數器
UINT EOBPos = 0; //EOB出現位置
const BYTE MAXZEROLEN = 15; //最大0行程
UINT i = 0; //臨時變量
UINT j = 0;
EOBPos = DCTBLOCKSIZE - 1; //設置起始位置，從最后一個信號開始
for (i = EOBPos; i > 0; i--) //從最后的AC信號數0的個數
{
if (lpbuf == 0) //判斷數據是否為0
{
--EOBPos; //向前一位
}
else //遇到非0，跳出
{
break;
}
}
for (i = 1; i <= EOBPos; i++) //從第二個信號，即AC信號開始編碼
{
if (lpbuf == 0 && zeroNum < MAXZEROLEN) //如果信號為0并連續長度小于15
{
++zeroNum;
}
else
{
lpOutBuf[j].zeroLen = zeroNum; //0行程（連續長度）
lpOutBuf[j].codeLen = ComputeVLI(lpbuf); //幅度編碼長度
lpOutBuf[j].amplitude = lpbuf; //振幅
zeroNum = 0; //0計數器復位
++resultLen; //符號數量++
++j; //符號計數
}
}
}
//********************************************************** **********
// 方法名稱:BuildSym2
//
// 方法說明:將信號的振幅VLI編碼,返回編碼長度和信號振幅的反碼
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -