ezw3.c

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

				coder->dwt->SubbandPtr[Data->n][Data->i] 
					= sign*(Real)Dequantize(coder->Magnitude[Data->n][Data->i], 
                                       coder->CurrentThreshold, GAMMA);
			}

         coder->nRF++;

			current = current->next;	/* move on to next node */
		}
	}

	coder->RefinementMark[coder->MaxBitPlane-coder->CurrentBitPlane] = DListTail(&coder->LSP);

   return 0;
}

/*--------------------------------------------------------------------------------------------*/
#endif
/*--------------------------------------------------------------------------------------------*/

/*--------------------------------------------------------------------------------------------*/
void BuildCodingArrays(Coder *coder)
{	
   int n, Size;

	coder->SubbandXSize = (int *)calloc(coder->nSubbands, sizeof(int));
	TEST_MALLOC(coder->SubbandXSize);

	coder->SubbandYSize = (int *)calloc(coder->nSubbands, sizeof(int));
	TEST_MALLOC(coder->SubbandYSize);

	coder->SubbandSize = (int *)calloc(coder->nSubbands, sizeof(int));
	TEST_MALLOC(coder->SubbandSize);

	coder->Magnitude = (int **)calloc(coder->nSubbands, sizeof(int *)); 
	TEST_MALLOC(coder->Magnitude);
	
	if (coder->Mode == ENCODE){
		coder->MaxMagnitude = (int **)calloc(coder->nSubbands, sizeof(int *)); 
		TEST_MALLOC(coder->MaxMagnitude);
	}
	else{
		coder->MaxMagnitude = NULL;
	}
	
	coder->State = (unsigned int **)calloc(coder->nSubbands, sizeof(unsigned int *)); 
	TEST_MALLOC(coder->State);
	
	for (n=0; n<coder->nSubbands; n++){

		Size = coder->dwt->SubbandSize[n];
		coder->SubbandSize[n] = Size;
		coder->SubbandXSize[n] = coder->dwt->SubbandXSize[n];
		coder->SubbandYSize[n] = coder->dwt->SubbandYSize[n];

		coder->Magnitude[n]  = (int *)calloc(Size, sizeof(int));
		TEST_MALLOC(coder->Magnitude[n]);
		
		if (coder->Mode == ENCODE){
			coder->MaxMagnitude[n] = (int *)calloc(Size, sizeof(int));
			TEST_MALLOC(coder->MaxMagnitude[n]);
		}
		
		coder->State[n] = (unsigned int *)calloc(Size, sizeof(unsigned int));
		TEST_MALLOC(coder->State[n]);		
	}
	
	return;

}

/*--------------------------------------------------------------------------------------------*/
void DestroyCodingArrays(Coder *coder)
{
		int n;

	for (n=0; n<coder->nSubbands; n++){
		free(coder->Magnitude[n]);
		
		if (coder->Mode == ENCODE){
			free(coder->MaxMagnitude[n]);
		}
		
		free(coder->State[n]);
	}

	free(coder->Magnitude);
	
	if (coder->Mode == ENCODE){
		free(coder->MaxMagnitude);
	}
	
	free(coder->SubbandSize);
	free(coder->SubbandXSize);
	free(coder->SubbandYSize);
	free(coder->State);

	return;

}

