binimp.c

图像处理的压缩算法

	return nSize;
}

/**
		read data from file by its logical row and col position
		then, put into the corresponding cell in the worksheet
*/
static int setCellFromFile(Worksheet& wks, POSITION_IDX& wksPos, file& fDataFile, POSITION_IDX& filePos, BINIMP *pbi)
{
	if( !fDataFile.IsOpen() || !wks.IsValid() )
		return BIN_INVALID_ARGUMENT;
	
	int nRetCode = BIN_SUCCEED;
	UINT nElementSize = 0;
	byte byDataType = 0;
	BOOL bLittleEndian = !(pbi->iBigEndian);
	
	nElementSize = getRowElementInfo(pbi, filePos.nCol, byDataType);
	
	if( IS_TYPE_REAL(byDataType) )	//real number
	{
		double dData = 0;
		float  fData = 0;
		if( sizeof(float) == nElementSize )
		{
			fDataFile.ReadFloat(&fData, nElementSize, 1, bLittleEndian);
			wks.SetCell(wksPos.nRow, wksPos.nCol, fData);
		}
		else if( sizeof(double) == nElementSize )
		{
			fDataFile.ReadFloat(&dData, nElementSize, 1, bLittleEndian);
			wks.SetCell(wksPos.nRow, wksPos.nCol, dData);
		}
		else
			nRetCode = BIN_INVALID_SIZE;
	}
	else if( IS_TYPE_INT(byDataType) || IS_TYPE_UINT(byDataType) ) //int or UINT
	{
		int nData = 0;
		fDataFile.ReadInt(&nData, nElementSize, 1, bLittleEndian);
		
		wks.SetCell(wksPos.nRow, wksPos.nCol, nData);
	}
	else if( IS_TYPE_STRING(byDataType) ) //string
	{
		string strResult;
		char *pRet = strResult.GetBuffer(nElementSize + 1); 
		
		int nRead = fDataFile.Read(pRet, nElementSize);
		*(pRet+nRead) = '\0';
		strResult.ReleaseBuffer();
		
		/// JCG 05/29/03 v7.0594 FIX_BUG_29_ORIGIN_SUSPENDS
		// need check the read result...
		if(0 != nRead)
			wks.SetCell(wksPos.nRow, wksPos.nCol, strResult);
		else
			nRetCode = BIN_INVALID_SIZE;
		/// end FIX_BUG_29_ORIGIN_SUSPENDS

	}
	else
		nRetCode = BIN_INVALID_TYPE;	
	
	
	//save the current reading logical row and col number in data file
	s_Pos.nRow = filePos.nRow;
	s_Pos.nCol = filePos.nCol;
	
	return nRetCode;	
}
/// EJP 06-23-2003 IMPROVE_IMPORT_SPEED
#endif // !IMPROVE_IMPORT_SPEED
/// end IMPROVE_IMPORT_SPEED

bool ReadBinaryHeaderParam(string &strDest, file &fil, int nType, int nOffset, int nSize, bool bLittleEndian)
{
	if( !fil.IsOpen() )
		return false;
	if( fil.Seek(nOffset, file::begin) != nOffset )
		return false;

	string strFormat;
	
	switch( nType )
	{
	case BIP_TYPE_REAL:
		strFormat = "%g";
		switch( nSize )
		{
		case 4:
			float f;
			fil.ReadFloat(&f, 4, 1, bLittleEndian);
			strDest.Format(strFormat, f);
			break;
		case 8:
			double d;
			fil.ReadFloat(&d, 8, 1, bLittleEndian);
			strDest.Format(strFormat, d);
			break;
		default:
			return false;
		}
		break;

	case BIP_TYPE_INT:
	case BIP_TYPE_UINT:
		strFormat = (BIP_TYPE_INT == nType ? "%d" : "%u");
		switch( nSize )
		{
		case 1:
			char n8;
			fil.Read(&n8, 1);
			strDest.Format(strFormat, n8);
			break;
		case 2:
			short n16;
			fil.ReadInt(&n16, 2, 1, bLittleEndian);
			strDest.Format(strFormat, n16);
			break;
		case 4:
			int n32;
			fil.ReadInt(&n32, 4, 1, bLittleEndian);
			strDest.Format(strFormat, n32);
			break;
		default:
			return false;
		}
		break;

	case BIP_TYPE_STRING:
		LPSTR lpstr = strDest.GetBufferSetLength(nSize + 1); // +1 for null terminator
		if( lpstr )
		{
			fil.Read(lpstr, nSize);
			lpstr[nSize] = 0; // be sure string is terminated
			strDest.ReleaseBuffer();
		}
		break;
		
	default:
		return false;
	}
	
	return true;
}

