bpe_decoder.c

CCSDS空间图像图像压缩标准c源代码

					for(i = 0; i < StrPtr->ImageWidth; i++)
					{
						image[r][i] = (image[r][i] > 0xFFFF) ? 0xFFFF : image[r][i];
						image[r][i] = (image[r][i] < 0) ? 0 : image[r][i];
						temp_16[i] = (WORD16)image[r][i] ;
					}
					fwrite(temp_16, StrPtr->ImageWidth, sizeof(WORD16), outfile);
				}
			else
			{	
				for(r = 0; r < StrPtr->ImageRows; r++)
				{
					for(i = 0; i < StrPtr->ImageWidth; i++)
					{
						image[r][i] = (image[r][i] > 0xFFFF) ? 0xFFFF : image[r][i];
						image[r][i] = (image[r][i] < 0) ? 0 : image[r][i];						
						image[r][i] = (float)(((int)(image[r][i])) << 8) + (((int)(image[r][i])) >> 8);
						temp_16[i] =(WORD16)image[r][i] ;
					}
					fwrite(temp_16, StrPtr->ImageWidth, sizeof(WORD16), outfile);
				}
			}
			free(temp_16);
		}	
		else
		{
			short *temp_16 = (short *)calloc(sizeof(short), StrPtr->ImageWidth);
			if(StrPtr->PixelByteOrder == 1) // LSB first	
				for(r = 0; r < StrPtr->ImageRows; r++)
				{
					for(i = 0; i < StrPtr->ImageWidth; i++)
					{						
						image[r][i] = (image[r][i] > 0x8FFF) ? 0x8FFF : image[r][i];
						image[r][i] = (image[r][i] < -32768) ? -32768 : image[r][i];
						image[r][i] = (image[r][i] > 0xFFFF) ? 0xFFFF : image[r][i];
						image[r][i] = (image[r][i] < 0) ? 0 : image[r][i];
						image[r][i] =(float) (((int)(image[r][i])) << 8) + (((int)(image[r][i])) >> 8);
						temp_16[i] = (short)image[r][i] ;
					}
					fwrite(temp_16, StrPtr->ImageWidth, sizeof(short), outfile);
				}
			else
			{	
				for(r = 0; r < StrPtr->ImageRows; r++)
				{
					for(i = 0; i < StrPtr->ImageWidth; i++)
					{						
						image[r][i] = (image[r][i] > 0x8FFF) ? 0x8FFF : image[r][i];
						image[r][i] = (image[r][i] < -32768) ? -32768 : image[r][i];
						temp_16[i] =(short)image[r][i] ;
					}
					fwrite(temp_16, StrPtr->ImageWidth, sizeof(short), outfile);
				}
			}
			free(temp_16);
		}
	}
	fclose(outfile);
	return BPE_OK;
}


void DecodingOutputFloating(StructCodingPara *PtrCP,
					float **imgout_floatingcase)
{	
	CoeffDegroupFloating(imgout_floatingcase, PtrCP->ImageRows, PtrCP->ImageWidth + PtrCP->PadCols_3Bits );

	DWT_ReverseFloating(imgout_floatingcase, PtrCP); 

	if (PtrCP->PtrHeader->Header.Part4.TransposeImg == TRANSPOSE)
	{
		UINT32 i = 0;
		UINT32 j = 0;
		float **transposedimg = (float **)calloc(PtrCP->ImageRows,sizeof(float *)); 
		
		for(i = 0; i < PtrCP->ImageRows; i++)
			transposedimg[i] = (float *)calloc((PtrCP->ImageWidth),sizeof(float));	

		for( i = 0 ; i < PtrCP->ImageRows; i ++)
			for(j = 0; j < PtrCP->ImageWidth; j++)
				transposedimg[j][i] = imgout_floatingcase[i][j];
			
		ImageWriteFloat(PtrCP, transposedimg);
	}		
	else
		ImageWriteFloat(PtrCP, imgout_floatingcase);
	
	return;	
}
///////////////////////////////////////////////////////////////////////////////

