LEADTOOLSラスターイメージングC API Help > 関数の参照 > L_RedirectIO
フレームを表示

L_RedirectIO

フレームを表示

#include "l_bitmap.h"

L_LTKRN_API L_VOID L_RedirectIO(pfnOpen, pfnRead, pfnWrite, pfnSeek, pfnClose, pUserData)

REDIRECTOPEN pfnOpen;

/* 公開手順への遠いポインター*/

REDIRECTREAD pfnRead;

/* 読まれた手順への遠いポインター*/

REDIRECTWRITE pfnWrite;

書き込む/*遠いポインター手順*/

REDIRECTSEEK pfnSeek;

/* シーク手順への遠いポインター*/

REDIRECTCLOSE pfnClose;

/* 精密な処置への遠いポインター*/

L_VOID* pUserData;

/* 追加のパラメーターへのポインタ*/

ファイルを開いて、読んで、書き込んで、捜して、閉じるためにLEADTOOLS入出力関数を置換させます。

パラメーター

説明

pfnOpen

公開手順への遠いポインター。デフォルトにリセットにNULLを使います。コールバック関数構文の説明のために、REDIRECTOPENコールバック関数を参照します。

pfnRead

読まれた手順への遠いポインター。デフォルトにリセットにNULLを使います。コールバック関数構文の説明のために、REDIRECTREADコールバック関数を参照します。

pfnWrite

遠いポインター書き込みます手順。コールバックの説明のためのデフォルトへのリセットへの使用NULLは、構文を機能させて、REDIRECTWRITEコールバック関数に言及します。

pfnSeek

シーク手順への遠いポインター。デフォルトにリセットにNULLを使います。コールバック関数構文の説明のために、REDIRECTSEEKコールバック関数を参照します。

pfnClose

精密な処置への遠いポインター。デフォルトにリセットにNULLを使います。コールバック関数構文の説明のために、REDIRECTCLOSEコールバック関数を参照します。

pUserData

コールバック関数が必要とするデータを含む変数や構造体へアクセスできるvoidポインタ。これにより、このコールバック関数を使用する関数から間接的にデータを受け取ることができます。（これは関数の呼出しのpUserDataパラメーターで渡す同じポインターです。）

 

これがボイドポインター（コールバック関数の中で適切なデータ型にキャストされなければなりません）であることを心にとめておきます。

戻り値

なし。

コメント

たとえば、再直接尋問のすべてのツールキットI/Oが機能する缶をマルチメディアエクステンションを用いてLEADTOOLS I/O関数のすべて向け直すことができます独自の、I/Oは機能します。

そのデフォルト設定にI/O関数をリセットするために、NULL引数を使います。I/Oプロセスの再定義は、定義するために、そのままにされます。

この関数が、L_FeedLoad、L_LoadBitmapMemory、L_LoadMemory、L_StartFeedLoad、L_StopFeedLoad、L_SaveBitmapMemoryとL_SaveFileMemoryと結合して使われることができません。

注意：

向け直されたIOは、若干のファイルフォーマットのためにサポートされません。詳細については、「リダイレクトIOがサポートされないファイル形式」を参照してください。

必須のDLLとライブラリ

LTKRN

ツールキットバージョンに基づいた正確なDLLとライブラリのリストについては、「アプリケーションとともに配布するファイル」を参照してください。

プラットホーム

Win32、x64、Linux。

参照

トピック：

ラスター画像は機能します：入出力

 

アノテーション関数：入出力

サンプル

このサンプルは、向け直された入出力を使用してファイルをロードします。どのように実装されるか見る個々のコールバック機能記述を参照してください

#define MAKE_IMAGE_PATH(pFileName) TEXT("C:\\Users\\Public\\Documents\\LEADTOOLS Images\\")pFileName


/************************** 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_LTKRNTEX_API 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;
}