jcfunction.h

bf533平台图像采集程序

//#include "malloc.h"
#include "math.h"
//#include "memory.h"


 //********************************************************************
 // 方法名称:BuildVLITable 
 //
 // 方法说明:生成VLI表，使pVLITAB[i] = (i的二进制码的长度)
 //
 //********************************************************************
 void BuildVLITable(void)
 {
  int i;
  for (i = DC_MIN_QUANTED; i < DC_MAX_QUANTED; ++i)
  {
	  pVLITAB[i] = ComputeVLI(i);
  }
 } 

 #ifdef 0
 //********************************************************************
 // 方法名称:BuildSym2 
 //
 // 方法说明:将信号的振幅进行VLI编码,返回编码长度和信号振幅的编码
 //
 // 参数说明:
 // value:AC/DC信号的振幅
 //********************************************************************
 SYM2 BuildSym2(short value)
 {
  SYM2 Symbol;  
  Symbol.codeLen = ComputeVLI(value);
  Symbol.amplitude = 0;
  if (value >= 0)
  {
   Symbol.amplitude = value;
  }
  else
  {
//   Symbol.amplitude = (short)(pow(2,Symbol.codeLen)-1) + value;  
	Symbol.amplitude = (1 << Symbol.codeLen) - 1 + value; 
   //计算反码
   //eg. value=-5    -5长度为3，2^3-1+(-5)=2=010 =(101的反码)
  }

  return Symbol;
 }
 
 #endif //0
 //********************************************************************
 // 方法名称:RLEComp 
 //
 // 方法说明:使用RLE算法对AC编码
 //
 // 参数说明:
 // lpbuf:输入缓冲,8x8变换信号缓冲

 //********************************************************************
 /*
 void RLEComp(short* lpbuf, HUFFCODE* acHuffTab, int index)
 {  
  unsigned char zeroNum     = 0;                //0行程计数器
//  unsigned int EOBPos      = 0;                //EOB出现位置 
  unsigned int EOBPos      = index;                //EOB出现位置 
  const unsigned char MAXZEROLEN = 15;          //最大0行程
  unsigned int i        = 0;     
  unsigned int j        = 0;

  HUFFCODE * huff;
  SYM2 sym2;
 
//  EOBPos = DCTBLOCKSIZE - 1;           //设置起始位置，从最后一个信号开始
//  for (i = EOBPos; i > 0; i--)         //从最后的AC信号数0的个数
//  {
//   if (lpbuf[i] == 0)          
//   {
//    --EOBPos;           
//   }
//   else            
//   {
//    break;                   
//   }
//  }
	
  for (i = 1; i <= EOBPos; i++)         //从第二个信号，即AC信号开始编码
  {
   if (lpbuf[i] == 0 && zeroNum < MAXZEROLEN)  
   {
    ++zeroNum;   
   }
   else
   {  
   	 unsigned char zeroLen = zeroNum;                    //0的行程
	 unsigned char codeLen = ComputeVLI(lpbuf[i]);;                    //幅度编码占用长度
 	short amplitude = lpbuf[i];                 //幅度
 
//    lpOutBuf[j].zeroLen = zeroNum;       //0行程（连续长度）
//    lpOutBuf[j].codeLen = ComputeVLI(lpbuf[i]);    //幅度编码长度
//    lpOutBuf[j].amplitude = lpbuf[i];      //振幅      
    zeroNum = 0;           //0计数器复位
//    (*resultLen)++;           //符号数量++
    ++j;             //符号计数
    
	if (codeLen == 0)                   //是否有连续16个0
	{   
		huff = &acHuffTab[0xF0];
		WriteBitsStream(huff->code, huff->length);                   //写入块结束标记  
	}
	else
	{
		huff = &acHuffTab[zeroLen * 16 + codeLen];
		WriteBitsStream(huff->code, huff->length);                   //写入块结束标记  
		sym2 = BuildSym2(amplitude);
		WriteBitsStream(sym2.amplitude, sym2.codeLen);                //写进幅度  
	}   

   }
  } 
 }

*/
  // 生成标准Huffman表
 void BuildSTDHuffTab(unsigned char* nrcodes,unsigned char* stdTab,HUFFCODE* huffCode)
 {
  unsigned char i     = 0;             //临时变量
  unsigned char j     = 0;
  unsigned char k     = 0;
  unsigned short code   = 0; 

  for (i = 1; i <= 16; i++)
  { 
   for (j = 1; j <= nrcodes[i]; j++)
   {   
    huffCode[stdTab[k]].code = code & ( (1<<i) -1 );
    huffCode[stdTab[k]].length = i;
    ++k;
    ++code;
   }
   code*=2;
  } 

  for (i = 0; i < k; i++)
  {
   huffCode[i].val = stdTab[i];  
  };
 }


 //********************************************************************
 // 方法名称:SetQuantTable 
 //
 // 方法说明:根据所需质量设置量化表
 //
 // 参数说明:
 // std_QT:标准量化表
 // QT:输出量化表
 // Q:质量参数
 //********************************************************************
 void SetQuantTable(const unsigned char* std_QT,unsigned char* QT, int Q)
 {
  int tmpVal = 0;  
  unsigned long i    = 0; 

  if (Q < 1) Q = 1;          
  if (Q > 100) Q = 100;

  //非线性映射 1->5000, 10->500, 25->200, 50->100, 75->50, 100->0
  if (Q < 50)
  {
   Q = 5000 / Q;
  }
  else
  {
   Q = 200 - Q * 2;
  }

  for (i = 0; i < DCTBLOCKSIZE; ++i)
  {
   tmpVal = (std_QT[i] * Q + 50L) / 100L;

   if (tmpVal < 1) 
   {
    tmpVal = 1L;
   }
   if (tmpVal > 255)
   {
    tmpVal = 255L;
   }
//   QT[FZBT[i]] = (unsigned char)(tmpVal);
   QT[i] = (unsigned char)(tmpVal);
  } 
 }