/*--------------------------------------------------------------------------------------------*/
void ComputeMaxMagnitudeTree(Coder *coder)
{
	int cn, n, i;
	int index, MaxMag;
	int x, y, bx, by;
	int cXSize;	

	assert(coder->Mode == ENCODE);
	
	fprintf(stdout, "Build maximum magnitude array and perform quantization ...\n");
	
	/* highest scale */
	for (n = coder->nSubbands-1; n > coder->nSubbands-4; n--){
		
      i = 0;
		for (y=0; y<coder->SubbandYSize[n]; y++){
			for (x=0; x<coder->SubbandXSize[n]; x++){
				
            index = Quantize(coder->dwt->SubbandPtr[n][i], 1.0);
				
            coder->Magnitude[n][i] = abs(index);
				
            if (SIGN(index) > 0){
               coder->State[n][i] = SETBIT(coder->State[n][i], SIGN_CTX_BIT);
            }
            
            if (coder->Magnitude[n][i]>0){              
               coder->MaxMagnitude[n][i] = SETBIT(coder->MaxMagnitude[n][i], 
                                             1<<Log2(coder->Magnitude[n][i]));
            }
            
				i++;	/* next coefficient */
			}
		}
	}
	
	/* highpass */
	for (n = coder->nSubbands-4; n > 0; n--){
		
      i = 0;
		/* descendants subband index */
		cn = n+3;
		cXSize = coder->SubbandXSize[cn];
				
		for (y=0; y<coder->SubbandYSize[n]; y++){
			for (x=0; x<coder->SubbandXSize[n]; x++){
				
            index = Quantize(coder->dwt->SubbandPtr[n][i], 1.0);
				
            coder->Magnitude[n][i] = abs(index);
				
            if (SIGN(index) > 0){
               coder->State[n][i] = SETBIT(coder->State[n][i], SIGN_CTX_BIT);
            }
             
            if (coder->Magnitude[n][i]>0){              
               coder->MaxMagnitude[n][i] = SETBIT(coder->MaxMagnitude[n][i], 
                                             1<<Log2(coder->Magnitude[n][i]));
            }

            bx = x<<1;
				by = y<<1;
				

				coder->MaxMagnitude[n][i] |= (coder->MaxMagnitude[cn][(by)*cXSize+bx] |
                                          coder->MaxMagnitude[cn][(by)*cXSize+bx+1] |
                                          coder->MaxMagnitude[cn][(by+1)*cXSize+bx] |
                                          coder->MaxMagnitude[cn][(by+1)*cXSize+bx+1]);
				
            i++;	/* next coefficient */
			}
		}	/* end subband */
	}
	
	/* baseband */
	i = 0;
	for (y=0; y<coder->SubbandYSize[0]; y++){
		for (x=0; x<coder->SubbandXSize[0]; x++){

			index = Quantize(coder->dwt->SubbandPtr[n][i], 1.0);
			
         coder->Magnitude[0][i] = abs(index);
			
         if (SIGN(index) > 0){
            coder->State[0][i] = SETBIT(coder->State[0][i], SIGN_CTX_BIT);            
         }
            
         if (coder->Magnitude[0][i]>0){             
            coder->MaxMagnitude[0][i] = SETBIT(coder->MaxMagnitude[0][i], 
                                          1<<Log2(coder->Magnitude[0][i]));
         }
         
         coder->MaxMagnitude[0][i] |= (coder->MaxMagnitude[1][i] | 
                                       coder->MaxMagnitude[2][i] | 
                                       coder->MaxMagnitude[3][i]);

			i++;	/* next coefficient */
		}
	}

	/* find the maximum magnitude */
	MaxMag = 0;

	for(i=0; i < coder->SubbandSize[0]; i++){
		if (MaxMag < coder->MaxMagnitude[0][i]){
			MaxMag = coder->MaxMagnitude[0][i];
		}
		if (MaxMag<coder->Magnitude[0][i]){
			MaxMag = coder->Magnitude[0][i];
		}
	}
	
	coder->MaxBitPlane = Log2(MaxMag);
	coder->CurrentBitPlane = coder->MaxBitPlane;
	coder->MaxThreshold = 1<<(coder->MaxBitPlane);
	coder->CurrentThreshold = coder->MaxThreshold;
   fprintf(stdout, "Max Bitplane = %d\n", coder->MaxBitPlane);

}

/*--------------------------------------------------------------------------------------------*/
void WriteHeader(Coder *coder)
{
	/* image size */
	AREncoderEncodeBits(coder->Encoder, ImageXSizeBits, coder->ImageXSize);
	AREncoderEncodeBits(coder->Encoder, ImageYSizeBits, coder->ImageYSize);
	/* decomposition steps */
	AREncoderEncodeBits(coder->Encoder, ScaleBits, coder->NScale);
	/* wavelet index */
	AREncoderEncodeBits(coder->Encoder, WaveletIndexBits, coder->WaveletIndex);
	/* initial bitplane */
	AREncoderEncodeBits(coder->Encoder, MaxBitPlaneBits, coder->MaxBitPlane);

#if _CODE_MEAN_
   AREncoderEncodeBits(coder->Encoder, 8, coder->mean);
#endif
   
}

