rle.c

C代码完成jpeg编码和解码

#include "dct.h" 

extern short block[BLOCK_SIZE];
extern int stream[BLOCK_SIZE];
extern short preblock;
extern short dcHuffman[12];
extern int DCbit[12];
extern short acHuffman[16][11];
extern int ACbit[16][11];

short cat (short diff);                // function to define the category (CAT) 
short dchuff(short cat);               // function to find the DC codeword according to DC Huffman coefficients
short achuff(short run, short cat);    // function to fine the AC codeword according to AC Huffman coefficients
short symbol2(short diff);             // function to calculate symbol-2
int count(short run, short cat);       // function to calculate the number of bits

void dc_encoding(void)                 // function doing DC encoding
{
	short dcsym1,dcsym2;
	short diff,cate;
	int data,bit;

	diff = block[0] - preblock;        
	cate = cat(diff);                  // calculate CAT
	dcsym1 = dchuff(cate);             // calculate dc-symbol-1
	dcsym2 = symbol2(diff);            // calculate dc-symbol-2
	
	preblock = block[0];
	data = (dcsym1 << cate) + dcsym2;  // connect symbol-1 and symbol-2 together
	bit = DCbit[cate];                 
	bit += cate;                       // calculate number of significance bits
	stream[0] = data << (32-bit);      // shift the data to the most significant bit, and store in stream[0]
}

void ac_encoding(void)
{
	short acsym1,acsym2;
	int i,num, data_num=1;
	short run, cate;
	int data, bit;

	run=0;

	for(i=63;i>0;i--){                 // find EOB
		if (block[i] != 0){
			num = i+1;
			break;
		}
		else if(block[i] == 0 && i==1) {
			num=1;
			break;
		}
		else ;
	} // for
	
	for(i=1;i<num;i++){
		if(block[i] != 0){
			cate = cat(block[i]);                // calculate CAT
			acsym1 = achuff(run, cate);          // calculate ac-symbol-1
			acsym2 = symbol2(block[i]);          // calculate ac-symbol-2
			data = (acsym1 << cate) + acsym2;    // connect symbol-1 and symbol-2 together
			bit = count(run, cate);              
			bit += cate;                         // calculate number of significance bits
			stream[data_num] = data << (32-bit); // shift the data to the most significant bit, and store in stream
			data_num++;                          // number of data
			run=0;
		} // if
		else if(block[i] == 0 && run==15){       // 16 zeros together
			acsym1 = achuff(15,0);               // RUN = 15, CAT = 0
			acsym2 = 0;
			data = acsym1;
			bit = 11;
			stream[data_num] = data << (32-bit);
			data_num++;
			run=0;
		} // else if
		else if(block[i] == 0 && run < 15) {
			run++;
		} 
		else ;// else
	} // for

	data = achuff(0,0);                          // EOB, RUN = 0, CAT = 0
	bit = 4;
	stream[data_num] = data << (32-bit);         // the last data of current block
}

short cat (short diff)                           // define the category (CAT) 
{
	short cate;

	if (diff==1 || diff==-1)
		cate=1;
	else if(diff==-3 || diff==-2 || diff==2 || diff==3)
		cate=2;
	else if((diff>=-7 && diff<=-4) || (diff>=4 && diff<=7))
		cate=3;
	else if((diff>=-15 && diff<=-8) || (diff>=8 && diff<=15))
		cate=4;
	else if((diff>=-31 && diff<=-16) || (diff>=16 && diff<=31))
		cate=5;
	else if((diff>=-63 && diff<=-32) || (diff>=32 && diff<=63))
		cate=6;
	else if((diff>=-127 && diff<=-64) || (diff>=64 && diff<=127))
		cate=7;
	else if((diff>=-255 && diff<=-128) || (diff>=128 && diff<=255))
		cate=8;
	else if((diff>=-511 && diff<=-256) || (diff>=256 && diff<=511))
		cate=9;
	else if((diff>=-1023 && diff<=-521) || (diff>=521 && diff<=1023))
		cate=10;
	else if((diff>=-2047 && diff<=-1024) || (diff>=1024 && diff<=2047))
		cate=11;
	else cate=0;

	return cate;
}

short dchuff(short cat)                // find the DC codeword according to DC Huffman coefficients
{
	short codedc;

	codedc = dcHuffman[cat];

	return codedc;
}

short achuff(short run, short cat)     // find the AC codeword according to AC Huffman coefficients
{
	short codeac;
	
	codeac = acHuffman[run][cat];

	return codeac;
}

short symbol2(short diff)              // calculate symbol-2
{
	short symbol;

	if(diff>=0) {                      // when DIFF is positive, symbol-2 is the lower order bits of DIFF
		symbol = diff;
	}
	else {                             // when DIFF is negative, symbol-2 is the lower order bits of DIFF-1
		diff = diff-1;
		if((diff & 0x4000) == 0) {     // locate the most significant bit which is 0 for negative DIFF
			symbol = diff & 0x7FFF;
		}
		else if((diff & 0x2000) == 0){
			symbol = diff & 0x3FFF;
		}
		else if((diff & 0x1000) == 0){
			symbol = diff & 0x1FFF;
		}
		else if((diff & 0x0800) == 0){
			symbol = diff & 0x0FFF;
		}
		else if((diff & 0x0400) == 0){
			symbol = diff & 0x07FF;
		}
		else if((diff & 0x0200) == 0){
			symbol = diff & 0x03FF;
		}
		else if((diff & 0x0100) == 0){
			symbol = diff & 0x01FF;
		}
		else if((diff & 0x0080) == 0){
			symbol = diff & 0x00FF;
		}
		else if((diff & 0x0040) == 0){
			symbol = diff & 0x007F;
		}
		else if((diff & 0x0020) == 0){
			symbol = diff & 0x003F;
		}
		else if((diff & 0x0010) == 0){
			symbol = diff & 0x001F;
		}
		else if((diff & 0x0008) == 0){
			symbol = diff & 0x000F;
		}
		else if((diff & 0x0004) == 0){
			symbol = diff & 0x0007;
		}
		else if((diff & 0x0002) == 0){
			symbol = diff & 0x0003;
		}
		else if((diff & 0x0001) == 0){
			symbol = diff & 0x0001;
		}
		else
			;
	}
	return symbol;
}

int count(short run, short cat)        // calculate the number of bits
{
	int bit;

	bit = ACbit[run][cat];
	
	return bit;
}