/// EJP 06-23-2003 IMPROVE_IMPORT_SPEED
#ifdef IMPROVE_IMPORT_SPEED

static int import_binary_file(Worksheet& wks, LPCSTR lpcstrFile, BINIMP& binimp)
{
	init_globals(binimp);
	init_wks_starting_col_and_row(wks, binimp);
	
	if( binimp.iPartial )
	{
		if( (binimp.iPartialC1 > binimp.iPartialC2 && binimp.iPartialC2 != -1) ||
			(binimp.iPartialC1 >= get_column_count(binimp)) ||
			(binimp.iPartialR1 > binimp.iPartialR2 && binimp.iPartialR2 != -1) )
		{
			return 1; // invalid range specified
		}
	}

	file fil;
	if( fil.Open(lpcstrFile, file::modeRead | file::typeBinary) )
	{
		// Get the number of bytes in each row of data.
		s_lRowSizeInBytes = get_binimp_row_size(binimp);
		if( s_lRowSizeInBytes )
		{
			// Allocate a buffer to hold a row of data
			s_pbyRowBuffer = (BYTE*)malloc(s_lRowSizeInBytes);
			if( s_pbyRowBuffer )
			{
				// Skip header bytes.
				fil.Seek(binimp.iHeaderBytes, file::begin);

				int iDataRow = 0; // 0=first row of data

				// If partial import then skip unwanted rows.
				if( binimp.iPartial && binimp.iPartialR1 > 0 )
				{
					fil.Seek(binimp.iPartialR1 * s_lRowSizeInBytes, file::current);
					iDataRow = binimp.iPartialR1;
				}
				
				// Set starting wks row.
				int iWksRow = s_nStartRow;
				
				int iSkipRows = 0; /// EJP 07-23-2003 v7.0631 QA70-4575 ADD_SKIPROWS_TO_BINIMP
				int iReadRows = binimp.iReadRows; /// EJP 09-12-2003 v7.5693 QA70-5073 ADD_READROWS_TO_BINIMP

				// Read data rows.
				while( fil.Read(s_pbyRowBuffer, s_lRowSizeInBytes) == s_lRowSizeInBytes )
				{
					/// EJP 07-23-2003 v7.0631 QA70-4575 ADD_SKIPROWS_TO_BINIMP
					if( iSkipRows )
					{
						iSkipRows--;
						/// EJP 09-12-2003 v7.5693 ADD_READROWS_TO_BINIMP
						if( 0 == iSkipRows )
							iReadRows = binimp.iReadRows;
						/// end ADD_READROWS_TO_BINIMP
					}
					else // iSkipRows == 0
					{
					/// end ADD_SKIPROWS_TO_BINIMP
						// Put row into worksheet.
						row_buffer_to_wks(wks, iWksRow, s_pbyRowBuffer, binimp);
						iWksRow++; // Next worksheet row.
					/// EJP 07-23-2003 v7.0631 QA70-4575 ADD_SKIPROWS_TO_BINIMP

						/// EJP 09-12-2003 v7.5693 QA70-5073 ADD_READROWS_TO_BINIMP
						///iSkipRows = binimp.iSkipRows; // reset iSkipRows
						if( binimp.iSkipRows )
						{
							iReadRows--;
							if( 0 == iReadRows )
								iSkipRows = binimp.iSkipRows; // reset iSkipRows
						}
						/// end ADD_READROWS_TO_BINIMP
					}
					/// end ADD_SKIPROWS_TO_BINIMP
					
					// If partial import and we just did the last row...
					if( binimp.iPartial && iDataRow == binimp.iPartialR2 )
						break; // Partial import is done.
					
					iDataRow++; // Next row of data
				}
		
				free(s_pbyRowBuffer);
			}
		}
		fil.Close();
	}
	return 0;
}

