LFile::StartFeedLoad

#include "ltwrappr.h"

virtual L_INT LFile::StartFeedLoad(nBitsPerPixel=0, nOrder=ORDER_BGRORGRAY, uFlags=LOADFILE_ALLOCATE|LOADFILE_STORE, pLoadFileOption=NULL, pFileInfo)

Initializes a file-load process in which you control the input stream. You must call the LFile::FeedLoad function to supply buffered data, and you must call LFile::StopFeedLoad when the loading is complete.

Returns

Comments

This file-load process is useful when receiving transmitted images, such as those on the Internet. It works the same way as the LFile::LoadFile function, except that your code supplies the image data. The file-load process works as follows:

ORDER_GRAY is only valid for 12 and 16-bit grayscale images. Support for 12 and 16-bit grayscale images is only available in the Document/Medical toolkits.

This function cannot be used in combination with the Redirect input / output functions.

Required DLLs and Libraries

See Also

Example

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.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(TEXT("%UserProfile%\\My Documents\\LEADTOOLS Images\\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(TEXT("%UserProfile%\\My Documents\\LEADTOOLS Images\\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;
}