ezw.cpp

单独的ezw编解码

         
         if (EZWHilbertScan(coder, level-1, LS, n, x, y, LastScanSig)){
            return 1;
         }
         MoveRight(x, y);
         if (EZWHilbertScan(coder, level-1, DS, n, x, y, LastScanSig)){
            return 1;
         }
      }
      break;

   case US:
      if (level<2){
         if (EZWProcessNode(coder, n, *x, *y, LastScanSig)){
            return 1;
         }
         MoveUp(x, y);         
         if (EZWProcessNode(coder, n, *x, *y, LastScanSig)){
            return 1;
         }
         MoveLeft(x, y);        
         if (EZWProcessNode(coder, n, *x, *y, LastScanSig)){
            return 1;
         }
         MoveDown(x, y);         
         if (EZWProcessNode(coder, n, *x, *y, LastScanSig)){
            return 1;
         }         
      }
      else{
         if (EZWHilbertScan(coder, level-1, LS, n, x, y, LastScanSig)){
            return 1;
         }
         MoveUp(x, y);                  
         if (EZWHilbertScan(coder, level-1, US, n, x, y, LastScanSig)){
            return 1;
         }
         MoveLeft(x, y);         
         if (EZWHilbertScan(coder, level-1, US, n, x, y, LastScanSig)){
            return 1;
         }
         MoveDown(x, y);        
         if (EZWHilbertScan(coder, level-1, RS, n, x, y, LastScanSig)){
            return 1;
         }
      }

      break;

   case DS:
      if (level<2){
         if (EZWProcessNode(coder, n, *x, *y, LastScanSig)){
            return 1;
         }
         MoveDown(x, y);         
         if (EZWProcessNode(coder, n, *x, *y, LastScanSig)){
            return 1;
         }
         MoveRight(x, y);         
         if (EZWProcessNode(coder, n, *x, *y, LastScanSig)){
            return 1;
         }
         MoveUp(x, y);
         if (EZWProcessNode(coder, n, *x, *y, LastScanSig)){
            return 1;
         }         
      }
      else{
         if (EZWHilbertScan(coder, level-1, RS, n, x, y, LastScanSig)){
            return 1;
         }
         MoveDown(x, y);         
         if (EZWHilbertScan(coder, level-1, DS, n, x, y, LastScanSig)){
            return 1;
         }
         MoveRight(x, y);         
         if (EZWHilbertScan(coder, level-1, DS, n, x, y, LastScanSig)){
            return 1;
         }
         MoveUp(x, y);
         if (EZWHilbertScan(coder, level-1, LS, n, x, y, LastScanSig)){
            return 1;
         }
      }

      break;

   default:
      Error("Scan direction is not defined.\n");
   }

   return 0;

}

/*--------------------------------------------------------------------------------------------*/
int EZWSortingPassHilbertScan(Coder *coder, int n)
{
   int x, y, level;
   int LastScanSig;
 
   LastScanSig = 0;

   // determine the level
   level = Log2((coder->SubbandXSize[n] >= coder->SubbandYSize[n] ?
                  coder->SubbandXSize[n]-1 : coder->SubbandYSize[n]-1))+1;

   // first point
   x = 0;
   y = 0;
   LastScanSig = 0;

   EZWHilbertScan(coder, level, ((level%2)? RS : DS), n, &x, &y, &LastScanSig);
   
   return 0;
}

/*--------------------------------------------------------------------------------------------*/
int EZWSortingPass(Coder *coder)
{
   int n;

   int (*EZWLLScan)(Coder *, int);
   int (*EZWHLScan)(Coder *, int);
   int (*EZWLHScan)(Coder *, int);
   int (*EZWHHScan)(Coder *, int);

   //---------------------------------------------------------------------
   EZWLLScan = EZWSortingPassHilbertScan;
   EZWHLScan = EZWSortingPassVerticalScan;
   EZWLHScan = EZWSortingPassHorizontalScan;
   EZWHHScan = EZWSortingPassHilbertScan;

   // LL
   if (EZWLLScan(coder, 0)){
      return 1;
   }

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

      // HL
      if (EZWHLScan(coder, n)){
         return 1;
      }
      // LH
      if (EZWLHScan(coder, n+1)){
         return 1;
      }
      // HH
      if (EZWHHScan(coder, n+2)){
         return 1;
      }
   }

   return 0;
}