static int get_column_count(BINIMP &binimp)
{
	int iCount = 0;
	for( int i = 0; i < binimp.vParamCount.GetSize(); i++ )
		iCount += binimp.vParamCount[i];
	return iCount;
}

static LONG get_binimp_row_size(BINIMP& binimp)
{
	LONG lSize = 0;
	for( int i = 0; i < binimp.vParamType.GetSize(); i++ )
		lSize += (binimp.vParamSize[i] * binimp.vParamCount[i]);
	return lSize;
}

static bool get_param_info_for_col(int& iParamVecElement, int& iParamCount, BINIMP& binimp, int iCol)
{
	int iCurrCol = 0;
	for( int iElement = 0; iElement < binimp.vParamCount.GetSize(); iElement++ )
	{
		for( int iCount = 0; iCount < binimp.vParamCount[iElement]; iCount++ )
		{
			if( iCurrCol == iCol )
			{
				iParamVecElement = iElement;
				iParamCount = iCount;
				return true;
			}
			iCurrCol++;
		}
	}
	return false;
}

static int get_num_bytes_before_col(BINIMP &binimp, int iCol)
{
	int iBytesBeforeCol = 0, iCurrCol = 0;

	for( int iElement = 0; iElement < binimp.vParamCount.GetSize(); iElement++ )
	{
		for( int iCount = 0; iCount < binimp.vParamCount[iElement]; iCount++ )
		{
			if( iCurrCol == iCol )
				return iBytesBeforeCol;
			iBytesBeforeCol += binimp.vParamSize[iElement];
			iCurrCol++;
		}
	}
	return 0;
}

static void init_globals(BINIMP &binimp)
{
	s_lRowSizeInBytes = 0;
	s_pbyRowBuffer = NULL;
	
	if( binimp.iPartial )
	{
		get_param_info_for_col(s_iFirstParamVecElement, s_iFirstParamCount, binimp, binimp.iPartialC1);
		if( binimp.iPartialC2 >= 0 )
			get_param_info_for_col(s_iLastParamVecElement, s_iLastParamCount, binimp, binimp.iPartialC2);
		else
		{
			s_iLastParamVecElement = -1;
			s_iLastParamCount = -1;
		}
		
		s_lBytesBeforePartial = get_num_bytes_before_col(binimp, binimp.iPartialC1);
	}
	else
	{
		s_iFirstParamVecElement = 0;
		s_iFirstParamCount = 0;
		
		s_iLastParamVecElement = -1;
		s_iLastParamCount = -1;
		
		s_lBytesBeforePartial = 0;
	}
}

static void init_wks_starting_col_and_row(Worksheet& wks, BINIMP& binimp)
{
	switch( binimp.iMode )
	{
	case ASCIMP_MODE_REPLACE_DATA:
		s_nStartCol = 0;
		s_nStartRow = 0;
		break;
	case ASCIMP_MODE_APPEND_COLS:
		s_nStartCol = FindEmptyColumn(wks);
		s_nStartRow = 0;
		break;
	case ASCIMP_MODE_APPEND_ROWS:
		s_nStartCol = 0;
		Dataset dd(wks, 0);
		if( dd.IsValid() )
			s_nStartRow = dd.GetSize();
		else
			s_nStartRow = 0;
		break;
	}
}