/*--------------------------------------------------------------------------------------------*/
void ReadHeader(Coder *coder)
{
	unsigned int value;

	/* image size */
	coder->ImageXSize = (int)ARDecoderDecodeBits(coder->Decoder, ImageXSizeBits);
	coder->ImageYSize = (int)ARDecoderDecodeBits(coder->Decoder, ImageYSizeBits);

	/* decomposition steps */
	coder->NScale = (int)ARDecoderDecodeBits(coder->Decoder, ScaleBits);
	coder->nSubbands = 3*coder->NScale+1;
	/* wavelet index */
	coder->WaveletIndex = (int)ARDecoderDecodeBits(coder->Decoder, WaveletIndexBits);
	/* initial bitplane */
	coder->MaxBitPlane = (int)ARDecoderDecodeBits(coder->Decoder, MaxBitPlaneBits);

	coder->CurrentBitPlane = coder->MaxBitPlane;
	coder->MaxThreshold = 1<<coder->MaxBitPlane;
	coder->CurrentThreshold = coder->MaxThreshold;

#if _CODE_MEAN_
   coder->mean = (int)ARDecoderDecodeBits(coder->Decoder, 8);
#endif
	
}

/*--------------------------------------------------------------------------------------------*/	
int WriteSymbol(Coder *coder, Histo *c, int symbol)
{
	if (AREncoderBitsOutput(coder->Encoder) < coder->TargetBits){
		AREncoderEncodeMSymbol(coder->Encoder, symbol, c);
		coder->CodedSymbols++;
		return 0;
	}
	else{
		return 1;
	}
}

/*--------------------------------------------------------------------------------------------*/
int ReadSymbol(Coder *coder, Histo *c, int *symbol)
{
	if (ARDecoderBitsInput(coder->Decoder) < coder->TargetBits){
		*symbol = ARDecoderDecodeMSymbol(coder->Decoder, c);
		coder->CodedSymbols++;
		return 0;
	}
	else{
		return 1;
	}
}

/*--------------------------------------------------------------------------------------------*/
int BytesCount(Coder *coder)
{
	if (coder->Mode == ENCODE){
		return ((AREncoderBitsOutput(coder->Encoder))>>3);
	}
	else{
		return ((ARDecoderBitsInput(coder->Decoder))>>3);
	}
}

/*--------------------------------------------------------------------------------------------*/
void DeleteData(void *data)
{
	free((ListData *)data);
}

/*--------------------------------------------------------------------------------------------*/
ListData *CreateData(int i, int x, int y, char n)
{
	ListData *data;

	if ( (data = (ListData *)malloc(sizeof(ListData)))==NULL){
		Error("CreateData: Fail to create data\n");
	}

	data->i = i;
	data->x = x;
	data->y = y;
	data->n = n;

	return data;
}

/*--------------------------------------------------------------------------------------------*/
void AllocModels(Coder *coder)
{
   int n, i, k;

   coder->SSigModel = (Histo ***)malloc(sizeof(Histo **)*coder->nSubbands);
   coder->RefiModel = (Histo ***)malloc(sizeof(Histo **)*coder->nSubbands);

   for (n=0; n<coder->nSubbands; n++){
      
      coder->SSigModel[n] = (Histo **)malloc(sizeof(Histo *)*nSSigModel);
      for (i=0; i<nSSigModel; i++){         
         if (n<coder->nSubbands-3){
            coder->SSigModel[n][i] = HistoAlloc(SSIG_MAX, 4);
         }
         else{
            coder->SSigModel[n][i] = HistoAlloc(SSIG_MAX, 3);
         }       
      }

      coder->RefiModel[n] = (Histo **)malloc(sizeof(Histo *)*nRefiModel);
      for (i=0; i<nRefiModel; i++){         
         coder->RefiModel[n][i] = HistoAlloc(REFI_MAX, 2);
      }
   }

}

/*--------------------------------------------------------------------------------------------*/
void DeallocModels(Coder *coder)
{
   int n, i, k;

   for (n=0; n<coder->nSubbands; n++){

      for (i=0; i<nSSigModel; i++){
         HistoDealloc(coder->SSigModel[n][i]);
      }
      free(coder->SSigModel[n]);

      for (i=0; i<nRefiModel; i++){
         HistoDealloc(coder->RefiModel[n][i]);
      }
      free(coder->RefiModel[n]);
   }

   free(coder->SSigModel);
   free(coder->RefiModel);
}

