L_RedirectIO

/************************** Global Declarations **********************************/ 
typedef struct tagDATA 
{ 
   BITMAPHANDLE   BitmapHandle;     /* BITMAP HANDLE to hold the image. */ 
} DATA; 
 
typedef struct tagUSERDATA 
{ 
   L_SIZE_T dwSize;       /* Size of the buffer. */ 
   L_SIZE_T dwUsed;       /* Number of bytes used. */ 
   L_UCHAR *pData;        /* Pointer to the actual buffer. */ 
   L_UCHAR *pCurData;     /* Current pointer location. */ 
} USERDATA, * LPUSERDATA; 
 
DATA     Data;       /* Pointer to DATA structure */ 
HANDLE   hBuf;       /* Handle for globally allocated memory */ 
USERDATA UserData;   /* User structure for I/O operation */ 
 
/* my own I/O callback functions */ 
L_HFILE EXT_CALLBACK WindowsOpen(L_TCHAR* pFile, 
                                 L_INT nMode, 
                                 L_INT nShare, 
                                 L_VOID* pUserData); 
 
L_INT EXT_CALLBACK MyClose (L_HFILE FD, L_VOID* pUserData) 
{ 
   /* we already have the file in memory so do nothing */ 
   UNREFERENCED_PARAMETER (FD); 
   LPUSERDATA pData = (LPUSERDATA)pUserData; 
 
   pData->pCurData = pData->pData; 
   pData->dwUsed = 0; 
   return (TRUE); 
} 
 
L_OFFSET EXT_CALLBACK MySeek (L_HFILE FD, L_OFFSET nPos, L_INT nOrigin, L_VOID* pUserData) 
{ 
   /* see in the memory buffer */ 
   UNREFERENCED_PARAMETER (FD); 
   LPUSERDATA pData = (LPUSERDATA)pUserData; 
 
   switch (nOrigin) 
   { 
   case 0:                     /* SEEK_SET */ 
      pData->pCurData = pData->pData + nPos; 
      pData->dwUsed = (L_SIZE_T)nPos; 
      break; 
   case 1:                     /* SEEK_CUR */ 
      pData->pCurData += nPos; 
      pData->dwUsed += (L_SIZE_T)nPos; 
      break; 
   case 2:                     /* SEEK_END */ 
      if (0 <= nPos)           /* Positive value, but at the end, so go to 
                                   the end. */ 
         nPos = 0; 
      else 
         nPos = -(nPos);      /* Seek backwards from the end of the buffer. */ 
      pData->pCurData = pData->pData + pData->dwSize - nPos; 
      pData->dwUsed = (L_SIZE_T)(pData->dwSize - nPos); 
      break; 
   } 
   return (pData->pCurData - pData->pData); 
} 
 
L_UINT EXT_CALLBACK MyWrite (L_HFILE FD, L_UCHAR * pBuf, L_UINT uCount, L_VOID* pUserData) 
{ 
   /* this is a read example, do nothing for write */ 
   UNREFERENCED_PARAMETER (FD); 
   UNREFERENCED_PARAMETER (pBuf); 
   UNREFERENCED_PARAMETER (pUserData); 
   return (uCount); 
} 
 
L_UINT EXT_CALLBACK MyRead (L_HFILE FD, L_UCHAR * pBuf, L_UINT uCount, L_VOID* pUserData) 
{ 
   /* read by copying from the memory buffer */ 
   UNREFERENCED_PARAMETER (FD); 
   LPUSERDATA pData = (LPUSERDATA)pUserData; 
 
   /* reading past end of file? */ 
   if(pData->pCurData >= pData->pData + pData->dwSize) 
      return 0; 
 
   /* Is the request for more data than is left in memory? */ 
   if (uCount + pData->pCurData > 
       pData->pData + pData->dwSize) 
      uCount = (L_UINT) (pData->dwSize - pData->dwUsed);   /* adjust request */ 
 
   /* Copy data to the buffer of the caller.  We can use _fmemcpy (even with 
      BORLAND) because LEADTOOLS will never request more than 64k. */ 
   _fmemcpy (pBuf, pData->pCurData, uCount); 
 
   /* Adjust internal data. */ 
   pData->pCurData += uCount; 
   pData->dwUsed += uCount; 
   return (uCount); 
} 
 
L_HFILE EXT_CALLBACK MyOpen(L_TCHAR* pFile, L_INT nMode, L_INT nShare, L_VOID* pUserData) 
{ 
   /* we already have the file in memory so do nothing */ 
   LPUSERDATA pData = (LPUSERDATA)pUserData; 
   UNREFERENCED_PARAMETER (pFile); 
   UNREFERENCED_PARAMETER (nMode); 
   UNREFERENCED_PARAMETER (nShare); 
   pData->pCurData = pData->pData; 
   pData->dwUsed = 0; 
   return (L_HFILE)5; 
} 
 
/***************************************************************************************/ 
L_INT RedirectIOExample(L_VOID) 
{ 
   L_SIZE_T lSizeToRead; 
   HANDLE hFile; 
   L_INT nRet; 
 
   /* We will allocate a buffer of the image size and read the image into it, 
   then all of our I/O operations will be operate on this buffer */ 
 
   hFile = CreateFile(MAKE_IMAGE_PATH(TEXT("image1.cmp")), GENERIC_READ , 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); 
 
   UserData.dwSize =  GetFileSize(hFile, NULL); 
   /* Allocate a buffer to hold the file. */ 
   hBuf = GlobalAlloc (GMEM_MOVEABLE, UserData.dwSize); 
   UserData.pData = (L_UCHAR *)GlobalLock (hBuf); 
   UserData.pCurData = UserData.pData; 
   UserData.dwUsed = 0; 
   lSizeToRead = 0; 
   /* Read the file in a loop, because the file could be larger than a single 
      read can request. */ 
   memset(UserData.pData, 0x44, UserData.dwSize); 
 
   while (lSizeToRead < UserData.dwSize) 
   { 
      if ( !ReadFile(hFile, (L_VOID *) UserData.pCurData, (DWORD)min (UserData.dwSize - lSizeToRead, 32000), (LPDWORD)&nRet, NULL)) 
      { 
         GlobalUnlock (hBuf); 
         GlobalFree (hBuf); 
         CloseHandle (hFile); 
         return (FALSE);        /* Failure on creation! */ 
      } 
      else 
      { 
         lSizeToRead += nRet; 
         UserData.pCurData += nRet; 
      } 
   } 
   UserData.pCurData = UserData.pData; 
   CloseHandle(hFile); 
 
   /* Use our own routines to replace the internal I/O calls */ 
   L_RedirectIO (MyOpen, MyRead, MyWrite, MySeek, MyClose, &UserData); 
 
   /* Load the bitmap as an 8 bit */ 
   nRet = L_LoadBitmap (MAKE_IMAGE_PATH(TEXT("cannon.jpg")), &Data.BitmapHandle, sizeof(BITMAPHANDLE), 8, ORDER_RGB, NULL, NULL); 
   if(nRet != SUCCESS) 
      return nRet; 
   /* Reset the I/O routines to the default ones. */ 
   L_RedirectIO (NULL, NULL, NULL, NULL, NULL, NULL); 
 
   /* free the bitmap when we are done */ 
   L_FreeBitmap(&Data.BitmapHandle); 
   GlobalUnlock (hBuf); 
   GlobalFree (hBuf); 
   return SUCCESS; 
}