coscode.cpp

图像处理源代码VC

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


void **fspace_2d(int row,int col,int lenth);
void ffree_2d(void **a,int row);
void fatal_error(char *msg);


//This utility block contains all of the routine needed to implement bit
//oriented rountines under either ANSI or K$R C.It needs to be linked
//with every program used in the program.
typedef struct bit_file
{
	FILE *file;
	unsigned char mask;
	int rack;
	int pacifier_counter;
} BIT_FILE;
BIT_FILE    *OpenInputBitFile(char *name);
BIT_FILE    *OpenOutputBitFile(char *name);
//void        OutputBit(BIT_FILE *bit_file,int bit);
void        OutputBits(BIT_FILE *bit_file,unsigned long code,int count);
//int         InputBit(BIT_FILE *bit_file);
//unsigned long InputBits(BIT_FILE *bit_file,int bit_count);
void        CloseInputBitFile(BIT_FILE *bit_file);
void        CloseOutputBitFile(BIT_FILE *bit_file);
//void        FilePrintBinary(FILE *file,unsigned int code,int bits);

BIT_FILE *OpenOutputBitFile(char *name)
{
  BIT_FILE *bit_file;

  bit_file=(BIT_FILE*)calloc(1,sizeof(BIT_FILE));
  if(bit_file==NULL)
	  return(bit_file);

  bit_file->file=fopen(name,"wb");
  bit_file->rack=0;
  bit_file->mask=0x80;
  bit_file->pacifier_counter=0;

  return (bit_file);
}

BIT_FILE *OpenInputBitFile(char *name)
{
  BIT_FILE *bit_file;

  bit_file=(BIT_FILE*)calloc(1,sizeof(BIT_FILE));
  if(bit_file==NULL)
     return(bit_file);

  bit_file->file=fopen(name,"rb");
  bit_file->rack=0;
  bit_file->mask=0x80;
  bit_file->pacifier_counter=0;

  return(bit_file);
}

void CloseOutputBitFile(BIT_FILE *bit_file)
{
  if(bit_file->mask!=0x80)
	 if(putc(bit_file->rack,bit_file->file)!=bit_file->rack)
		fatal_error("Fatal error in ClosebitFile!");

  fclose(bit_file->file);
  free((char*)bit_file);
}

void CloseInputBitFile(BIT_FILE *bit_file)
{
  fclose(bit_file->file);
  free((char*)bit_file);
}

/*
void OutputBit(BIT_FILE *bit_file,int bit)
{
  if(bit)
    bit_file->rack|=bit_file->mask;
  bit_file->mask>>=1;
  if(bit_file->mask==0)
  {
    if (putc(bit_file->rack,bit_file->file)!=bit_file->rack)
		fatal_error("Fatal error in OutputBit!");
	 else
	   if((bit_file->pacifier_counter++&4095)==0)
	     putc('.',stdout);
	 bit_file->rack=0;
	 bit_file->mask=0x80;
	}
}
*/

void OutputBits(BIT_FILE *bit_file,unsigned long code,int count)
{
  unsigned long mask;

  mask=1L<<(count-1);
  while(mask!=0)
  {
    if(mask&code)
      bit_file->rack|=bit_file->mask;
	 bit_file->mask>>=1;
	 if(bit_file->mask==0)
	 {
	   if(putc(bit_file->rack,bit_file->file)!=bit_file->rack)
		  fatal_error("Fatal error in OutputBit!");
      else if((bit_file->pacifier_counter++&2074)==0)
		{
//			putc('.',stdout);
//			putc('\n',stdout);
		}
		bit_file->rack=0;
		bit_file->mask=0x80;
    }
	 mask>>=1;
  }
}

/*
int InputBit(BIT_FILE *bit_file)
{
  int value;

  if(bit_file->mask==0x80)
  {
    bit_file->rack=getc(bit_file->file);
	 if(bit_file->rack==EOF)
		fatal_error("Fatal error in InputBit!");
	 if((bit_file->pacifier_counter++&2047)==0)
	 {
		putc('.',stdout);
	  putc('\n',stdout);
   }
  }
 value=bit_file->rack&bit_file->mask;
 bit_file->mask>>=1;
 if(bit_file->mask==0)
 bit_file->mask=0x80;
 return(value?1:0);
}
*/

unsigned long InputBits(BIT_FILE *bit_file,int bit_count)
{
  unsigned long mask;
  unsigned long return_value;

  mask=1L<<(bit_count-1);
  return_value=0;
  while(mask!=0)
  {
    if(bit_file->mask==0x80)
	 {
	   bit_file->rack=getc(bit_file->file);
		if(bit_file->rack==EOF)
		  fatal_error("Fatal error in InputBit! \n");
	   if((bit_file->pacifier_counter++&2047)==0)
		{
//			 putc('.',stdout);
//			 putc('\n',stdout);
		}
    }
	 if(bit_file->rack & bit_file->mask)
		return_value|=mask;
	 mask>>=1;
	 bit_file->mask>>=1;
	 if(bit_file->mask==0)
		bit_file->mask=0x80;
  }

  return(return_value);
}
/*
void FilePrintBinary(FILE *file, unsigned int code,int bits)
{
  unsigned int mask;
  mask=1<<(bits-1);
  while(mask!=0)
	{if(code & mask)
   fputc('1',file);
	else
   fputc('0',file);
	mask>>=1;
	}
}
*/
//This is dct module,which implements a graphics compression program based
//on the discrete cosine transform.It needs to be linked with the standard
//support routines.