/*--------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------*/
/* The newly significant coefficients are refined in this pass */
int EZWRefinementPass(Coder *coder)
{
  	ListData *Data;
	DListElement *current; 
	int bitn, sign;
	int p, lp;
	
	current = DListHead(&coder->LSP);

	lp = coder->MaxBitPlane - coder->CurrentBitPlane;

	for (p=0; p<lp; p++){
		
      while(current != coder->RefinementMark[p]->next){
		
			Data = (ListData *)current->data;
			
			assert(CHKBIT(coder->State[Data->n][Data->i], CSIG_CTX_BIT));
			
			if (coder->Mode == ENCODE){

				bitn = (coder->Magnitude[Data->n][Data->i] & coder->CurrentThreshold);
				bitn = (bitn == 0? 0 : 1);
      		
				if(EZWWSymbol(coder,bitn)){
					return 1;
				}
      		
			}
			else{
				
				if (EZWRSymbol(coder,&bitn)) {
					return 1;
				}
								
				/* compute the refined index */
				coder->Magnitude[Data->n][Data->i] <<= 1;
				coder->Magnitude[Data->n][Data->i] += bitn;

				sign = (CHKBIT(coder->State[Data->n][Data->i], SIGN_CTX_BIT) ? 1 : -1);

				coder->SubbandPtr[Data->n][Data->i] 
					= sign*(int)EZWDequantize(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;
}

/*--------------------------------------------------------------------------------------------*/

/*--------------------------------------------------------------------------------------------*/
void EZWBuildCodingArrays(Coder *coder,int *ezwcomp)
{	
	int n, i, j, k, Size;
	int xsize,ysize;
	int add = 1 << coder->NScale;

	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);
	
	//process the image size
	//coder->FXSize,coder->FYSize图像实际大小
	coder->ImageXSize = coder->FXSize;
	coder->ImageYSize = coder->FYSize;
	if ((coder->ImageXSize>>(coder->NScale))<<(coder->NScale) != coder->ImageXSize){		
		coder->ImageXSize = ((coder->ImageXSize>>(coder->NScale))<<(coder->NScale)) + add;
		if((coder->ImageYSize>>(coder->NScale))<<(coder->NScale) != coder->ImageYSize){			
			coder->ImageYSize = ((coder->ImageYSize>>(coder->NScale))<<(coder->NScale)) + add;
		}
	}

	coder->Coeff=(int *)calloc(coder->ImageXSize*coder->ImageYSize, sizeof(int));

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

	//分配自带大小
	xsize = coder->ImageXSize;
	ysize = coder->ImageYSize;
	for(i = coder->NScale-1; i >= 0; i--)
	{
		coder->SubbandXSize[3*i+1] = (xsize >>= 1);
		coder->SubbandYSize[3*i+1] = (ysize >>= 1);
		
		coder->SubbandXSize[3*i+2] = xsize;
		coder->SubbandYSize[3*i+2] = ysize;
		
		coder->SubbandXSize[3*i+3] = xsize;
		coder->SubbandYSize[3*i+3] = ysize;
	}
	coder->SubbandXSize[0] = xsize;
	coder->SubbandYSize[0] = ysize;

	coder->SubbandSize[0] = coder->SubbandXSize[0]*coder->SubbandYSize[0];
	
	/* move transformed image (in Mallat order) into linear array structure */
	/* special case for LL subband */
	coder->SubbandPtr[0] = coder->Coeff;
	for (i = 1; i < coder->nSubbands; i++) {
		coder->SubbandSize[i] = coder->SubbandXSize[i]*coder->SubbandYSize[i];
		coder->SubbandPtr[i] = coder->SubbandPtr[i-1] + coder->SubbandSize[i-1];
	}
	for (j = 0; j < coder->SubbandYSize[0]; j++){
		for (i = 0; i < coder->SubbandXSize[0]; i++){
			coder->SubbandPtr[0][j*coder->SubbandXSize[0]+i] = ezwcomp[j*coder->FXSize+i];
		}
	}
	
	for (k = 0; k < coder->NScale-1; k++) {
		for (j = 0; j < coder->SubbandYSize[3*k+1]; j++){
			for (i = 0; i < coder->SubbandXSize[3*k+1]; i++){
				coder->SubbandPtr[3*k+1][j*coder->SubbandXSize[3*k+1]+i] =
					ezwcomp[j*coder->FXSize+(coder->SubbandXSize[3*k+1]+i)];
			}
		}
		
		for (j = 0; j < coder->SubbandYSize[3*k+2]; j++){
			for (i = 0; i < coder->SubbandXSize[3*k+2]; i++){
				coder->SubbandPtr[3*k+2][j*coder->SubbandXSize[3*k+2]+i] = 
					ezwcomp[(coder->SubbandYSize[3*k+2]+j)*coder->FXSize+i];
			}
		}
		
		for (j = 0; j < coder->SubbandYSize[k*3+3]; j++){
			for (i = 0; i < coder->SubbandXSize[k*3+3]; i++){
				coder->SubbandPtr[3*k+3][j*coder->SubbandXSize[k*3+3]+i] = 
					ezwcomp[(coder->SubbandYSize[k*3+3]+j)*coder->FXSize+(coder->SubbandXSize[k*3+3]+i)];
			}
		}
	}
	/*highest pass*/
	/*如果图像需要宽展,多余的部分补零*/
	k=coder->NScale -1;
	for(j = 0; j < coder->SubbandYSize[3*k+1]; j++){
		for(i = 0; i < coder->FXSize-coder->SubbandXSize[3*k+1];i++){
			coder->SubbandPtr[3*k+1][j*coder->SubbandXSize[3*k+1]+i] =
				ezwcomp[j*coder->FXSize+(coder->SubbandXSize[3*k+1]+i)];
		}
	}
	for(j = 0; j < coder->FYSize-coder->SubbandYSize[3*k+2]; j++){
		for(i = 0; i < coder->SubbandXSize[3*k+2];i++){
			coder->SubbandPtr[3*k+2][j*coder->SubbandXSize[3*k+2]+i] = 
				ezwcomp[(coder->SubbandYSize[3*k+2]+j)*coder->FXSize+i];
		}
	}
	for(j = 0; j < coder->FYSize-coder->SubbandYSize[k*3+3]; j++){
		for(i = 0; i < coder->FXSize-coder->SubbandXSize[k*3+3]; i++){
			coder->SubbandPtr[3*k+3][j*coder->SubbandXSize[k*3+3]+i] = 
				ezwcomp[(coder->SubbandYSize[k*3+3]+j)*coder->FXSize+(coder->SubbandXSize[k*3+3]+i)];
		}
	}


	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->SubbandSize[n];		

		coder->Magnitude[n]  = (int *)calloc(Size, sizeof(int));
		TEST_MALLOC(coder->Magnitude[n]);
		
		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 EZWDeBuildCodingArrays(Coder *coder)
{	
	int n, Size,i;
	int add = 1 << coder->NScale;
	int xsize,ysize;
	
	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->Coeff=(int *)calloc(coder->ImageXSize*coder->ImageYSize, sizeof(int));

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

	//coder->FXSize,coder->FYSize图像实际大小
	coder->ImageXSize = coder->FXSize;
	coder->ImageYSize = coder->FYSize;
	if ((coder->ImageXSize>>(coder->NScale))<<(coder->NScale) != coder->ImageXSize){		
		coder->ImageXSize = ((coder->ImageXSize>>(coder->NScale))<<(coder->NScale)) + add;
		if((coder->ImageYSize>>(coder->NScale))<<(coder->NScale) != coder->ImageYSize){			
			coder->ImageYSize = ((coder->ImageYSize>>(coder->NScale))<<(coder->NScale)) + add;
		}
	}
	
	coder->Coeff=(int *)calloc(coder->ImageXSize*coder->ImageYSize, sizeof(int));
	
	coder->SubbandPtr = (int **)calloc(coder->nSubbands, sizeof(int *));
	
	//分配子带大小
	xsize = coder->ImageXSize;
	ysize = coder->ImageYSize;
	for(i = coder->NScale-1; i >= 0; i--)
	{
		coder->SubbandXSize[3*i+1] = (xsize >>= 1);
		coder->SubbandYSize[3*i+1] = (ysize >>= 1);
		
		coder->SubbandXSize[3*i+2] = xsize;
		coder->SubbandYSize[3*i+2] = ysize;
		
		coder->SubbandXSize[3*i+3] = xsize;
		coder->SubbandYSize[3*i+3] = ysize;
	}
	coder->SubbandXSize[0] = xsize;
	coder->SubbandYSize[0] = ysize;
	
	coder->SubbandSize[0] = coder->SubbandXSize[0]*coder->SubbandYSize[0];	
		
	/* set the data pointers */
	coder->SubbandPtr[0] = coder->Coeff;
	for (i = 1; i < coder->nSubbands; i++) {
		coder->SubbandSize[i] = coder->SubbandXSize[i]*coder->SubbandYSize[i];
		coder->SubbandPtr[i] = coder->SubbandPtr[i-1] + coder->SubbandSize[i-1];
	}
	
	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->SubbandSize[n];
		
		coder->Magnitude[n]  = (int *)calloc(Size, sizeof(int));
		TEST_MALLOC(coder->Magnitude[n]);		
			
		coder->State[n] = (unsigned int *)calloc(Size, sizeof(unsigned int));
		TEST_MALLOC(coder->State[n]);		
	}
	
	return;
	
}
/*--------------------------------------------------------------------------------------------*/
void EZWDestroyCodingArrays(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 EZWComputeMaxMagnitudeTree(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 = EZWQuantize(coder->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],