void TempCoeffOutput(FILE *fdc,
					 FILE * fac, 
					 BitPlaneBits *BlockCodingInfo,
					 StructCodingPara * PtrCoding)
{
	UINT32 i;	
	int totalbytes_counter = 0;

	for(i = 0; i < PtrCoding->PtrHeader->Header.Part3.S_20Bits; i ++)
	{
		int m, n;
//test			
		fwrite(&(BlockCodingInfo[i].PtrBlockAddress[0][0]), 1,sizeof(long), fdc);

		for(m = 0; m < 8; m++)
			for(n = 0; n < 8; n++)
			{
				totalbytes_counter += 4;
				fwrite(&(BlockCodingInfo[i].PtrBlockAddress[m][n]), 1,sizeof(long), fac);
			}

	}
}

void SegmentBufferFlushDecoder(StructCodingPara *StrCoding) // flush codes and reset
{
	
	if((StrCoding->PtrHeader->Header.Part2.SegByteLimit_27Bits != 0)
		&&(StrCoding->SegmentFull == FALSE) && StrCoding->PtrHeader->Header.Part2.UseFill == TRUE)
	{
		DWORD32 temp = 0;
		while(StrCoding->SegmentFull == FALSE)
		{
			BitsRead(StrCoding, &temp, 8);
		}
	}
	
	StrCoding->Bits->TotalBitCounter  +=  StrCoding->Bits->CodeWordAlighmentBits;
	StrCoding->Bits->SegBitCounter = 0;
	StrCoding->Bits->ByteBuffer_4Bytes = 0;
	StrCoding->Bits->CodeWordAlighmentBits = 0;
	return;
}

