LFile::StartFeedLoad

typedef struct tagDATA 
{ 
   L_INT32 dwSize;              // Size of the buffer.  
   L_INT32 dwUsed;              // Number of bytes used.  
   L_CHAR  *pData;        // Pointer to the buffer.  
   L_CHAR  *pCurData;     // Current pointer location. 
} DATA,  * LPDATA; 
 
// define user LFile class to override CallBacks 
 
class LUserFileSFL : public LFile 
{ 
private: 
   DATA Data; 
 
public: 
   HDC      m_hDC ; 
public: 
   LUserFileSFL() ; 
   virtual ~LUserFileSFL() ; 
   virtual L_INT FeedLoadCallBack(pFILEINFO pFileInfo, 
                                  LBitmapBase * pLBitmap, 
                                  LBuffer * pLBuffer,  
                                  L_UINT uFlags, 
                                  L_INT nRow, 
                                  L_INT nLines); 
 
   virtual  L_INT    LoadInfoCallBack(L_INT fd,pLOADINFO pInfo); 
   virtual  L_INT    RedirectOpenCallBack( 
                                       L_TCHAR  *pFile, 
                                       L_INT nMode, 
                                       L_INT nShare); 
   virtual  L_INT    RedirectCloseCallBack(L_INT FD); 
   virtual  L_UINT   RedirectReadCallBack( 
                                       L_INT FD, 
                                       L_CHAR  *pBuf, 
                                       L_INT nCount); 
   virtual  L_UINT   RedirectWriteCallBack( 
                                          L_INT FD, 
                                          L_CHAR  *pBuf, 
                                          L_INT nCount); 
   virtual  L_INT32  RedirectSeekCallBack( 
                                       L_INT FD, 
                                       L_INT32 lnPos, 
                                       L_INT nCount); 
}; 
 
LUserFileSFL::LUserFileSFL() 
{ 
} 
 
LUserFileSFL::~LUserFileSFL() 
{ 
} 
 
L_INT LUserFileSFL::FeedLoadCallBack(pFILEINFO pFileInfo, LBitmapBase * pLBitmap, 
                                  LBuffer * pLBuffer, L_UINT uFlags, 
                                  L_INT nRow, L_INT nLines) 
{ 
   UNREFERENCED_PARAMETER(pFileInfo); 
 
   UNREFERENCED_PARAMETER(uFlags); 
 
   UNREFERENCED_PARAMETER(nLines); 
 
   pLBitmap->Paint()->SetDC(m_hDC); 
   pLBitmap->Paint()->PaintDCBuffer( *pLBuffer, nRow); 
 
   return SUCCESS ; 
} 
 
/* This LOADINFOCALLBACK function provides information for a raw fax 
file. This example uses hard-coded and saved information. Your application  
probably would get the information in some other way. */ 
 
L_INT LUserFileSFL::LoadInfoCallBack(L_INT fd,pLOADINFO pInfo) 
{ 
   UNREFERENCED_PARAMETER(fd); 
 
   // Set the LOADINFO structure's fields 
   pInfo->BitsPerPixel = 1; 
   pInfo->Flags = LOADINFO_TOPLEFT; 
   pInfo->Format = FILE_FAX_G3_2D; 
   pInfo->Height = m_pBitmap->GetHeight(); // Value set before we created the file  
   pInfo->Offset = 0; 
   pInfo->Width = m_pBitmap->GetWidth(); // Value set before we created the file  
   return SUCCESS; 
 
} 
 
/* This procedure is a replacement to the built in Open procedure. 
It returns the number 5 (which looks like a file handle) 
to indicate that the function was successful. */ 
 
L_INT LUserFileSFL::RedirectOpenCallBack( L_TCHAR  *pFile,  
                                       L_INT nMode, L_INT nShare) 
{ 
   UNREFERENCED_PARAMETER(pFile); 
 
   UNREFERENCED_PARAMETER(nMode); 
 
   UNREFERENCED_PARAMETER(nShare); 
 
   Data.pCurData = Data.pData; 
   Data.dwUsed = 0; 
   return (5); 
} 
 
/* This procedure is a replacement to the built in Close procedure. 
This may be called many times, especially by L_FileInfo, so 
we need to reset the internal data structure to the defaults. */ 
 
L_INT LUserFileSFL::RedirectCloseCallBack(L_INT FD) 
{ 
   UNREFERENCED_PARAMETER(FD); 
 
   Data.pCurData = Data.pData; 
   Data.dwUsed = 0; 
   return (TRUE); 
} 
  
/* This procedure is a replacement to the built in read procedure. 
It reads the data from the allocated memory and adjusts the internal data. */ 
 
L_UINT LUserFileSFL::RedirectReadCallBack( L_INT FD,  
                                        L_CHAR  *pBuf, L_INT uCount) 
{ 
   UNREFERENCED_PARAMETER(FD); 
 
   // Is the request for more data than is left in memory?  
   if (uCount + Data.pCurData > Data.pData + Data.dwSize) 
      uCount = (L_UINT) (Data.dwSize - Data.dwUsed);   // adjust request 
 
   // Copy data to the buffer of the caller. 
   memcpy (pBuf, Data.pCurData, uCount); 
   // Adjust internal data.  
   Data.pCurData += uCount; 
   Data.dwUsed += uCount; 
 
   return ((L_UINT)uCount); 
} 
 
/* This procedure is a replacement to the built in Write procedure. 
In this example no I/O operation will be done, so we do nothing. */ 
 
