LOptimize::OptimizeBuffer

#include "ltwrappr.h"

L_INT LOptimize::OptimizeBuffer(pOrgImgBuffer, uOrgImgBufferSize, phOptImgBuffer, puOptImgBufferSize, pOptImgOptions)

L_UCHAR L_FAR * pOrgImgBuffer;	/* pointer to the image buffer to optimize */
L_UINT32 uOrgImgBufferSize;	/* size of the image in memory */
HGLOBAL L_FAR * phOptImgBuffer;	/* address of a memory handle */
L_UINT32 L_FAR * puOptImgBufferSize;	/* address of image-size variable to be updated */
pOPTIMIZEIMAGEOPTIONS pOptImgOptions;	/* pointer to the OPTIMIZEIMAGEOPTIONS structure */

Optimizes a supported image format buffer using the passed optimization options.

Parameter	Description
pOrgImgBuffer	Pointer to the original image buffer in memory. The image format in memory should be one of the LEAD Image optimizer supported formats.
uOrgImgBufferSize	Size, in bytes, of the original image in memory, which is referenced by the pOrgImgBuffer parameter.
phOptImgBuffer	Address of a memory handle to be updated by the optimized image buffer. The user is responsible for freeing it by calling the GlobalFree Windows function.
puOptImgBufferSize	Pointer to a variable to be updated with the size of the optimized image buffer in memory, which is referenced by phOptImgBuffer.
pOptImgOptions	Pointer to an OPTIMIZEIMAGEOPTIONS structure that contains the options used in optimization. Pass NULL to use the default optimization options.

Returns

SUCCESS	The function was successful.
< 1	An error occurred. Refer to Return Codes.

Comments

This function optimizes the specified buffer and reduces its size, based on the specified optimization options.

The function will initialize the phOptImgBuffer handle and allocate the storage necessary to hold the optimized image. Since the function allocates storage to hold the optimized image, the user must free the allocated memory by calling the Windows GlobalFree function.

Note that the image buffer to be optimized should be one of the LEAD Image optimizer supported formats otherwise the function will return an Error.

You can optimize an image buffer in memory as follows:

1.	Save the image to be optimized (the original image) in memory, and get a pointer to the first byte of this image. Pass this pointer as the pOrgImgBuffer parameter. Pass the size, in bytes, of the image in memory as the uOrgImgBufferSize parameter.
2.	Declare a memory handle (HGLOBAL) variable and pass its address as the phOptImgBuffer parameter. This function will allocate and unlock the memory needed to save the optimized image buffer.
3.	Declare a long integer (L_UINT32) variable. Pass the address of this variable as the puOptImgBufferSize parameter. This function will update this variable with the size, in bytes, of the optimized image buffer.
4.	Determine the optimization options to use, by doing one of the following:
	$image\sqrblit.gif$ Pass NULL in the pOptImgOptions parameter to optimize the image buffer using the default optimization options.
	$image\sqrblit.gif$ Get the default optimization options by calling LOptimize::GetDefaultOptions function, and update the structure values as you like. Pass the address of the updated optimization options structure in the pOptImgOptions parameter.
5.	Call this function to optimize the image buffer and update the phOptImgBuffer and uOptImgBufferSize variables with the optimized buffer and buffer size.

Required DLLs and Libraries

LTIMGOPT

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

See Also

Functions:	LOptimize::GetDefaultOptions, LOptimize::OptimizeDir, LOptimize::OptimizeDirCallBack, LOptimize::OptimizeBufferCallBack, LMemoryFile::SaveBitmap, LMemoryFile::LoadBitmap, Class Members
Topics:	Image Optimization
	Raster Image Functions: Optimization Functions

Example

L_INT LOptimizeChild::OptimizeBufferCallBack(L_INT nPercent)
{
   L_TCHAR buf[1024]; // Message buffer

   wsprintf(buf, TEXT("%d"), nPercent);
   lstrcat(buf, TEXT("% Optimizing ")) ;
   MessageBox(NULL, buf, TEXT("Optimizing"), MB_OK | MB_ICONINFORMATION);

   return SUCCESS;
}

void OptimizeBufferExample()
{
   LOptimizeSon opt;
   LMemoryFile mfile;
   LBuffer buf;
   L_INT nRet = 0;
   L_UINT32 uOrgImgBufferSize = 0;
   L_UCHAR L_FAR * phOrgImgBuffer = NULL;
   HGLOBAL hOptImgBuffer = NULL; //Handle to the Optimized Buffer in Memory
   L_UINT32 uOptImgBufferSize = 0; //size of the optimized buffer in Memory
   OPTIMIZEIMAGEOPTIONS OptImgOptions; //optimization options structure
   L_UCHAR L_FAR * pOptImgBuffer = NULL;

   mfile.SetBitmap(&m_LBitmapWnd);
   nRet = mfile.SaveBitmap( &buf, FILE_GIF,8,0,NULL) ;

   uOrgImgBufferSize = buf.GetSize();

   phOrgImgBuffer = (L_UCHAR L_FAR *)GlobalLock(buf.GetHandle());

   memset(&OptImgOptions, 0,sizeof(OPTIMIZEIMAGEOPTIONS)) ;
   nRet = opt.GetDefaultOptions(&OptImgOptions, sizeof(OPTIMIZEIMAGEOPTIONS));

   if(nRet == SUCCESS)
   {
      //Optimize the image buffer
      opt.EnableCallBack(TRUE) ;
      nRet = opt.OptimizeBuffer(phOrgImgBuffer, uOrgImgBufferSize, &hOptImgBuffer, // to be updated.
                                                               &uOptImgBufferSize, // to be updated.
                                                               &OptImgOptions);
      if(nRet == SUCCESS)
      {
         //To work on the optimized buffer, We have to lock it.
         pOptImgBuffer = (L_UCHAR L_FAR *) GlobalLock(hOptImgBuffer);
         if(pOptImgBuffer)
         {
            //Now, pOptImgBuffer is ready to work on,
            //for example you can create a disk file and dump this buffer to it.
            FILE* fo = fopen("c:\\Optimized.gif","wb");
            fwrite(pOptImgBuffer,uOptImgBufferSize,1,fo);
            fclose(fo);
            //Unlock the Memory Buffer.
            GlobalUnlock(hOptImgBuffer);
            //Free the Memory Buffer allocated by OptimizeBuffer function.
            GlobalFree(hOptImgBuffer);
         }
      }
   }
   buf.Unlock();
   buf.Free();
}