Working with the RAW File Filter

typedef struct tagRAWLOADDATA 
{ 
   L_INT nWidth; //width of image 
   L_INT nHeight; //height of image 
   L_INT nBitsPerPixel; //bits per pixel of image--if palettized, a gray palette is generated 
   L_INT nViewPerspective; //view perspective of raw data (TOP_LEFT, BOTTOM_LEFT, etc) 
   L_INT nOrder; //ORDER_RGB or ORDER_BGR 
   L_INT nOffset; //offset into file where raw data begins 
   L_INT bPadding; //TRUE if each line of data is padded to four bytes 
   L_INT bReverseBits; //TRUE if the bits of each byte are reversed 
} RAWLOADDATA, *LPRAWLOADDATA; 
 
class LUserFile : public LFile 
{ 
protected: 
   RAWLOADDATA m_RawData; 
public: 
   void SetRawLoadData(LPRAWLOADDATA pRawData); 
   LUserFile(); 
   ~LUserFile(); 
   L_INT LoadInfoCallBack(L_INT fd,pLOADINFO pInfo); 
}; 
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
LUserFile::LUserFile() 
{ 
   ZeroMemory( &m_RawData, sizeof(RAWLOADDATA)) ; 
} 
 
LUserFile::~LUserFile() 
{ 
} 
 
void LUserFile::SetRawLoadData(LPRAWLOADDATA pRawData) 
{ 
   m_RawData.nWidth = pRawData->nWidth; 
   m_RawData.nHeight = pRawData->nHeight; 
   m_RawData.nBitsPerPixel = pRawData->nBitsPerPixel; 
   m_RawData.nViewPerspective = pRawData->nViewPerspective; 
   m_RawData.nOrder = pRawData->nOrder; 
   m_RawData.nOffset = pRawData->nOffset; 
   m_RawData.bPadding = pRawData->bPadding; 
   m_RawData.bReverseBits = pRawData->bReverseBits; 
} 
 
L_INT LUserFile::LoadInfoCallBack(L_INT fd,pLOADINFO pInfo) 
{ 
   UNREFERENCED_PARAMETER(fd); 
   pInfo->Format = FILE_RAW; 
   pInfo->Width = m_RawData.nWidth; 
   pInfo->Height = m_RawData.nHeight; 
   pInfo->BitsPerPixel = m_RawData.nBitsPerPixel; 
   pInfo->XResolution = 150; 
   pInfo->YResolution = 150; 
   pInfo->Offset = m_RawData.nOffset; 
   pInfo->Flags = 0; 
   if (m_RawData.bPadding) 
      pInfo->Flags |= LOADINFO_PAD4; 
   if (m_RawData.nOrder == ORDER_RGB) 
      pInfo->Flags |= LOADINFO_ORDERRGB; 
   if (m_RawData.bReverseBits) 
      pInfo->Flags |= LOADINFO_LSB; 
   switch(m_RawData.nViewPerspective) 
   { 
      case TOP_LEFT: 
      pInfo->Flags |= LOADINFO_TOPLEFT; 
      break; 
      case BOTTOM_LEFT: 
      pInfo->Flags |= LOADINFO_REVERSE; 
      break; 
      case TOP_RIGHT://BOTTOM_LEFT180 
      pInfo->Flags |= LOADINFO_BOTTOMLEFT180; 
      break; 
      case BOTTOM_RIGHT: //TOP_LEFT180 
      pInfo->Flags |= LOADINFO_TOPLEFT180; 
      break; 
      case RIGHT_TOP: //TOP_LEFT90 
      pInfo->Flags |= LOADINFO_TOPLEFT90; 
      break; 
      case LEFT_BOTTOM: //TOP_LEFT270 
      pInfo->Flags |= LOADINFO_TOPLEFT270; 
      break; 
      case LEFT_TOP: //BOTTOM_LEFT90 
      pInfo->Flags |= LOADINFO_BOTTOMLEFT90; 
      break; 
      case RIGHT_BOTTOM: //BOTTOM_LEFT270 
      pInfo->Flags |= LOADINFO_BOTTOMLEFT270; 
      break; 
   } 
   //if image is palettized create a grayscale palette 
   if ( pInfo->BitsPerPixel <= 8) 
   { 
      L_INT nColors, i; 
      nColors = 1 << pInfo->BitsPerPixel; 
      pInfo->Flags |= LOADINFO_PALETTE; 
      for (i=0; i<nColors; i++) 
      { 
         pInfo->rgbQuad[i].rgbBlue = (i * 256) / nColors; 
         pInfo->rgbQuad[i].rgbGreen = (i * 256) / nColors; 
         pInfo->rgbQuad[i].rgbRed = (i * 256) / nColors; 
         pInfo->rgbQuad[i].rgbReserved = 0; 
      } 
   } 
   return SUCCESS; 
} 
//This example loads RAW data into a LEAD LBitmapBase object. 
//Raw data parameters are set in the overridden LUserFile::LoadInfoCallBack function, 
//which gets called when the file format is FILE_RAW, or any unrecognized file format. 
//The LUserFile::LoadInfoCallBack obtains information through a user-defined structure. 
//In this example it is RAWLOADDATA 
L_INT LoadRawData(L_TCHAR *pszFile, LBitmapBase* pLEADBitmap, LPRAWLOADDATA pRawData) 
{ 
   L_INT nRet = FALSE ; 
   FILEINFO fileInfo; 
   LUserFile file; 
   memset(&fileInfo, 0, sizeof(fileInfo)); 
   fileInfo.uStructSize = sizeof(fileInfo); 
   fileInfo.Format = FILE_RAW; 
   fileInfo.Flags = FILEINFO_FORMATVALID; 
    
   file.SetBitmap(pLEADBitmap); 
   file.SetFileName(pszFile); 
   file.SetRawLoadData(pRawData); 
   file.EnableLoadInfoCallBack(TRUE); 
   nRet = file.LoadFile( 0, ORDER_BGR, LOADFILE_ALLOCATE | LOADFILE_STORE, NULL, &fileInfo); 
   file.EnableLoadInfoCallBack(FALSE); 
    
   return nRet; 
} 
 
