jpeginit.c

DSP GEPE 压缩算法

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "jpeg.h"


extern BYTE VLI_TAB[4096];
extern BYTE* pVLITAB;    
extern BYTE YQT[64]; 
extern BYTE UVQT[64]; 
extern float YQT_DCT[64];
extern float UVQT_DCT[64];
//extern const BYTE FZBT[64];
//extern  BYTE std_Y_QT[64];
//extern  BYTE std_UV_QT[64];
extern HUFFCODE STD_DC_Y_HT[12];
extern HUFFCODE STD_DC_UV_HT[12];
extern HUFFCODE STD_AC_Y_HT[256];
extern HUFFCODE STD_AC_UV_HT[256];

BYTE ComputeVLI(short int val);

/*void SetQuantTable( BYTE* std_QT,BYTE* QT, int Q)
 {
  int tmpVal = 0;                  //临时变量
  int i    = 0; 
  unsigned int K=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 < 64; ++i)
  {
   tmpVal = (std_QT[i] * Q + 50) / 100;

   if (tmpVal < 1)                 //数值范围限定
   {
    tmpVal = 1;
   }
   if (tmpVal > 255)
   {
    tmpVal = 255;
   }
   K=FZBT[i];
   QT[K] = tmpVal;
  } 
 }

 //为float AA&N IDCT算法初始化量化表
 void InitQTForAANDCT()
 {
  int i = 0;           //临时变量
  int j = 0;
  int k = 0; 
  unsigned int n=0;
  for (i = 0; i < 8; i++)  //初始化亮度信号量化表
  {
   for (j = 0; j < 8; j++)
   {
    n=FZBT[k];
    YQT_DCT[k] = (float) (1.0 / ((double) YQT[n] *
     aanScaleFactor[i] * aanScaleFactor[j] * 8.0));       
    ++k;
   }
  } 

  k = 0;
  for (i = 0; i < 8; i++)  //初始化色差信号量化表
  {
   for (j = 0; j < 8; j++)
   {
    n=FZBT[k];
    UVQT_DCT[k] = (float) (1.0 / ((double) UVQT[n] *
     aanScaleFactor[i] * aanScaleFactor[j] * 8.0));       
    ++k;
   }
  } 
 }*/
 
 void BuildVLITable()
 {
  short int i   = 0;

  for (i = 0; i < DC_MAX_QUANTED; ++i)
  {
   pVLITAB[i] = ComputeVLI(i);
  }

  for (i = DC_MIN_QUANTED; i < 0; ++i)
  {
   pVLITAB[i] = ComputeVLI(i);
  }
 }
 

 BYTE ComputeVLI(short int val)
 { 
  BYTE binStrLen = 0;
  val = _abs((int)val); 
  //获取二进制码长度   
  if(val == 1)
  {
   binStrLen = 1;  
  }
  else if(val >= 2 && val <= 3)
  {
   binStrLen = 2;
  }
  else if(val >= 4 && val <= 7)
  {
   binStrLen = 3;
  }
  else if(val >= 8 && val <= 15)
  {
   binStrLen = 4;
  }
  else if(val >= 16 && val <= 31)
  {
   binStrLen = 5;
  }
  else if(val >= 32 && val <= 63)
  {
   binStrLen = 6;
  }
  else if(val >= 64 && val <= 127)
  {
   binStrLen = 7;
  }
  else if(val >= 128 && val <= 255)
  {
   binStrLen = 8;
  }
  else if(val >= 256 && val <= 511)
  {
   binStrLen = 9;
  }
  else if(val >= 512 && val <= 1023)
  {
   binStrLen = 10;
  }
  else if(val >= 1024 && val <= 2047)
  {
   binStrLen = 11;
  }

  return binStrLen;
 }
 
void BuildSTDHuffTab(BYTE* nrcodes,BYTE* stdTab,HUFFCODE* huffCode)
 {
  int i     = 0;             //临时变量
  int j     = 0;
  int k     = 0;
  unsigned short int code   = 0; 

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

  for (i = 0; i < k; i++)
  {
   huffCode[i].val = stdTab[i];  
  }
 
 }
 
 
 void Initimage(int* lpInBuff)
{
 	int i,j;
 	for(i=0;i<640;i++)
 		for(j=0;j<8;j++)
 		*(lpInBuff+i*640+j)=0xffffffff;
}