L_StartCompressBuffer

#include "l_bitmap.h"

L_LTFIL_API L_INT L_StartCompressBuffer(pBitmap, pfnCallback, uInputBytes, uOutputBytes, pOutputBuffer, nOutputType, nQFactor, pUserData, pSaveOptions)

Initializes the buffered compression engine. The compression is then carried out using the L_CompressBuffer function. It is ended by the L_EndCompressBuffer function.

Returns

Comments

This function does not support signed data images. It returns the error code ERROR_SIGNED_DATA_NOT_SUPPORTED if a signed data image is passed to this function.

You must declare and initialize a bitmap handle before calling this function, but you do not have to allocate the bitmap. In the bitmap handle, the Order field must be ORDER_BGR, and the ViewPerspective field must be TOP_LEFT. Then, the data that you put into the input buffer must be BGR and loaded from top left.

The compression process starts after the first call to L_CompressBuffer. Your callback function is called when the output buffer is filled with compressed data or after completing the compression process. The callback function is responsible for emptying the output buffer storing it, sending it, or doing other processing.

Your program must allocate the output buffer. The following is a flow chart that shows the relationship of these functions:

Do not free any buffers that the compression engine uses until after you call the L_EndCompressBuffer function.

Required DLLs and Libraries

Platforms

Windows 2000 / XP/Vista, Windows CE.

See Also

Example

This example demonstrates low-level image compression using L_StartCompressBuffer,L_CompressBuffer, L_CompressBuffer, and L_EndCompressBufferL_EndCompressBuffer. The callback function for writing the output is included at the end of the example.

L_INT EXT_CALLBACK FileWrite (pBITMAPHANDLE pBitmap,
                              L_UCHAR     * pBuffer,
                              L_SIZE_T      uBytes,
                              L_VOID      * pParams)
{
   UNREFERENCED_PARAMETER (pBitmap);
   DWORD dwBytesWritten;

   /* Write data to the file.  Note that the file handle is passed in as an L_VOID
      pointer as per the LEAD definition and must be cast appropriately to use it as a file handle. */
   WriteFile((HANDLE)pParams, pBuffer, (DWORD)uBytes, &dwBytesWritten, NULL);
   return (SUCCESS);
}

 L_INT StartCompressBufferExample(pBITMAPHANDLE LeadBitmap)
{
   L_INT nRet;
   L_INT i, j;            /* Loop counters                           */
   HANDLE hFD;             /* File handle                             */
   L_UINT32 uLineBytes;   /* Bytes per line in the input buffer      */
   HGLOBAL hInBuffer;     /* Input buffer handle                     */
   HGLOBAL hOutBuffer;    /* Output buffer handle                    */
   L_UCHAR *lpInBuffer;   /* Pointer to the input buffer             */
   L_UCHAR *lpOutBuffer;  /* Pointer to the output buffer            */
   L_UCHAR *lpDataBuffer; /* Copy of the pointer to the input buffer */
   
   /* Load the image to the bitmap at 24-bits per pixel */
   if(LeadBitmap->Flags.Allocated)
      L_FreeBitmap(LeadBitmap);
   nRet = L_LoadBitmap (TEXT("C:\\Program Files\\LEAD Technologies\\LEADTOOLS 15\\Images\\IMAGE3.CMP"), LeadBitmap, sizeof(BITMAPHANDLE), 24, ORDER_BGR, NULL, NULL);
   if(nRet != SUCCESS)
      return nRet;
   if(LeadBitmap->ViewPerspective != TOP_LEFT)
   {
      nRet = L_ChangeBitmapViewPerspective ( NULL, LeadBitmap, sizeof(BITMAPHANDLE), TOP_LEFT );
      if(nRet != SUCCESS)
         return nRet;
   }

   /* Create the output file */
   hFD = CreateFile(TEXT("C:\\Program Files\\LEAD Technologies\\LEADTOOLS 15\\Images\\COMPCB.CMP"), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);

   /* Calculate the bytes per line in the input buffer, without padding */
   uLineBytes = LeadBitmap->Width * 3;

   /* Allocate memory for the incoming uncompressed data. Note that we
      are compressing 16 lines at a time. You should always use multiples of 16 */
   hInBuffer = GlobalAlloc( GMEM_MOVEABLE, 16 * uLineBytes);
   lpInBuffer = (L_UCHAR *)GlobalLock( hInBuffer );

   /* Allocate an output buffer. This is where the compressed data will
      go. Note that this allocates 1024-byte packets. */
   hOutBuffer = GlobalAlloc( GMEM_MOVEABLE, 1024 );
   lpOutBuffer = (L_UCHAR *)GlobalLock( hOutBuffer );

   /* Lock down the bitmap */
   L_AccessBitmap( LeadBitmap );  

   /* Initialize the compression engine  */
   nRet = L_StartCompressBuffer(LeadBitmap,
                               FileWrite,
                               16 * uLineBytes,
                               1024,
                               (L_UCHAR *)lpOutBuffer,
                               LEAD,
                               QFS,
                               (L_VOID *) &hFD, NULL );
   if(nRet != SUCCESS)
      return nRet;

   /* Compress the data */
   for( i = 0; i < LeadBitmap->Height; ) /* i is incremented at the end */
   {
      lpDataBuffer = lpInBuffer;

      /* Compression of the 16-line chunk starts here */
      for( j = 0; (i+j) < LeadBitmap->Height && j < 16; j++ )
      {
         /* Get one line at time */
         nRet = (L_INT)  L_GetBitmapRow(LeadBitmap, lpDataBuffer, i+j, uLineBytes);
         if(nRet < 1)
            return nRet;

         /* Move the pointer to next line */
         lpDataBuffer = lpDataBuffer + uLineBytes;
      }

      /* This is the main function that will do the actual Compression. */
      nRet = L_CompressBuffer(lpInBuffer);
      if(nRet != SUCCESS)
         return nRet;
      i += 16;
   }

   /* Reset the compression engine */
   nRet = L_EndCompressBuffer();
   if(nRet != SUCCESS)
      return nRet;

   /* Free all allocated memory.  Release the bitmap.  Close the file. */
   GlobalUnlock( hInBuffer );
   GlobalFree( hInBuffer );
   GlobalUnlock( hOutBuffer );
   GlobalFree( hOutBuffer );
   L_ReleaseBitmap(LeadBitmap );
   CloseHandle( hFD );

   MessageBox (NULL, TEXT("Function complete"), TEXT("Notice"), MB_OK);

   return SUCCESS;
}