Working with the RAW File Filter

//This example saves a LEAD BITMAPHANDLE 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 pBitmap. 
//If pBitmap 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, pBITMAPHANDLE pBitmap, L_UINT32 uOffset) 
{ 
   SAVEFILEOPTION SaveFileOption; 
   L_INT nRet; 
    
   memset(&SaveFileOption, 0, sizeof(SAVEFILEOPTION)); 
   SaveFileOption.uStructSize = sizeof(SAVEFILEOPTION); 
   SaveFileOption.Flags = ESO_PAD4 | ESO_REVERSEBITS; 
    
   if (uOffset == 0) 
   { 
      nRet = L_SaveFile(pszFileName, pBitmap, FILE_RAW, 0, 0, SAVEFILE_OPTIMIZEDPALETTE, NULL, NULL, &SaveFileOption); 
   } 
   else 
   { 
      HFILE hFile; 
      L_UINT32 SizeWritten; 
       
#ifdef UNICODE 
      hFile = _wcreat(pszFileName, 0); 
#else 
      hFile = _lcreat(pszFileName, 0); 
#endif 
      nRet  = L_SaveFileOffset(hFile, uOffset, &SizeWritten, pBitmap, FILE_RAW, 0, 0, SAVEFILE_OPTIMIZEDPALETTE, NULL, NULL, &SaveFileOption); 
      _lclose(hFile); 
   } 
   return nRet; 
} 
//This example loads RAW data into a LEAD BITMAPHANDLE. 
//Raw data parameters are set in the MyLoadInfoCallBack, which gets called 
//when the file format is FILE_RAW, or any unrecognized file format. 
//The MyLoadInfoCallBack obtains information through a user-defined structure. 
//In this example it is RAWLOADDATA 
// 
//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; 
L_INT L_EXPORT EXT_CALLBACK MyLoadInfoCallBack( L_INT fd, pLOADINFO pInfo, L_VOID  *pUserData ) 
{ 
   LPRAWLOADDATA pRawData = (LPRAWLOADDATA)pUserData; 
    
   UNREFERENCED_PARAMETER(fd); 
    
   pInfo->Format        = FILE_RAW; 
   pInfo->Width         = pRawData->nWidth; 
   pInfo->Height        = pRawData->nHeight; 
   pInfo->BitsPerPixel  = pRawData->nBitsPerPixel; 
   pInfo->XResolution   = 150; 
   pInfo->YResolution   = 150; 
   pInfo->Offset        = pRawData->nOffset; 
    
   pInfo->Flags = 0; 
    
   if (pRawData->bPadding) 
      pInfo->Flags |= LOADINFO_PAD4; 
    
   if (pRawData->nOrder == ORDER_RGB) 
      pInfo->Flags |= LOADINFO_ORDERRGB; 
   if (pRawData->bReverseBits) 
      pInfo->Flags |= LOADINFO_LSB; 
   switch(pRawData->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; 
} 
L_INT LoadRawData(L_TCHAR *pszFile, pBITMAPHANDLE pBitmap, LPRAWLOADDATA pRawLoadData) 
{ 
   LOADINFOCALLBACK OldCallback; 
   L_INT   nRet; 
   FILEINFO FileInfo; 
    
   memset(&FileInfo, 0, sizeof(FILEINFO)); 
   FileInfo.Format = FILE_RAW; 
   FileInfo.Flags = FILEINFO_FORMATVALID; 
    
   OldCallback = L_SetLoadInfoCallback(MyLoadInfoCallBack, (L_VOID *)pRawLoadData); 
    
   nRet = L_LoadFile( 
   pszFile, 
   pBitmap, sizeof(BITMAPHANDLE), 
   0, 
   ORDER_BGR, 
   LOADFILE_ALLOCATE | LOADFILE_STORE, 
   NULL, 
   NULL, 
   NULL, 
   &FileInfo); 
    
   L_SetLoadInfoCallback(OldCallback, NULL); 
   return nRet; 
}