main.c

基于嵌入式零树小波编码的C语言程序实现。

/*--------------------------------------------------------------------------------------------*/
#include "ezw3.h"

/*--------------------------------------------------------------------------------------------*/
int EncodeInterface(int argc, char **argv, char *ProgramName, Coder *coder);
int DecodeInterface(int argc, char **argv, char *ProgramName, Coder *coder);

/*--------------------------------------------------------------------------------------------*/
/* Coder APIs */
extern int Encode(Coder *coder);
extern int Decode(Coder *coder);
extern void Usage(char *ProgramName);
extern void GetProgramName(char *NameOnly, char *FullPath);
/*--------------------------------------------------------------------------------------------*/

/*--------------------------------------------------------------------------------------------*/
int main(int argc, char **argv)
{
	char ProgramName[_MAX_PATH];

	GetProgramName(ProgramName, argv[0]);
	
	if(argc < 2){
		Usage(ProgramName);
		return -1;
	}

	if (argv[1][0]=='e'){
		Coder *coder;
		coder = (Coder *)malloc(sizeof(Coder));
		argv+=2; argc-=2;
		EncodeInterface(argc, argv, ProgramName, coder);
		free(coder);
		PrintLeaks();
	}
	else if (argv[1][0]=='d'){
		Coder *coder;
		coder = (Coder *)malloc(sizeof(Coder));
		argv+=2; argc-=2;	
		DecodeInterface(argc, argv, ProgramName, coder);		
		free(coder);
		PrintLeaks();
	}
	else if (argv[1][0]=='a'){
		char TempFileName[_MAX_PATH];
		int len;
		struct stat statistics; 
		int EncodedImageFileSize;
		double ImagePSNR, ImageSNR;
		Coder *encoder;
		Coder *decoder;

		encoder = (Coder *)malloc(sizeof(Coder));
		argv+=2; argc-=2;	
		if (EncodeInterface(argc, argv, ProgramName, encoder)==-1){
			free(encoder);
			Error("Encode fail...\n");		
		}
		fprintf(stdout, "\n");
		/* decoding - full rate */
		decoder = (Coder *)malloc(sizeof(Coder));
		decoder->DecodeFileNameSpecify = TRUE;
      decoder->TestFullBitPlane = encoder->TestFullBitPlane;
      decoder->LastFullBitPlane = encoder->LastFullBitPlane;
		sprintf(TempFileName, encoder->EncodeImageFileName);
		len = strlen(TempFileName);
		TempFileName[len-strlen(ENC_EXT)-1] = '\0';
		sprintf(decoder->DecodeImageFileName, "%s.%s.pgm", TempFileName, ENC_EXT);
		sprintf(decoder->EncodeImageFileName, encoder->EncodeImageFileName);
		decoder->TargetBitRate = MaxReal;
		Decode(decoder);

		if(stat(decoder->EncodeImageFileName, &statistics) == -1){
			EncodedImageFileSize = 0;
		}
		else{
			EncodedImageFileSize = (int)statistics.st_size;
		}
		
		ImagePSNR = ImageFileComparePSNR(encoder->InputImageFileName, 
													decoder->DecodeImageFileName);
      /*
		ImageSNR =  ImageFileCompareSNR(encoder->InputImageFileName, 
													decoder->DecodeImageFileName);

		printf("\nRATE = %.6lf, PSNR = %.4lf dB, MSE = %.4lf, SNR = %.4lf\n", 
			EncodedImageFileSize*8.0/(decoder->ImageXSize*decoder->ImageYSize), ImagePSNR,
			255*255*pow(10.0, -ImagePSNR/10), ImageSNR);
		*/
      printf("\nRATE = %.6lf, PSNR = %.4lf dB, MSE = %.4lf\n", 
			EncodedImageFileSize*8.0/(decoder->ImageXSize*decoder->ImageYSize), ImagePSNR,
			255*255*pow(10.0, -ImagePSNR/10));
		
		free(encoder);
		free(decoder);

		PrintLeaks();
	}
	else if (argv[1][0]=='r'){
		char RDLogFileName[_MAX_PATH];
		char EncodeImageFileName[_MAX_PATH];
		char OriginalImageFileName[_MAX_PATH];
		int len;
		struct stat statistics; 
		int EncodedImageFileSize;
		double ImagePSNR;
		Coder *decoder;
		FILE *RDLog;
		double BitRate, LastRate, RateInc;
		int Cont, Append, Profile;
				
		ReadLine("Encoded image filename ? ", EncodeImageFileName);
		ReadLine("Original image filename ? ", OriginalImageFileName);
		ReadLine("Rate x PSNR results filename ? ", RDLogFileName);
		Append = ReadYesNo("Append ?");
		BitRate = ReadDouble("First rate (bits/pixel) ? ");
		LastRate = ReadDouble("Last rate (bits/pixel) ? ");
		if (BitRate>LastRate){
			BitRate = LastRate;
		}
		Profile = ReadYesNo("Log2 r-d point ?");

		if (Profile){
			RateInc = 1.0;
		}
		else{
			RateInc = ReadDouble("Rate increment ? ");
		}

		if(stat(EncodeImageFileName, &statistics) == -1){
			EncodedImageFileSize = 0;
		}
		else{
			EncodedImageFileSize = (int)statistics.st_size;
		}
		
		/* open the rd file */
		if (Append){
			RDLog = fopen(RDLogFileName, "a");
		}
		else{
			RDLog = fopen(RDLogFileName, "w");
		}

		do {
			decoder = (Coder *)malloc(sizeof(Coder));
			sprintf(decoder->EncodeImageFileName, "%s", EncodeImageFileName);
			sprintf(decoder->OriginalImageFileName, "%s", OriginalImageFileName);
			sprintf(decoder->DecodeImageFileName, "decode.pgm");
			decoder->DecodeFileNameSpecify = TRUE;
			decoder->TargetBitRate = BitRate ;
			Decode(decoder);
			
			ImagePSNR = ImageFileComparePSNR(decoder->OriginalImageFileName,
												decoder->DecodeImageFileName);
			fprintf(RDLog, "%9.4lf %9.4lf %9.4lf\n", BitRate, ImagePSNR, 
				255*255*pow(10.0, -ImagePSNR/10));
			
			fflush(RDLog);

			printf("%9.4lf %9.4lf %9.4lf\n", BitRate, ImagePSNR, 
				255*255*pow(10.0, -ImagePSNR/10));
		
			free(decoder);
			PrintLeaks();

			if (Profile){
				BitRate *=2.0;
			}
			else{
				BitRate += RateInc;
			}

			if (BitRate > LastRate + 0.1*RateInc){
				break;
			}
		}while(1);

		fclose(RDLog);
	}
	else{
		fprintf(stderr, "To do ...\n");
	}

	fprintf(stderr, "Done.\n");
	return 0;
}