void DecoderEngine(StructCodingPara * PtrCoding)
{
	UINT32 i = 0;
	UINT32 j = 0;
	UINT32 X = 0;
	UINT32 Y = 0;
	UINT32 TotalBlocks = 0;
	DWORD32 counter = 0;
	UCHAR8 temp_code = 0;

	int **imgout_integercase = NULL;
	float **imgout_floatingcase = NULL;
	StructFreBlockString * StrFreBlockString = NULL;
	StructFreBlockString *tempStr = NULL;

	
	PtrCoding->Bits = (BitStream *)calloc(sizeof(BitStream), 1);
	
	if((PtrCoding->Bits->F_Bits = fopen(PtrCoding->InputFile, "rb")) == NULL)  // default name
		ErrorMsg(BPE_FILE_ERROR);

	HeaderReadin(PtrCoding); // read first header. 	
	PtrCoding->ImageWidth = PtrCoding->PtrHeader->Header.Part4.ImageWidth_20Bits;	
	
	if(PtrCoding->ImageWidth % BLOCK_SIZE != 0)
		PtrCoding->PadCols_3Bits = BLOCK_SIZE - (PtrCoding->ImageWidth % 8 );
	else 
		PtrCoding->PadCols_3Bits  =  0;
	
	StrFreBlockString = (StructFreBlockString *)calloc(sizeof(StructFreBlockString), 1);
	StrFreBlockString->next = NULL;
	StrFreBlockString->previous = NULL;

	TotalBlocks = 0;
	for(;;)
	{		
		BitPlaneBits * BlockCodingInfo;
		BlockCodingInfo = (BitPlaneBits *)calloc(PtrCoding->PtrHeader->Header.Part3.S_20Bits,	sizeof(BitPlaneBits));
		TotalBlocks += PtrCoding->PtrHeader->Header.Part3.S_20Bits;

		StrFreBlockString->FreqBlkString = (long **)calloc(PtrCoding->PtrHeader->Header.Part3.S_20Bits * BLOCK_SIZE,sizeof(long *));
		for(i = 0; i < PtrCoding->PtrHeader->Header.Part3.S_20Bits * BLOCK_SIZE; i++)
			StrFreBlockString->FreqBlkString[i] = (long *)calloc(BLOCK_SIZE,sizeof(long));


		StrFreBlockString->FloatingFreqBlk  = (float **)calloc(PtrCoding->PtrHeader->Header.Part3.S_20Bits * BLOCK_SIZE,sizeof(float *));
		for(i = 0; i < PtrCoding->PtrHeader->Header.Part3.S_20Bits * BLOCK_SIZE; i++)
			StrFreBlockString->FloatingFreqBlk[i] = (float *)calloc(BLOCK_SIZE,sizeof(float));

		StrFreBlockString->Blocks = PtrCoding->PtrHeader->Header.Part3.S_20Bits;
		DCDeCoding(PtrCoding, StrFreBlockString, BlockCodingInfo);
		ACBpeDecoding(PtrCoding, BlockCodingInfo) ;	// This means the decoding process stops before segment limit. 
		AdjustOutPut(PtrCoding, BlockCodingInfo);

	//	TempCoeffOutput(fdc, fac, BlockCodingInfo, PtrCoding);
    	
		free(BlockCodingInfo);			
		SegmentBufferFlushDecoder(PtrCoding);
		PtrCoding->SegmentFull = FALSE;
		PtrCoding->RateReached = FALSE;
		PtrCoding->DecodingStopLocations.BitPlaneStopDecoding = 0;
		PtrCoding->BlockCounter += PtrCoding->PtrHeader->Header.Part3.S_20Bits;
		if(PtrCoding->PtrHeader->Header.Part1.EngImgFlg == TRUE)
			break;
		if (PtrCoding->PtrHeader->Header.Part1.EngImgFlg != TRUE)
			HeaderReadin(PtrCoding); // read second header. 
		tempStr = (StructFreBlockString *)calloc(sizeof(StructFreBlockString), 1);			
		(StrFreBlockString->next) = tempStr;
		tempStr->previous = StrFreBlockString;
		tempStr->next = NULL;
		StrFreBlockString = StrFreBlockString->next;
	}
	// ***************************  5. header information  *****************************//

	PtrCoding->ImageRows = TotalBlocks * 64 /  (PtrCoding->ImageWidth + PtrCoding->PadCols_3Bits ); 

	imgout_integercase = (int **)calloc(PtrCoding->ImageRows,sizeof(int *)); 
	for(i = 0; i < PtrCoding->ImageRows; i++)
		imgout_integercase[i] = (int *)calloc((PtrCoding->ImageWidth + PtrCoding->PadCols_3Bits),sizeof(int));	

	imgout_floatingcase = (float **)calloc(PtrCoding->ImageRows,sizeof(float *)); 
	for(i = 0; i < PtrCoding->ImageRows; i++)
		imgout_floatingcase[i] = (float *)calloc((PtrCoding->ImageWidth + PtrCoding->PadCols_3Bits),sizeof(float));	

	while(StrFreBlockString->previous != NULL)
		StrFreBlockString = StrFreBlockString->previous;
	do{
		UINT32 F_x = 0;
		do
		{
			for( i = 0; i < BLOCK_SIZE; i++)
				for( j = 0; j < BLOCK_SIZE; j++)
				{
					imgout_integercase[X + i][Y + j] = StrFreBlockString->FreqBlkString[F_x + i][j];
					imgout_floatingcase[X + i][Y + j] =StrFreBlockString->FloatingFreqBlk[F_x + i][j];
				}
				
			Y += BLOCK_SIZE;

			if( Y >= PtrCoding->ImageWidth)
			{
				Y = 0;
				X += BLOCK_SIZE;
			}
			F_x += BLOCK_SIZE;
		}while (F_x <  StrFreBlockString->Blocks * BLOCK_SIZE);				
			
		StrFreBlockString = StrFreBlockString->next;
	}while(StrFreBlockString != NULL);
	
	if(PtrCoding->PtrHeader->Header.Part4.DWTType == INTEGER_WAVELET)
		DecodingOutputInteger(PtrCoding, imgout_integercase);
	else
		DecodingOutputFloating(PtrCoding, imgout_floatingcase);
	
	fclose(PtrCoding->Bits->F_Bits);
	free(imgout_integercase);
	return; 
}