//A few parameteters can be adjust to modify the compression algorithm.
//The first two define the number of rows and columns in the gray-scale
//image.The last one,'N',define the DCT block size.

//#define ROWS 200
//#define COLS 150
#define N     10

//This macro is used to ensure correct rounding of integer values.
#define ROUND(a)(((a)<0)?(int)((a)-0.5):(int)((a)+0.5))

void Initialize(int quality);
//void ReadPixelStrip(FILE *input,unsigned char strip[N][COLS]);
//void ReadPixelStrip(FILE *input,unsigned char **strip,int N,int COLS);
int  InputCode(BIT_FILE *input);
int  NewInputCode(BIT_FILE *input);
void ReadDCTData(BIT_FILE *input,int input_data[N][N]);
//void ReadDCTData(BIT_FILE *input,int **input_data,int N);
void OutputCode(BIT_FILE *output_file,int code);
void NewOutputCode(BIT_FILE *output_file,int code);
void WriteDCTData(BIT_FILE *output,int output_data[N][N]);
//void WriteDCTData(BIT_FILE *output,int **output_data,int N);
//void WritePixelStrip(FILE *output,unsigned char strip[N][COLS]);
//void WritePixelStrip(FILE *output,unsigned char **strip,int N,int COLS);
void ForwardDCT(unsigned char input[N][N],int output[N][N]);
//void ForwardDCT(unsigned char **input,int **output,int N);
void InverseDCT(int input[N][N],unsigned char output[N][N]);
//void InverseDCT(int **input,unsigned char **output,int N);

void CompressFile(unsigned char **Image,BIT_FILE *output,
		  int quality,int rw,int cl);
void dctcc(char *inputfile,char *outputfile,int quality);
void ExpandFile1(BIT_FILE *input,char *output,int rw,int cl);
void dct_ce(char *inputfile,char *output,int rw,int cl);

struct zigzag{
	  int row;
	  int col;
}ZigZag[N*N]=
{
{0,0},
{0,1},{1,0},
{2,0},{1,1},{0,2},
{0,3},{1,2},{2,1},{3,0},
{4,0},{3,1},{2,2},{1,3},{0,4},
{0,5},{1,4},{2,3},{3,2},{4,1},{5,0},
{6,0},{5,1},{4,2},{3,3},{2,4},{1,5},{0,6},
{0,7},{1,6},{2,5},{3,4},{4,3},{5,2},{6,1},{7,0},
{8,0},{7,1},{6,2},{5,3},{4,4},{3,5},{2,6},{1,7},{0,8},
{0,9},{1,8},{2,7},{3,6},{4,5},{5,4},{6,3},{7,2},{8,1},{9,0},
{9,1},{8,2},{7,3},{6,4},{5,5},{4,6},{3,7},{2,8},{1,9},
{2,9},{3,8},{4,7},{5,6},{6,5},{7,4},{8,3},{9,2},
{9,3},{8,4},{7,5},{6,6},{5,7},{4,8},{3,9},
{4,9},{5,8},{6,7},{7,6},{8,5},{9,4},
{9,5},{8,6},{7,7},{6,8},{5,9},
{6,9},{7,8},{8,7},{9,6},
{9,7},{8,8},{7,9},
{8,9},{9,8},
{9,9}
};

//unsigned char PixelStrip[N][COLS];

double C[N][N];
double Ct[N][N];
int InputRunLength;
int OutputRunLength;
int Quantum[N][N];

//The initialization routine has the job of setting up the cosine transform
//matrix,as well as its transposed value.These two matrices are used when
//calculating both the DCT and its inverse.In addition,the quantization
//matrix is set up based on the quality parameter passed to routine.The two
//run-length parametrers are both set to zero.
void Initialize(int quality)
{
  int i;
  int j;
  double pi=atan(1.0)*4;

  for(i=0;i<N;i++)
  for(j=0;j<N;j++)
    Quantum[i][j]=1+((1+i+j)*quality);
  OutputRunLength=0;
  InputRunLength=0;
  for(j=0;j<N;j++)
  {
    C[0][j]=1.0/sqrt((double)N);
	 Ct[j][0]=C[0][j];
  }

  for(i=1;i<N;i++)
  {
	 for(j=0;j<N;j++)
	 {
	   C[i][j]=sqrt(2.0/N)*cos(pi*(2*j+1)*i/(2.0*N));
      Ct[j][i]=C[i][j];
	 }
  }
}

//This routine is called when compressing a grey-scale file.It reads in a
//strip that is N(usually eight)rows deep and COLS (usually 320)collumns
//wide.This strip is then repeatedly processed,a block at a time,by the
//format DCT routine.

/*
//void ReadPixelStrip(FILE *input,unsigned char strip[N][COLS])
void ReadPixelStrip(FILE *input,unsigned char **strip,int N,int COLS)
{
 int row;
 int col;
 int c;

 for(row=0;row<N;row++)
 for(col=0;col<COLS;col++)
 {
   c=getc(input);
	if(c==EOF)
	  fatal_error("Error reading input grey scale file");
	strip[row][col]=(unsigned char)c;