//This example saves a LEAD LBitmapBase object as RAW data starting at offset uOffset. 
//The data is padded so that each line of bytes is evenly divided by 4. 
//The bits in each byte are reversed before saving. 
//The bits per pixel of the raw data is the same as the bits per pixel of pLEADBitmap. 
//If pLEADBitmap is a palettized image, the palette is not saved--only the raw data. 
//The OPTIMIZED_PALETTE flag is used to disable dithering on images with 8 bits or pixel or less. 
//Note that when saving a file as RAW data, the view perspective is ignored. 
L_INT SaveRawData(L_TCHAR *pszFileName, LBitmapBase* pLEADBitmap, 
L_UINT32 uOffset, LUserFile& file) 
{ 
   SAVEFILEOPTION SaveFileOption; 
   L_INT nRet; 
   memset(&SaveFileOption, 0, sizeof(SaveFileOption)); 
   SaveFileOption.uStructSize = sizeof(SaveFileOption); 
   SaveFileOption.Flags = ESO_PAD4 | ESO_REVERSEBITS; 
   file.SetBitmap(pLEADBitmap); 
   file.SetFileName(pszFileName); 
   file.EnableCallBack(FALSE); 
    
   if (uOffset == 0) 
   { 
      nRet = file.SaveFile( FILE_RAW, 0, 0, SAVEFILE_OPTIMIZEDPALETTE, &SaveFileOption); 
   } 
   else 
   { 
      HFILE hFile; 
      L_INT32 SizeWritten; 
       
#ifdef UNICODE 
      hFile = _wcreat(pszFileName, 0); 
#else 
      hFile = _lcreat(pszFileName, 0); 
#endif 
      nRet = file.SaveOffset(hFile, uOffset, &SizeWritten, FILE_RAW, 0, 0, SAVEFILE_OPTIMIZEDPALETTE, &SaveFileOption); 
      _lclose(hFile); 
   } 
   return nRet; 
} 
 
void CAnasDemoView::OnSettxtoptionsTxt() 
{ 
   LBitmapBase LEADBitmap; 
   LUserFile LeadFile; 
   //LoadRawData(TEXT("C:\\Raw Data.raw"), &LEADBitmap); 
   JBIG2OptionsExample(); 
   LoadTXTFile( TEXT("C:\\txt.txt"), &LeadFile, 50, 
   50, 50, 50); 
}