bpe_encoder.c

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

			{
				fread(temp_16, StrPtr->ImageWidth, sizeof(short),infile);	
				for(i = 0; i <  StrPtr->ImageWidth; i++)
					image[r][i] = temp_16[i];
			}			
			free(temp_16);
		}

		if ( StrPtr->PixelByteOrder == 1) // LSB first, exchange the order of bytes of a pixel. 
		{
			for(r = 0; r <  StrPtr->ImageRows; r++)
			{
				for (i = 0; i <  StrPtr->ImageWidth; i ++)
					image[r][i] = (image[r][i]>>8) + (image[r][i]<<8) ;
			}
		}	
	}
	else
		ErrorMsg(BPE_FILE_ERROR);

	fclose(infile);
	return BPE_OK;
}


void SegmentBufferFlushEncoder(StructCodingPara *StrCoding) // flush codes and reset
{	
	if(StrCoding->Bits->CodeWordAlighmentBits != 0)
	{
		int shift = 0;
		shift = StrCoding->Bits->CodeWord_Length - StrCoding->Bits->CodeWordAlighmentBits;
		BitsOutput(StrCoding, 0, shift);
	}

	if((StrCoding->PtrHeader->Header.Part2.SegByteLimit_27Bits != 0)
		&& (StrCoding->SegmentFull == FALSE) 
		&& StrCoding->PtrHeader->Header.Part2.UseFill == TRUE)
	{
		while(StrCoding->SegmentFull == FALSE)
		{
			BitsOutput(StrCoding, 0, 8);
		}
	}
	
	StrCoding->Bits->SegBitCounter = 0;
	StrCoding->Bits->ByteBuffer_4Bytes = 0;
	StrCoding->Bits->CodeWordAlighmentBits = 0;
	return;
}
// if it is 1, means LSB first, 0 means MSB first
// extern char InputFile[BUFFER_LENGTH],  CodingOutputFile[BUFFER_LENGTH];


void BuildBlockString(int **TransformedImage,
					  int ImageRows, 
					  int ImageWidth,
					  long **BlockString)
{
	int i = 0;
	int j = 0; 
	int k = 0; 
	int p = 0;
	int BlockRow = 0;
	int BlockCol = 0;
	int counter = 0;
	UINT32 TotalBlocks = 0;
	
	BlockRow = ImageRows / BLOCK_SIZE;
	BlockCol = ImageWidth / BLOCK_SIZE;

///////////////////////////////////////////////////////////////////////////////////////
/* Allocate memory for coding of the input image */
	TotalBlocks = BlockRow * BlockCol;
	for(i = 0; i < BlockRow; i ++)
		for ( j= 0; j < BlockCol; j++)
		{
			for ( k= 0; k < BLOCK_SIZE; k ++)
			{
				for (p = 0; p < BLOCK_SIZE; p ++)
					BlockString[counter][p] = 
					TransformedImage[i*BLOCK_SIZE + k][j*BLOCK_SIZE + p];
				counter ++;
			}
		}

	return;
}


