L_ReadFileTagMemory - Raster Imaging C API Help

L_ReadFileTagMemory

#include "l_bitmap.h"

L_LTFIL_API L_INT L_ReadFileTagMemory(pBuffer, uTag, pType, pCount, pData, nBufferSize, pLoadOptions)

L_UCHAR* pBuffer;

pointer to the file in memory

L_UINT16 uTag;

tag to identify the data in the TIFF file

L_UINT16* pType;

address of the variable for the data type

L_UINT* pCount;

address of the variable for the count

L_VOID* pData;

pointer to the buffer for the data

L_SSIZE_T nBufferSize;

size of the file in memory (in bytes)

pLOADFILEOPTION pLoadOptions;

pointer to optional extended load options

Gets the specified tagged data from a TIFF file in memory. This function is provided to support TIFF tags that you define.

Parameter Description
pBuffer Pointer to the file in memory.
uTag Tag to identify the data in the TIFF file. Use the same tag that you specified in the L_SetTag function.
pType Address of the variable to be updated with the tagged data type. The following are possible values:
  Value Meaning
  TAG_BYTE [1] Byte.
  TAG_ASCII [2] Byte in the range of 0 to 255.
  TAG_SBYTE [6] Byte used as signed number in the range of -128 to +127.
  TAG_UNDEFINED [7] Byte, with application-defined usage.
  TAG_SHORT [3] Two bytes, unsigned.
  TAG_SSHORT [8] Two bytes, signed.
  TAG_LONG [4] Four bytes, unsigned.
  TAG_SLONG [9] Four bytes, signed.
  TAG_RATIONAL [5] Eight bytes, used as a pair of unsigned long integers, where the first number is the numerator and the second is the denominator of a fraction.
  TAG_SRATIONAL [10] Eight bytes, used as a pair of signed long integers, where the first number is the numerator and the second is the denominator of a fraction.
  TAG_FLOAT [11] Four bytes used as a floating point number.
  TAG_DOUBLE [12] Eight bytes used as a double-precision floating point number.
TAG_IFD [13] 32-bit IFD offset.
TAG_LONG8 [16] Unsigned 64-bit integer (valid only for BigTIFF formats).
TAG_SLONG8 [17] Signed 64-bit integer (valid only for BigTIFF formats).
TAG_IFD8 [18] 64-bit IFD offset (valid only for BigTIFF formats).
pCount Address of the variable to be updated with the count of data items. The count is based on the tagged data type. For example, if the count is 2 and the data type is TAG_DOUBLE, the required buffer size is 16.
pData Pointer to the buffer to be updated with the data. You can pass NULL if you want to use this function's return value to determine the required buffer size.
nBufferSize Size of the file in memory (in bytes).
pLoadOptions Pointer to optional extended load options. Pass NULL to use the default load options.

Returns

>=0

Length of the tagged data, in bytes.

< 0

An error occurred. Refer to Return Codes.

Comments

It is often convenient to call this function twice, as follows:

1.

Call the function the first time, specifying NULL in the pData parameter, and using the return value to determine the required size of the buffer.

2.

Allocate the buffer.

3.

Call the function the second time, passing a pointer to your buffer in the pData parameter.

For general information about TIFF tags, refer to Implementing TIFF Comments and Tags.

Required DLLs and Libraries

LTFIL

For a listing of the exact DLLs and Libraries needed, based on the toolkit version, refer to Files To Be Included With Your Application.

Platforms

Win32, x64, Linux.

See Also

Functions:

L_SetTag, L_GetTag, L_ReadFileTag, L_DeleteTag, L_ReadFileTags

Topics:

Implementing TIFF Comments and Tags

Example

This example specifies a tag for recording the position of a company logo on an image. It sets the tag with L_SetTag; saves the image as a TIFF file in memory; then uses L_ReadFileTagMemory to read the tag from the file in memory.

L_INT ReadFileTagMemoryExample(pBITMAPHANDLE pBitmap) 
{ 
   L_INT nRet; 
   L_TCHAR msgbuf[80];              /* buffer for the message string */ 
   L_UINT16 LogoPosition = 0x8001;  /* my private tag                */ 
   L_UINT16 TagType = TAG_SSHORT;   /* tagged data type              */ 
   L_UINT32 TagCount = 4;           /* count of data items           */ 
   short TagData[] = {5, 5, 24, 37}; 
   L_VOID * pTagData = &TagData; /* pointer to the buffer containing tagged data */ 
   HGLOBAL hBuf;                 /* handle to the buffer for the file            */ 
   L_INT32 BufferSize;           /* required size of the file buffer             */ 
   HGLOBAL hFileInMemory=NULL;   /* memory handle for the file                   */ 
   L_SIZE_T uMemSize;            /* size of the file in memory                   */ 
   L_UCHAR *pData;               /* pointer to the file in memory                */ 
 
   /* Set the tag data to be saved */ 
   nRet = L_SetTag(LogoPosition, TagType, TagCount, pTagData); 
   if(nRet != SUCCESS) 
      return nRet; 
 
   /* Save the image as a TIFF file in memory */ 
   nRet = L_SaveBitmapMemory(&hFileInMemory, pBitmap, FILE_TIF, pBitmap->BitsPerPixel, 0, &uMemSize, NULL); 
   if(nRet != SUCCESS) 
      return nRet; 
 
   /* Get the pointer to the memory-resident file */ 
   pData = (L_UCHAR *) GlobalLock (hFileInMemory); 
 
   /* Clear the variables so that we can validate the data */ 
   TagType = 0; 
   TagCount = 0; 
   TagData[0] = 0; 
   TagData[1] = 0; 
   TagData[2] = 0; 
   TagData[3] = 0; 
 
   /* Get the required size of the buffer for the tagged data */ 
   BufferSize = L_ReadFileTagMemory(pData, LogoPosition, &TagType, &TagCount, NULL, uMemSize, NULL); 
 
   /* Allocate and lock the buffer */ 
   if ((TagType == TAG_SSHORT) && (BufferSize > 0)) 
   { 
      hBuf = GlobalAlloc(GMEM_MOVEABLE, BufferSize); 
      pTagData = GlobalLock( hBuf ); 
   } 
   else 
   { 
      GlobalUnlock (hFileInMemory); 
      GlobalFree (hFileInMemory); 
      return BufferSize; 
   } 
 
   /* Get the tagged data */ 
   nRet = L_ReadFileTagMemory(pData, LogoPosition, &TagType, &TagCount, pTagData, uMemSize, NULL); 
 
   /* Display a message showing the data */ 
   if ((TagType == TAG_SSHORT) && (TagCount == 4))  
   { 
      wsprintf(msgbuf, TEXT("X = %d\nY= %d\nWidth = %d\nHeight = %d"),  
            ((short  *)pTagData)[0],  
            ((short  *)pTagData)[1],  
            ((short  *)pTagData)[2],  
            ((short  *)pTagData)[3]);  
      MessageBox (NULL, msgbuf, TEXT("Logo Position"), MB_OK);    
   } 
 
   /* Free memory that we no longer need */ 
   GlobalUnlock (hBuf); 
   GlobalFree(hBuf);  
   GlobalUnlock (hFileInMemory); 
   GlobalFree (hFileInMemory); 
   return SUCCESS; 
} 

Help Version 20.0.2018.7.30
Products | Support | Contact Us | Copyright Notices
© 1991-2018 LEAD Technologies, Inc. All Rights Reserved.

LEADTOOLS Raster Imaging C API Help