static int row_buffer_to_wks(Worksheet& wks, int iWksRow, BYTE *pbyRowBuffer, BINIMP& binimp)
{
	int iParamCount = 0;

	if( binimp.iPartial )
	{
		// Skip bytes for unwanted columns
		pbyRowBuffer += s_lBytesBeforePartial;
		iParamCount = s_iFirstParamCount;
	}

	int iWksCol = s_nStartCol;
	
	for( int iParamVecElement = s_iFirstParamVecElement; iParamVecElement < binimp.vParamType.GetSize(); iParamVecElement++ )
	{
		while( iParamCount < binimp.vParamCount[iParamVecElement] )
		{
			// Set worksheet cell
			set_worksheet_cell(wks, iWksRow, iWksCol, pbyRowBuffer, binimp.vParamType[iParamVecElement], binimp.vParamSize[iParamVecElement], binimp.iBigEndian);

			// Advance pointer to data for next paramter.
			pbyRowBuffer += binimp.vParamSize[iParamVecElement];
			
			// If we have set the cell of the last column.
			if( iParamVecElement == s_iLastParamVecElement && iParamCount == s_iLastParamCount )
				return 0; // we are done
			
			// Next parameter in vector element.
			iParamCount++;

			// Next wks column.
			iWksCol++;
		}
		iParamCount = 0;
	}
	
	return 0;
}

static int set_worksheet_cell(Worksheet &wks, int iRow, int iCol, BYTE *pbyData, int iDataType, int iDataSize, bool bBigEndian)
{
	if( IS_TYPE_REAL(iDataType) )
	{
		if( bBigEndian )
			reverse_bytes(pbyData, iDataSize);
		
		if( sizeof(float) == iDataSize )
		{
			float fData = *((float*)pbyData);
			wks.SetCell(iRow, iCol, fData);
		}
		else if( sizeof(double) == iDataSize )
		{
			double dData = *((double*)pbyData);
			wks.SetCell(iRow, iCol, dData);
		}
	}
	else if( IS_TYPE_INT(iDataType) )
	{
		if( bBigEndian )
			reverse_bytes(pbyData, iDataSize);

		int iData = 0;
		switch( iDataSize )
		{
		case sizeof(char):
			iData = *((char*)pbyData);
			break;
		case sizeof(short):
			iData = *((short*)pbyData);
			break;
		case sizeof(long):
			iData = *((long*)pbyData);
			break;
		}
		
		wks.SetCell(iRow, iCol, iData);
	}
	else if( IS_TYPE_UINT(iDataType) )
	{
		if( bBigEndian )
			reverse_bytes(pbyData, iDataSize);

		DWORD dwData = 0;
		switch( iDataSize )
		{
		case sizeof(char):
			dwData = *((BYTE*)pbyData);
			break;
		case sizeof(short):
			dwData = *((WORD*)pbyData);
			break;
		case sizeof(long):
			dwData = *((DWORD*)pbyData);
			break;
		}
		
		wks.SetCell(iRow, iCol, dwData);
	}
	else if( IS_TYPE_STRING(iDataType) )
	{
		string strData;
		LPSTR lpstr = strData.GetBuffer(iDataSize + 1);
		if( lpstr )
		{
			memcpy(lpstr, pbyData, iDataSize);
			*(lpstr + iDataSize) = 0; // be sure it is null terminated
			strData.ReleaseBuffer();
			wks.SetCell(iRow, iCol, strData);
		}
	}
	return 0;
}

static void reverse_bytes(BYTE *pbyData, int iSize)
{
	BYTE by;

	for( int i = 0; i < iSize/2; i++ )
	{
		by = *(pbyData + i);
		*(pbyData + i) = *(pbyData + iSize - i - 1);
		*(pbyData + iSize - i - 1) = by;
	}
}
#endif // IMPROVE_IMPORT_SPEED
/// end IMPROVE_IMPORT_SPEED