L_UINT LUserFileSFL::RedirectWriteCallBack( L_INT FD,  
                                         L_CHAR  *pBuf, L_INT uCount) 
{ 
   UNREFERENCED_PARAMETER(FD); 
 
   UNREFERENCED_PARAMETER(pBuf); 
 
   return ((L_UINT)uCount); 
} 
  
/* This procedure is a replacement to the built-in seek procedure. 
This emulates the whole seek operation on a memory block, and 
adjusts the internal data structures accordingly. */ 
 
L_INT32 LUserFileSFL::RedirectSeekCallBack( L_INT FD,  
                                         L_INT32 lnPos, L_INT nCount) 
{ 
   UNREFERENCED_PARAMETER(FD); 
 
   switch (nCount) 
   { 
   case 0:                     /* SEEK_SET */ 
      Data.pCurData = Data.pData + lnPos; 
      Data.dwUsed = lnPos; 
      break; 
   case 1:                     /* SEEK_CUR */ 
      Data.pCurData += lnPos; 
      Data.dwUsed += lnPos; 
      break; 
   case 2:                     /* SEEK_END */ 
      if (0 <= lnPos)           /* Positive value, but at the end, so go to 
                                   the end. */ 
         lnPos = 0; 
      else 
         lnPos = -(lnPos);      /* Seek backwards from the end of the buffer. */ 
      Data.pCurData = Data.pData + Data.dwSize - lnPos; 
      Data.dwUsed = Data.dwSize - lnPos; 
      break; 
   } 
   return (L_INT) (Data.pCurData - Data.pData); 
} 
 
L_INT LFile__StartFeedLoadExample(HWND hWnd) 
{ 
   L_INT nRet; 
   HANDLE         hf;                  // File handle  
   L_UCHAR        cBuf[1024];          // Buffer for receiving data  
   L_INT          nRead;               // Amount of data read in one pass of the reading loop  
   L_UINT32       dwBaseTime;          // Value of the first call to GetTickCount  
   L_UINT32       dwReceiveTotal;      // Data received so far from the simulated transmission  
   L_UINT32       dwReceiveRead;       // Data actually processed so far  
   RECT           rClientSize;         // RECT for the client area  
   RECT           rLeadDest;           // Destination rectangle for painting 
   LBitmapBase    LeadBitmap ; 
   LUserFileSFL   userFile ; 
   DWORD          wReadBytes; 
 
   if (userFile.IsLoadInfoCallBackEnabled() == FALSE) 
      userFile.EnableLoadInfoCallBack(TRUE); 
 
   if((userFile.GetRedirectIOFlags() & (IO_REDIRECT_ALL)) != (IO_REDIRECT_ALL)) 
      userFile.SetRedirectIOFlags(IO_REDIRECT_ALL); 
 
   if (userFile.IsRedirectIOEnabled() == TRUE) 
      userFile.EnableRedirectIO(TRUE) ; 
 
   // Initialize variables used for simulating an incoming transmission  
   dwBaseTime = GetTickCount(); 
   dwReceiveTotal = 0; 
   dwReceiveRead = 0; 
 
// Open the file to be read  
   hf = CreateFile(MAKE_IMAGE_PATH(TEXT("ImageProcessingDemo\\Image3.cmp")), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); 
 
   /* Get the client area of the window. We assume that elsewhere in the program, the 
   L_FileInfo function has been used to update the FileInfo structure and that the 
   window dimensions have been adjusted to the bitmap's aspect ratio. */ 
   GetClientRect(hWnd,&rClientSize); 
 
   // Make the destination rectangle for painting the same as the client area  
   rLeadDest = rClientSize; 
 
   userFile.SetBitmap(&LeadBitmap) ; 
   userFile.SetFileName(MAKE_IMAGE_PATH(TEXT("image1.cmp"))) ; 
   userFile.EnableCallBack(TRUE) ; 
 
   userFile.m_hDC = GetDC(hWnd) ; 
 
   // Initialize the file-load process 
   nRet = userFile.StartFeedLoad ( 0, ORDER_BGR, LOADFILE_ALLOCATE | LOADFILE_STORE, NULL); 
   if(nRet != SUCCESS) 
      return nRet; 
 
   // Use the Windows GetTickCount function to simulate receiving a transmitted image  
   for( ; ; ) 
   { 
      // Calculate the data received so far, using a simulated baud rate of 28800 
      dwReceiveTotal = ((GetTickCount() - dwBaseTime) * (28800 / 100) / 100); 
      // Initialize the amount of data to read in this pass 
      nRead = (L_INT) min(dwReceiveTotal - dwReceiveRead, (L_UINT32) sizeof(cBuf)); 
 
      // Do nothing if no data was received in this pass  
      if(nRead == 0) 
         continue; 
      // Try to read the expected amount of data from the file into cBuf  
      nRead = (L_INT) ReadFile (hf, cBuf, nRead, &wReadBytes, NULL); 
      // We are finished if nothing was read 
      if(!nRead) 
         break; 
 
      LBuffer  LeadBuffer(cBuf,1024) ; 
      // Supply image data from cBuf to the file-load process 
      nRet = userFile.FeedLoad ( &LeadBuffer); 
      if(nRet != SUCCESS) 
         return nRet; 
 
      // Update the amount of data actually processed so far 
      dwReceiveRead += (L_UINT32) nRead; 
   } 
 
   // Close the file and clean up the file-load process 
   CloseHandle (hf); 
   nRet = userFile.StopFeedLoad (); 
   if(nRet != SUCCESS) 
      return nRet; 
 
   // Avoid an unnecessary repaint 
   ValidateRect(hWnd, &rLeadDest); 
 
   ReleaseDC( hWnd, userFile.m_hDC); 
   return SUCCESS; 
}