void EncoderEngine(StructCodingPara * PtrCoding)
{
	int  **OriginalImage = NULL;
	int **TransformedImage = NULL;
	long **BlockString = NULL;
	UINT32 TotalBlocks = 0;
	UINT32 i = 0;
	UINT32 j = 0;
	UCHAR8 TempPaddedRows = 0;

	BitPlaneBits *BlockCodingInfo;
	// check to see if the file size are correct or not. 
	if (ImageSize(PtrCoding) == BPE_FILE_ERROR)
		ErrorMsg(BPE_FILE_ERROR);

	// determine the last rows we need to replicate.
	if(PtrCoding->ImageRows % BLOCK_SIZE != 0)
		PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits = BLOCK_SIZE - (PtrCoding->ImageRows % BLOCK_SIZE);

	PtrCoding->PtrHeader->Header.Part4.ImageWidth_20Bits = PtrCoding->ImageWidth;
	
	if(PtrCoding->ImageWidth % BLOCK_SIZE != 0)
		PtrCoding->PadCols_3Bits = BLOCK_SIZE - (PtrCoding->ImageWidth % BLOCK_SIZE );

	// assign space for the original image

	OriginalImage = (int **)calloc(PtrCoding->ImageRows +	PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits, sizeof(int *));  
	
	for(i = 0; i < PtrCoding->ImageRows + PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits; i++)
		OriginalImage[i] = (int *)calloc(PtrCoding->ImageWidth + PtrCoding->PadCols_3Bits,sizeof(int));
		// assign memeory for the transformed image	
		// The OriginalImage matrix is to store the original image and 
	//TransformedImage stores the transformed values. 

	// read into the original image. 
	if ((i = ImageRead(PtrCoding, OriginalImage)) != BPE_OK)
		ErrorMsg(BPE_FILE_ERROR);

	// replicate the last rows and cols if the number of rows
	// and columns are not integal of 8. 

	for(i = 0; i < PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits ; i++)
	{
		for(j = 0; j < PtrCoding->ImageWidth + PtrCoding->PadCols_3Bits; j++)
			OriginalImage[i + PtrCoding->ImageRows][j] = OriginalImage[PtrCoding->ImageRows - 1][j];
	}

	for(i = 0; i < PtrCoding->PadCols_3Bits ; i++)
	{
		for(j = 0; j < PtrCoding->ImageRows +PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits ; j++)
			OriginalImage[j][i + PtrCoding->ImageRows] = OriginalImage[j][PtrCoding->ImageRows - 1];
	}

	TransformedImage = (int **)calloc(PtrCoding->ImageRows +	PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits,sizeof(int *));  
	for(i = 0; i < PtrCoding->ImageRows+ PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits; i++)
   		TransformedImage[i] = (int *)calloc(PtrCoding->ImageWidth + PtrCoding->PadCols_3Bits, sizeof(int));	
	
	/* Read the input image */

///////////////////////////////////////////////////////////////////////////////////////
/* Allocate memory for coding of the input image */
	TotalBlocks =  (PtrCoding->ImageRows +	PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits) / BLOCK_SIZE *
		(PtrCoding->ImageWidth + PtrCoding->PadCols_3Bits )/ BLOCK_SIZE;	

	BlockString = (long **)calloc(TotalBlocks * BLOCK_SIZE,sizeof(long *));
	for(i = 0; i < TotalBlocks * BLOCK_SIZE; i++)
		BlockString[i] = (long *)calloc(BLOCK_SIZE,sizeof(long));

////////////////////////////////////////////////////////////////////////////////
	// Output the coding information into the the output. 
	if((PtrCoding->Bits->F_Bits = fopen(PtrCoding->CodingOutputFile, "wb")) == NULL)  // default name
		ErrorMsg(BPE_FILE_ERROR);
	
	/****************************     1. Transform       *************************/
	DWT_(PtrCoding, OriginalImage, TransformedImage);
	
		BuildBlockString(TransformedImage, PtrCoding->ImageRows + PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits,
		PtrCoding->ImageWidth + PtrCoding->PadCols_3Bits, BlockString);
	for(i = 0; i < PtrCoding->ImageRows; i++)
		free(TransformedImage[i]);
	free(TransformedImage);

	TempPaddedRows = PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits;
	PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits = 0;
	for(;PtrCoding->BlockCounter < TotalBlocks; )
	{	
		//////////////////////////////////////////////////////////////////////
		// update the information of header. 

		if (PtrCoding->BlockCounter + PtrCoding->PtrHeader->Header.Part3.S_20Bits == TotalBlocks)
		{
			PtrCoding->PtrHeader->Header.Part1.EngImgFlg = TRUE;
			PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits = TempPaddedRows;
		}
		else if (PtrCoding->BlockCounter + PtrCoding->PtrHeader->Header.Part3.S_20Bits > TotalBlocks)
		{			
			// This part may handle the situation where the number of blocks in the last packet is not exactly the one specified. 
			// For example: if totalblocks = 128, PtrCoding->PtrHeader->Header.Part3.S_20Bits = 10, so in the last packet, 
			// only 8 blocks left, so we need to specify exactly 8 blocks are left in the last packet and part3 may need to be enabled
			PtrCoding->PtrHeader->Header.Part1.EngImgFlg = TRUE;
			PtrCoding->PtrHeader->Header.Part1.PadRows_3Bits = TempPaddedRows;
			PtrCoding->PtrHeader->Header.Part1.Part3Flag = TRUE; 
			PtrCoding->PtrHeader->Header.Part3.S_20Bits = TotalBlocks - PtrCoding->BlockCounter;
			
			PtrCoding->PtrHeader->Header.Part1.Part2Flag = TRUE; 
			PtrCoding->PtrHeader->Header.Part2.SegByteLimit_27Bits = PtrCoding->BitsPerPixel * PtrCoding->PtrHeader->Header.Part3.S_20Bits * 64/8;


		}

///////////////////////////////////////////////////////////////////////////
		BlockCodingInfo = (BitPlaneBits *)calloc(PtrCoding->PtrHeader->Header.Part3.S_20Bits,	sizeof(BitPlaneBits));
//********************************* 2. DC and AC encoding   *************************/	
		DCEncoding(PtrCoding, BlockString, BlockCodingInfo);

		if((PtrCoding->SegmentFull == FALSE) &&  // if (1) the segment is not full and (2) the DCstop is not true, continue AC coding. 
			// Otherwise jump to the codeline that update the header information, block counters, etc. 
			 ( !((PtrCoding->PtrHeader->Header.Part2.DCstop == TRUE) && (PtrCoding->PtrHeader->Header.Part1.Part2Flag == TRUE))))		
		{
			ACBpeEncoding(PtrCoding, BlockCodingInfo);	
			free(BlockCodingInfo) ;
	        // Update the bitstream struct. 	
		}

		if(PtrCoding->PtrHeader->Header.Part1.EngImgFlg == TRUE)
			break;	

		PtrCoding->BlockCounter += PtrCoding->PtrHeader->Header.Part3.S_20Bits;
		HeaderUpdate(PtrCoding->PtrHeader);	

		SegmentBufferFlushEncoder(PtrCoding);
		PtrCoding->SegmentFull = FALSE;
		
	}
	// ***************************  5. header information  *****************************//
    SegmentBufferFlushEncoder(PtrCoding);	
	for(i = 0; i < TotalBlocks * BLOCK_SIZE; i++)
		free(BlockString[i]);
	free(BlockString);
	return ; 
}