/*--------------------------------------------------------------------------------------------*/
int EncodeInterface(int argc, char **argv, char *ProgramName, Coder *coder)
{
	/* default */
	coder->NScale = DefaultScale;
	coder->nSubbands = 3*coder->NScale+1;
	coder->EncodeFileNameSpecify = FALSE;
	coder->WaveletIndex = DefaultWaveletIndex;
	coder->TestFullBitPlane = FALSE;
	
	/* required */
	if (argc<2){
		Usage(ProgramName);
		return -1;
	}

	coder->InputImageName = argv[0];
	coder->TargetBitRate = atof(argv[1]);
	argv+=2; argc-=2;
	
	while (argc > 0){
		if (!strcmp("-l", *argv)){
			argv++; argc--;
			if (argc==0){ Usage(ProgramName); return -1;}
			coder->NScale = atoi(*argv);
			if (coder->NScale < 3 || coder->NScale >= (1<<ScaleBits)){
				coder->NScale = DefaultScale;
			}
			coder->nSubbands = 3*coder->NScale+1;
			argv++; argc--;
		}
		else if (!strcmp("-w", *argv)){
			argv++; argc--;
			if (argc==0){ Usage(ProgramName); return -1;}
			coder->WaveletIndex = atoi(*argv);
			if (coder->WaveletIndex<0 || coder->WaveletIndex >= (1<<WaveletIndexBits)){
				coder->WaveletIndex = 0;
			}
			argv++; argc--;
		}
		else if (!strcmp("-o", *argv)){
			argv++; argc--;
			if (argc==0){ Usage(ProgramName); return -1;}
			sprintf(coder->EncodeImageFileName, "%s.%s", *argv, ENC_EXT);
			coder->EncodeFileNameSpecify = TRUE;
			argv++; argc--; 
		}
		else if (!strcmp("-p", *argv)){
			argv++; argc--;
			if (argc==0){ Usage(ProgramName); return -1;}
			coder->LastFullBitPlane = atoi(*argv);
			coder->TestFullBitPlane = TRUE;
			argv++; argc--;
		}
		else{
			Usage(ProgramName);
			return -1;
		}
	}
	
	Encode(coder);
	
	return 0;
}

/*--------------------------------------------------------------------------------------------*/
int DecodeInterface(int argc, char **argv, char *ProgramName, Coder *coder)
{
	Boolean ComparePSNR;
	char *OriginalImageName;

	/* default */
	ComparePSNR = FALSE;
	coder->DecodeFileNameSpecify = FALSE;
	
	/* required */
	if (argc<1){
		Usage(ProgramName);
		return -1;
	}

	coder->EncodeImageName = argv[0];
	argc--; argv++;
	
	while(argc>0){
		if (!strcmp("-o", *argv)){
			argv++; argc--;
			OriginalImageName = *argv;
			argv++; argc--;
			sprintf(coder->OriginalImageFileName, "%s.pgm", OriginalImageName);
			ComparePSNR = TRUE;
		}
		else if (!strcmp("-d", *argv)){
			argv++; argc--;
			sprintf(coder->DecodeImageFileName, "%s.%s.pgm", *argv, ENC_EXT);
			coder->DecodeFileNameSpecify = TRUE;
			argv++; argc--; 
		}
		else if (!strcmp("-r", *argv)){
			argv++; argc--;
			coder->TargetBitRate = atof(*argv);
			if (coder->TargetBitRate < 0){
				coder->TargetBitRate = 0;
			}
			argv++; argc--;
		}
		else{
			Usage(ProgramName);
			return -1;
		}
	}

	sprintf(coder->EncodeImageFileName, "%s.%s", coder->EncodeImageName, ENC_EXT);

	Decode(coder);

	if (ComparePSNR){
		printf("PSNR = %.4lf dB\n", ImageFileComparePSNR(coder->DecodeImageFileName, 
			coder->OriginalImageFileName));
	}	

	return 0;

}