L_StartCompressBuffer

#include "l_bitmap.h"

L_INT EXT_FUNCTION 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

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.

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.

Required DLLs and Libraries

Platforms

Windows 95 / 98 / Me, Windows 2000 / XP, Windows CE.

See Also

Example

For complete sample code, refer to the COMPCB example5Example.

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

The sample code uses the following global declarations: */

HINSTANCE hInst;   /* Current instance of the application, set by the InitInstance function */
BITMAPHANDLE LeadBitmap;   /* Bitmap handle to hold the loaded image */
COMPBUFFCALLBACK lpfnCallBack; 

/* Prototype for the COMPBUFFCALLBACK function */
L_INT L_EXPORT EXT_CALLBACK  FileWrite (pBITMAPHANDLE pBitmap, 
                                L_UCHAR L_FAR * pBuffer, L_UINT nBytes,
                                L_VOID L_FAR * pParams);
/****************************************************************************************/
void TestFunction(void)
{
   L_INT i, j;          /* Loop counters */
   L_INT 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 L_FAR *lpInBuffer;       /* Pointer to the input buffer */
   L_UCHAR L_FAR *lpOutBuffer;      /* Pointer to the output buffer */
   L_UCHAR L_FAR *lpDataBuffer;     /* Copy of the pointer to the input buffer */
   /* Load the image to the bitmap at 24-bits per pixel */
   L_LoadBitmap (TEXT("IMAGE3.CMP"), &LeadBitmap, sizeof(BITMAPHANDLE), 24, ORDER_BGR, NULL, NULL);
   if(LeadBitmap.ViewPerspective != TOP_LEFT)
      L_ChangeBitmapViewPerspective ( NULL, &LeadBitmap, sizeof(BITMAPHANDLE), TOP_LEFT );
   /* Create the output file */
   #ifdef UNICODE

hFD = _wcreat(TEXT("COMPCB.CMP"), 0);

#else

hFD = _lcreat("COMPCB.CMP", 0);

#endif

   /* 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 L_FAR *)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 L_FAR *)GlobalLock( hOutBuffer );
   /* Set the callback function*/
   lpfnCallBack = (COMPBUFFCALLBACK) MakeProcInstance(
                                          (FARPROC) FileWrite, hInst );
   /* Lock down the bitmap */
   L_AccessBitmap( &LeadBitmap );  
   /* Initialize the compression engine  */
   L_StartCompressBuffer( &LeadBitmap,
                        lpfnCallBack,
                        16 * uLineBytes,
                        1024,
                        (L_CHAR L_FAR *)lpOutBuffer,
                        LEAD,
                        QFS,
                        (L_VOID L_FAR*) &hFD, NULL );
   /* 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 */
         L_GetBitmapRow(&LeadBitmap, lpDataBuffer, i+j, uLineBytes);
         /* Move the pointer to next line */
         lpDataBuffer = lpDataBuffer + uLineBytes;
      }
      /* This is the main function that will do the actual Compression. */
      L_CompressBuffer(lpInBuffer);
      i += 16;
   }

   /* Reset the compression engine */
   L_EndCompressBuffer();
   /* Free the callback function*/
   FreeProcInstance((FARPROC) lpfnCallBack);
   /* Free all allocated memory.  Release the bitmap.  Close the file. */
   GlobalUnlock( hInBuffer );
   GlobalFree( hInBuffer );
   GlobalUnlock( hOutBuffer );
   GlobalFree( hOutBuffer );
   L_ReleaseBitmap( &LeadBitmap );
   _lclose( hFD );

   MessageBox (NULL, TEXT("Function complete - Look at COMPCB.CMP"), TEXT("Notice"), MB_OK);
   return;
}

/* Callback function for L_StartCompressBuffer */

L_INT L_EXPORT EXT_CALLBACK FileWrite (pBITMAPHANDLE pBitmap, L_UCHAR L_FAR * pBuffer, 
                                L_UINT uBytes, L_VOID L_FAR * pParams)
{
   UNREFERENCED_PARAMETER (pBitmap);
   /* Write data to the file.  Note that the file handle is passed in as an L_VOID
      L_FAR pointer as per the LEAD definition and must be cast appropriately
      to use it as a file handle. */
   _lwrite (*(L_INT L_FAR *) pParams, (L_CHAR *)pBuffer, uBytes);
   return (SUCCESS);
}