/*--------------------------------------------------------------------------------------------*/
void ResetModels(Coder *coder)
{
   int n, i;

   for (n=0; n<coder->nSubbands; n++){

      for (i=0; i<nSSigModel; i++){
         HistoReset(coder->SSigModel[n][i]);
      }
 
      for (i=0; i<nRefiModel; i++){
         HistoReset(coder->RefiModel[n][i]);
      }
   }
}

/*--------------------------------------------------------------------------------------------*/
void Usage(char *ProgramName)
{
	fprintf(stderr, "Encoder Usage:\n");
	fprintf(stderr, "%s e [input image] [bitrate] [options]\n", ProgramName);
	fprintf(stderr, "\t Options:\n");
	fprintf(stderr, "\t -l <number of levels>\n");
	fprintf(stderr, "\t -w <wavelet>\n");
	fprintf(stderr, "\t     0=Antonini  1=Villa1810\n");
	fprintf(stderr, "\t -o <encode filename>\n");
	fprintf(stderr, "\t -p <bitplane> : code to bitplane\n");
	fprintf(stderr, "\n");
	fprintf(stderr, "Decoder Usage:\n");
	fprintf(stderr, "%s d [encode image] [options]\n", ProgramName);
	fprintf(stderr, "\t -d <decode filename>\n");
	fprintf(stderr, "\t -o <original image> for PSNR calculation\n");
	fprintf(stderr, "\t -r <bitrate>\n");
	fprintf(stderr, "\n");
	fprintf(stderr, "Encode-Decode Usage:\n");
	fprintf(stderr, "%s a [input image] [bitrate] [options]\n", ProgramName);
	fprintf(stderr, "\t Options are the same as encoder.\n");
	fprintf(stderr, "\n");
	fprintf(stderr, "R-D Curve:\n");
	fprintf(stderr, "\t Please read the readme file for usage\n");
	return;
}

/*--------------------------------------------------------------------------------------------*/
void GetProgramName(char *NameOnly, char *FullPath)
{
	char *c;

	c = strrchr(FullPath, '\\');
	c++;
	sprintf(NameOnly, c);
	c = strrchr(NameOnly, '.');
	*c = 0;
}

/*--------------------------------------------------------------------------------------------*/
void ChildrenPareCtxBitUpdate(Coder *coder, int n, int x, int y)
{
	int cx, cy, i, j;
	
	if (n==0){
      // 3 offsprings at LH, HL & HH
		coder->State[1][y*coder->SubbandXSize[1]+x]
         = SETBIT(coder->State[1][y*coder->SubbandXSize[1]+x], PARE_CTX_BIT);		
      coder->State[2][y*coder->SubbandXSize[3]+x]
         = SETBIT(coder->State[2][y*coder->SubbandXSize[2]+x], PARE_CTX_BIT);
		coder->State[3][y*coder->SubbandXSize[3]+x]
         = SETBIT(coder->State[3][y*coder->SubbandXSize[3]+x], PARE_CTX_BIT);
		
	}
	else	if (n<coder->nSubbands-3){
				
		n=n+3;
		x<<=1;
		y<<=1;
		i = y*coder->SubbandXSize[n]+x;
		j = i + coder->SubbandXSize[n];

		coder->State[n][i] = SETBIT(coder->State[n][i], PARE_CTX_BIT);
		coder->State[n][i+1] = SETBIT(coder->State[n][i+1], PARE_CTX_BIT);		
      coder->State[n][j] = SETBIT(coder->State[n][j], PARE_CTX_BIT);		
      coder->State[n][j+1] = SETBIT(coder->State[n][j+1], PARE_CTX_BIT);
		
	}
}

/*--------------------------------------------------------------------------------------------*/
void CSigContextUpdate(Coder *coder, int i, int x, int y, int n)
{
   ChildrenPareCtxBitUpdate(coder, n, x, y);
}

/*--------------------------------------------------------------------------------------------*/
int CSigContext(Coder *coder, int i, int n, int LastScanSig)
{
   return (LastScanSig<<1) + CHKBIT(coder->State[n][i], PARE_CTX_BIT);
}