LMemoryFile::StartCompressBuffer

#include "ltwrappr.h"

virtual L_INT LMemoryFile::StartCompressBuffer(uInputBytes, uOutputBytes, nOutputType, nQFactor=2, pSaveFileOption=NULL)

Initializes the buffered compression engine. The compression is then carried out using the LMemoryFile::CompressBuffer function. It is ended by the LMemoryFile::EndCompressBuffer function.

Returns

Comments

You must declare and initialize m_pBitmap 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 LMemoryFile::CompressBuffer. You must override LMemoryFile::CompressBufferCallBack, which will be 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.

NOTE: 4:1:1 and 4:2:2 formats use subsampling for the color components. In the case of 4:1:1, the color components for 4 pixels is averaged during compression. This will cause a color shift, but the shift is tolerable for low compression ratios. If you have high compression and repeated savings, then the color shift will increase.  Due to this characteristic of the JPEG algorithm, the only ways to avoid this are to: (a)  use 4:4:4 (which has no subsampling), or (b) avoid repeated load and resave.

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

Win32, x64.

See Also

Example

// define user LMemoryFile class to override its CallBacks
class LUserMemoryFileSCB : public LMemoryFile
{
public:
   LUserMemoryFileSCB () ;
   virtual ~LUserMemoryFileSCB () ;
   virtual L_INT CompressBufferCallBack(LBitmapBase * pLBitmap, LBuffer * pLBuffer);
};
LUserMemoryFileSCB::LUserMemoryFileSCB()
{
}
LUserMemoryFileSCB::~LUserMemoryFileSCB ()
{
}
L_INT LUserMemoryFileSCB::CompressBufferCallBack(LBitmapBase* pLBitmap, LBuffer* pLBuffer)
{
   UNREFERENCED_PARAMETER(pLBitmap);
   UNREFERENCED_PARAMETER(pLBuffer);
   MessageBox(NULL, TEXT("Here Compress Buffer CallBack"), TEXT("CompressBufferCallBack"), MB_OK);
   return SUCCESS ;
}
L_INT LMemoryFile__StartCompressBufferExample(LBitmapBase& LeadBitmap)
{
   L_INT nRet;
   L_SIZE_T zRet;
   LUserMemoryFileSCB userLeadMemFile ;
   LBuffer LeadBuffer ;
   L_UINT uLineBytes ;
   L_INT i;
   userLeadMemFile.SetBitmap(&LeadBitmap) ;
   userLeadMemFile.EnableCallBack(TRUE) ;
   uLineBytes = LeadBitmap.GetWidth() * 3 ;
   // Initialize the compression engine
   nRet = userLeadMemFile.StartCompressBuffer(16 * uLineBytes,
                                       1024,
                                       LEAD,
                                       QFS,
                                       NULL);
   if(nRet != SUCCESS)
      return nRet;
   // Compress the data 
   for( i = 0; i < LeadBitmap.GetHeight(); i++) // i is incremented at the end
   {
      // Get one line at time
      zRet = LeadBitmap.GetRow(&LeadBuffer, i);
      if(zRet < 1)
         return (L_INT) zRet;
      // This is the main function that will do the actual Compression.
      nRet = userLeadMemFile.CompressBuffer(&LeadBuffer);
      if(nRet != SUCCESS)
         return nRet;
   }
   // Reset the compression engine
   nRet = userLeadMemFile.EndCompressBuffer();
   if(nRet != SUCCESS)
      return nRet;
   return SUCCESS;
}