image.c

基于wavelet算法的视频图像压缩

/*---------------------------------------------------------------------------*/
int CopyImage(PIMAGE pimageDest, PIMAGE pimageSrc)
{
   assert((pimageDest->xsize == pimageSrc->xsize) &&
      (pimageDest->ysize == pimageSrc->ysize));
	
   memcpy(pimageDest->pixel[0], pimageSrc->pixel[0], 
      (pimageDest->xsize)*(pimageDest->ysize));
	
   return TRUE;
	
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int CopyLImage(PLIMAGE plimageDest, PLIMAGE plimageSrc)
{
   assert((plimageDest->xsize == plimageSrc->xsize) &&
      (plimageDest->ysize == plimageSrc->ysize));
	
   memcpy(plimageDest->pixel[0], plimageSrc->pixel[0], 
      (plimageDest->xsize)*(plimageDest->ysize)*sizeof(int));
	
   return TRUE;
	
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int CopyFImage(PFIMAGE pfimageDest, PFIMAGE pfimageSrc)
{
   assert((pfimageDest->xsize == pfimageSrc->xsize) &&
      (pfimageDest->ysize == pfimageSrc->ysize));
	
   memcpy(pfimageDest->pixel[0], pfimageSrc->pixel[0], 
      (pfimageDest->xsize)*(pfimageDest->ysize)*sizeof(double));
	
   return TRUE;
	
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int CopyImageToFImage(PFIMAGE pfimageDest, PIMAGE pimageSrc)
{
	int i, j;
	
   assert((pfimageDest->xsize == pimageSrc->xsize) &&
      (pfimageDest->ysize == pimageSrc->ysize));
	
	for (j=0; j<pfimageDest->ysize; j++){
		for (i=0; i<pfimageDest->xsize; i++){
			pfimageDest->pixel[j][i] = (double)pimageSrc->pixel[j][i];
		}
	}
   
   return TRUE;
	
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int CopyFImageToImage(PIMAGE pimageDest, PFIMAGE pfimageSrc)
{
	int i, j;
	
   assert((pimageDest->xsize == pfimageSrc->xsize) &&
      (pimageDest->ysize == pfimageSrc->ysize));
	
	for (j=0; j<pimageDest->ysize; j++){
		for (i=0; i<pimageDest->xsize; i++){
			pimageDest->pixel[j][i] = (int)( (pfimageSrc->pixel[j][i]+0.5) < 0.0 ? 0 : 
											( (pfimageSrc->pixel[j][i]+0.5) > 255.0 ? 
												255 : (pfimageSrc->pixel[j][i]+0.5)));
		}
	}
   
   return TRUE;
	
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
 * Average2x2Image
 * Return a floating point image by 2x2 
 * averaging the source image
 */
PFIMAGE Average2x2Image(PIMAGE pimageSrc, int type)
{
   PFIMAGE pfimage;
   int ii, jj, i, j, XLimit, YLimit;
	
   /* allocate the memory */
   pfimage = (PFIMAGE)malloc(sizeof(FIMAGE));
	
   pfimage->xsize=pimageSrc->xsize/2;
   pfimage->ysize=pimageSrc->ysize/2;
	
   if (FImageBufferAlloc(pfimage)){
      switch (type){
		case 0: ii = 0; jj = 0; break;
		case 1: ii = 1; jj = 0; break;
		case 2: ii = 0; jj = 1; break;
		case 3: ii = 1; jj = 1; break;
      }
		
		XLimit = (pimageSrc->xsize - ii) / 2;
		YLimit = (pimageSrc->ysize - jj) / 2;

      for (j=0; j<YLimit; j++){
         for (i=0; i<XLimit; i++){
            pfimage->pixel[j][i]= (double)
               0.25*(pimageSrc->pixel[(j<<1) + jj][(i<<1) + ii] +
					pimageSrc->pixel[(j<<1) + jj][(i<<1) + ii + 1] +
					pimageSrc->pixel[(j<<1) + jj + 1][(i<<1) + ii] +
					pimageSrc->pixel[(j<<1) + jj + 1][(i<<1) + ii + 1]);
         }
      }
      return pfimage;
   }
   else{
      return NULL;
   }
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/* 
 * Average3x3Image
 * Return a floating point image by 3x3 
 * averaging the source image
 */
PFIMAGE Average3x3Image(PIMAGE pimageSrc, int type)
{
   PFIMAGE pfimage;
   int ii, jj, i, j, XLimit, YLimit;
	
   /* allocate the memory */
   pfimage = (PFIMAGE)malloc(sizeof(FIMAGE));
	
   pfimage->xsize=pimageSrc->xsize/3;
   pfimage->ysize=pimageSrc->ysize/3;

   if (FImageBufferAlloc(pfimage)){
      switch (type){
		case 0: ii = 0; jj = 0; break;
		case 1: ii = 1; jj = 0; break;
		case 2: ii = 2; jj = 0; break;
		case 3: ii = 0; jj = 1; break;
		case 4: ii = 1; jj = 1; break;
		case 5: ii = 2; jj = 1; break;
		case 6: ii = 0; jj = 2; break;
		case 7: ii = 1; jj = 2; break;
		case 8: ii = 2; jj = 2; break;
      }
		
		XLimit = (pimageSrc->xsize - ii) / 3;
		YLimit = (pimageSrc->ysize - jj) / 3;

      for (j=0; j<YLimit; j++){
         for (i=0; i<XLimit; i++){
            pfimage->pixel[j][i] = (double)
               (  pimageSrc->pixel[3*j + jj    ][3*i + ii    ] +
					   pimageSrc->pixel[3*j + jj    ][3*i + ii + 1] +
					   pimageSrc->pixel[3*j + jj    ][3*i + ii + 2] +
					   pimageSrc->pixel[3*j + jj + 1][3*i + ii    ] +
					   pimageSrc->pixel[3*j + jj + 1][3*i + ii + 1] +
					   pimageSrc->pixel[3*j + jj + 1][3*i + ii + 2] +
					   pimageSrc->pixel[3*j + jj + 2][3*i + ii    ] +
					   pimageSrc->pixel[3*j + jj + 2][3*i + ii + 1] +
					   pimageSrc->pixel[3*j + jj + 2][3*i + ii + 2])/(double)9.0;
         }
      }

      return pfimage;
   }
   else{
      return NULL;
   }
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*
 * Average3x3ImageFilter0
 * Return a floating point image by 3x3 with filter
 * averaging the source image
 */
PFIMAGE Average3x3ImageFilter0(PIMAGE pimageSrc, int type)
{
   PFIMAGE pfimage;
   int ii, jj, i, j, XLimit, YLimit;
	double FilterCoeff[9] = {0.25, 0.50, 0.25, 
		                   0.50, 1.00, 0.50,
								 0.25, 0.50, 0.25};
	
   /* allocate the memory */
   pfimage = (PFIMAGE)malloc(sizeof(FIMAGE));
	
   pfimage->xsize=pimageSrc->xsize/3;
   pfimage->ysize=pimageSrc->ysize/3;
	
   if (FImageBufferAlloc(pfimage)){
      switch (type){
		case 0: ii = 0; jj = 0; break;
		case 1: ii = 1; jj = 0; break;
		case 2: ii = 2; jj = 0; break;
		case 3: ii = 0; jj = 1; break;
		case 4: ii = 1; jj = 1; break;
		case 5: ii = 2; jj = 1; break;
		case 6: ii = 0; jj = 2; break;
		case 7: ii = 1; jj = 2; break;
		case 8: ii = 2; jj = 2; break;
      }
		
		
		XLimit = (pimageSrc->xsize - ii) / 3;
		YLimit = (pimageSrc->ysize - jj) / 3;

      for (j=0; j<YLimit; j++){
         for (i=0; i<XLimit; i++){
            pfimage->pixel[j][i] = (double)
               (  FilterCoeff[0]*pimageSrc->pixel[3*j + jj    ][3*i + ii    ] +
					   FilterCoeff[1]*pimageSrc->pixel[3*j + jj    ][3*i + ii + 1] +
					   FilterCoeff[2]*pimageSrc->pixel[3*j + jj    ][3*i + ii + 2] +
					   FilterCoeff[3]*pimageSrc->pixel[3*j + jj + 1][3*i + ii    ] +
					   FilterCoeff[4]*pimageSrc->pixel[3*j + jj + 1][3*i + ii + 1] +
					   FilterCoeff[5]*pimageSrc->pixel[3*j + jj + 1][3*i + ii + 2] +
					   FilterCoeff[6]*pimageSrc->pixel[3*j + jj + 2][3*i + ii    ] +
					   FilterCoeff[7]*pimageSrc->pixel[3*j + jj + 2][3*i + ii + 1] +
					   FilterCoeff[8]*pimageSrc->pixel[3*j + jj + 2][3*i + ii + 2])/(double)4.0;
         }
      }
      return pfimage;
   }
   else{
      return NULL;
   }
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int ImageInitialize(int XSize, int YSize, PIMAGE pimage)
{
	assert(XSize>0 && YSize>0);
	
	pimage->xsize=XSize;
   pimage->ysize=YSize;
	
   /* Allocate memory */
   if(!ImageBufferAlloc(pimage)){
      return 0;
   }
	else{
		return 1; 
	}
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int LImageInitialize(int XSize, int YSize, PLIMAGE plimage)
{
	assert(XSize>0 && YSize>0);
	
	plimage->xsize=XSize;
   plimage->ysize=YSize;
	
   /* Allocate memory */
   if(!LImageBufferAlloc(plimage)){
      return 0;
   }
	else{
		return 1; 
	}
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
int FImageInitialize(int XSize, int YSize, PFIMAGE pfimage)
{
	assert(XSize>0 && YSize>0);
	
	pfimage->xsize=XSize;
   pfimage->ysize=YSize;
	
   /* Allocate memory */
   if(!FImageBufferAlloc(pfimage)){
      return 0;
   }
	else{
		return 1;
	}
}


/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
PIMAGE ImageAlloc(int XSize, int YSize)
{
   PIMAGE pimage;
	
	assert(XSize>0 && YSize>0);
	
   pimage = (PIMAGE)malloc(sizeof(IMAGE));
   pimage->xsize=XSize;
   pimage->ysize=YSize;
	
   /* Allocate memory */
   if(!ImageBufferAlloc(pimage)){
      return NULL;
   }
	else{
		return pimage; 
	}
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
PLIMAGE LImageAlloc(int XSize, int YSize)
{
   PLIMAGE plimage;
	
	assert(XSize>0 && YSize>0);
	
   plimage = (PLIMAGE)malloc(sizeof(LIMAGE));
   plimage->xsize=XSize;
   plimage->ysize=YSize;
	
   /* Allocate memory */
   if(!LImageBufferAlloc(plimage)){
      return NULL;
   }
	else{
		return plimage; 
	}
}

/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
PFIMAGE FImageAlloc(int XSize, int YSize)
{
   PFIMAGE pfimage;
	
	assert(XSize>0 && YSize>0);
	
   pfimage = (PFIMAGE)malloc(sizeof(FIMAGE));
   pfimage->xsize=XSize;
   pfimage->ysize=YSize;
	
   /* Allocate memory */
   if(!FImageBufferAlloc(pfimage)){
      return NULL;
   }
	else{
		return pfimage; 
	}
}


/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/	
/* Adapted from G.Davis Baseline Wavelet Transform Coder Construction Kit		*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------*/	
/*----------------------------------------------------------------------------*/	
PIMAGE ReadPGM(char *PGMFileName)
{
	FILE *fp;
	PIMAGE pimage;
	unsigned char ch=' ';
	char ftype;
	int MaxG;
	

	pimage=(PIMAGE)malloc(sizeof(IMAGE));
	if (pimage==NULL){
		return NULL;
	}

	if ((fp=fopen(PGMFileName, "rb"))==NULL){
		free(pimage);
		return NULL;
	}
	
	/* Process the header */
	while ((ch != 'P') && (ch != '#')){ 
		ch = fgetc(fp);
	}
	
	/* Skip the comment */
	PGMSkipComments(fp, &ch);

	/* File type, only P5 */
	ftype = fgetc(fp);
	
	if (ftype != '5'){
		ImageWarning("Only binary PGM is supported.\n");
		free(pimage);
		fclose(fp);
		return NULL;
	}

	pimage->xsize=(int)PGMGetVal(fp);
	pimage->ysize=(int)PGMGetVal(fp);
	MaxG=(int)PGMGetVal(fp);
	
	/* Allocate the buffer */
	if(!ImageBufferAlloc(pimage)){
		free(pimage);
		return NULL;
	}
	
	/* Offset from the end of the file - avoid reading comments etc. */
	fseek(fp, -1*pimage->xsize * pimage->ysize, SEEK_END);

	/* Load the data */
	if (fread(pimage->pixel[0], sizeof(unsigned char),
		pimage->xsize*pimage->ysize, fp) != (unsigned int)pimage->xsize*pimage->ysize){
		fclose(fp);
		ImageBufferFree(pimage);
		free(pimage);
		return NULL;
	}
	else{
		fclose(fp);
		return pimage;
	}
}

/*----------------------------------------------------------------------------*/	
/*----------------------------------------------------------------------------*/	
PFIMAGE ReadPGMToFloat(char *PGMFileName)
{
	FILE *fp;
	PIMAGE pimage;
	PFIMAGE pfimage;

	unsigned char ch=' ';
	char ftype;
	int MaxG, i;
	

	pimage=(PIMAGE)malloc(sizeof(IMAGE));
	if (pimage==NULL){
		return NULL;
	}

	pfimage=(PFIMAGE)malloc(sizeof(FIMAGE));