Overloads Public Sub StartCompress( _
   ByVal width As Integer, _
   ByVal height As Integer, _
   ByVal bitsPerPixel As Integer, _
   ByVal order As RasterByteOrder, _
   ByVal viewPerspective As RasterViewPerspective, _
   ByVal inputDataLength As Integer, _
   ByVal outputData() As Byte, _
   ByVal outputDataIndex As Integer, _
   ByVal outputDataLength As Integer, _
   ByVal compression As CodecsCompression, _
   ByVal callback As CodecsCompressDataCallback _
) 

Dim instance As RasterCodecs
Dim width As Integer
Dim height As Integer
Dim bitsPerPixel As Integer
Dim order As RasterByteOrder
Dim viewPerspective As RasterViewPerspective
Dim inputDataLength As Integer
Dim outputData() As Byte
Dim outputDataIndex As Integer
Dim outputDataLength As Integer
Dim compression As CodecsCompression
Dim callback As CodecsCompressDataCallback
 
instance.StartCompress(width, height, bitsPerPixel, order, viewPerspective, inputDataLength, outputData, outputDataIndex, outputDataLength, compression, callback)

public void StartCompress( 
   int width,
   int height,
   int bitsPerPixel,
   RasterByteOrder order,
   RasterViewPerspective viewPerspective,
   int inputDataLength,
   byte[] outputData,
   int outputDataIndex,
   int outputDataLength,
   CodecsCompression compression,
   CodecsCompressDataCallback callback
)

public:
void StartCompress( 
   int width,
   int height,
   int bitsPerPixel,
   RasterByteOrder order,
   RasterViewPerspective viewPerspective,
   int inputDataLength,
   array<byte>^ outputData,
   int outputDataIndex,
   int outputDataLength,
   CodecsCompression compression,
   CodecsCompressDataCallback^ callback
) 

Public Sub CompressExample()
      Dim codecs As RasterCodecs = New RasterCodecs()

      Dim srcFileName As String = Path.Combine(LEAD_VARS.ImagesDir, "Image1.cmp")
      Dim destFileName As String = Path.Combine(LEAD_VARS.ImagesDir, "Image1_CompressData.cmp")

      ' Load the image to at 24-bits per pixel
      Dim image As RasterImage = codecs.Load(srcFileName, 24, CodecsLoadByteOrder.Bgr, 1, 1)
      If image.ViewPerspective <> RasterViewPerspective.TopLeft Then
         image.ChangeViewPerspective(RasterViewPerspective.TopLeft)
      End If

      ' Create the output file
      _compressStream = File.Create(destFileName)

      ' Calculate the bytes per line in the input buffer, without padding 
      Dim lineBytes As Integer = image.Width * 3

      ' Allocate a buffer for the incoming uncompressed data. Note that we
      '  are compressing 16 lines at a time. You should always use multiples of 16
      Dim inBuffer As Byte() = New Byte(16 * lineBytes - 1) {}

      ' Allocate an output buffer. This is where the compressed data will
      ' go.  Note that this allocates 1024-byte packets. 
      Dim outBuffer As Byte() = New Byte(1023) {}

      ' Lock down the image
      image.Access()

      ' Initialize the compression engine
      codecs.Options.Jpeg.Save.CmpQualityFactorPredefined = CodecsCmpQualityFactorPredefined.QualityAndSize
      codecs.StartCompress(image.Width, image.Height, image.BitsPerPixel, image.Order, image.ViewPerspective, 16 * lineBytes, outBuffer, 0, outBuffer.Length, CodecsCompression.Cmp, AddressOf MyCodecsCompressDataCallback)

      ' Compress the data
      Dim i As Integer = 0
      Do While i < image.Height ' i is incremented at the end
         ' Compression of the 16-line chunk starts here
         Dim j As Integer = 0
         Dim inBufferIndex As Integer = 0
         Do While (i + j) < image.Height AndAlso j < 16
            ' Get one line at time
            image.GetRow(i + j, inBuffer, inBufferIndex, lineBytes)

            ' Move to next line
            inBufferIndex += lineBytes

            j += 1
         Loop

         ' This is the main function that will do the actual Compression
         codecs.Compress(inBuffer, 0)
         i += 16
      Loop

      ' Reset the compression engine 
      codecs.StopCompress()

      ' Release the image and close the file
      image.Release()
      _compressStream.Close()

      ' Clean up
      codecs.Dispose()
   End Sub

   Private _compressStream As FileStream
   Private _compressBuffer As Byte()

   Private Function MyCodecsCompressDataCallback(ByVal width As Integer, ByVal height As Integer, ByVal bitsPerPixel As Integer, ByVal order As RasterByteOrder, ByVal viewPerspective As RasterViewPerspective, ByVal buffer As RasterNativeBuffer) As Boolean
      ' Write data to the file
      If _compressBuffer Is Nothing OrElse _compressBuffer.Length < buffer.Length Then
         _compressBuffer = New Byte(CType(buffer.Length, Integer) - 1) {}
      End If

      Marshal.Copy(buffer.Data, _compressBuffer, 0, CType(buffer.Length, Integer))

      _compressStream.Write(_compressBuffer, 0, CType(buffer.Length, Integer))

      Return True
   End Function

Public NotInheritable Class LEAD_VARS
   Public Const ImagesDir As String = "C:\Users\Public\Documents\LEADTOOLS Images"
End Class

public void CompressExample()
   {
      RasterCodecs codecs = new RasterCodecs();

      string srcFileName = Path.Combine(LEAD_VARS.ImagesDir, "Image1.cmp");
      string destFileName = Path.Combine(LEAD_VARS.ImagesDir, "Image1_CompressData.cmp");

      // Load the image to at 24-bits per pixel
      RasterImage image = codecs.Load(srcFileName, 24, CodecsLoadByteOrder.Bgr, 1, 1);
      if(image.ViewPerspective != RasterViewPerspective.TopLeft)
         image.ChangeViewPerspective(RasterViewPerspective.TopLeft);

      // Create the output file
      _compressStream = File.Create(destFileName);

      // Calculate the bytes per line in the input buffer, without padding 
      int lineBytes = image.Width * 3;

      // Allocate a buffer for the incoming uncompressed data. Note that we
      //  are compressing 16 lines at a time. You should always use multiples of 16
      byte[] inBuffer = new byte[16 * lineBytes];

      // Allocate an output buffer. This is where the compressed data will
      // go.  Note that this allocates 1024-byte packets. 
      byte[] outBuffer = new byte[1024];

      // Lock down the image
      image.Access();

      // Initialize the compression engine
      codecs.Options.Jpeg.Save.CmpQualityFactorPredefined = CodecsCmpQualityFactorPredefined.QualityAndSize;
      codecs.StartCompress(
         image.Width,
         image.Height,
         image.BitsPerPixel,
         image.Order,
         image.ViewPerspective,
         16 * lineBytes,
         outBuffer,
         0,
         outBuffer.Length,
         CodecsCompression.Cmp,
         MyCodecsCompressDataCallback);

      // Compress the data
      int i = 0;
      while(i < image.Height) // i is incremented at the end
      {
         // Compression of the 16-line chunk starts here
         int j = 0;
         int inBufferIndex = 0;
         while((i + j) < image.Height && j < 16)
         {
            // Get one line at time
            image.GetRow(i + j, inBuffer, inBufferIndex, lineBytes);

            // Move to next line
            inBufferIndex += lineBytes;

            j++;
         }

         // This is the main function that will do the actual Compression
         codecs.Compress(inBuffer, 0);
         i += 16;
      }

      // Reset the compression engine 
      codecs.StopCompress();

      // Release the image and close the file
      image.Release();
      _compressStream.Close();

      // Clean up
      codecs.Dispose();
   }

   FileStream _compressStream;
   byte[] _compressBuffer;

   bool MyCodecsCompressDataCallback(int width, int height, int bitsPerPixel, RasterByteOrder order, RasterViewPerspective viewPerspective, RasterNativeBuffer buffer)
   {
      // Write data to the file
      if(_compressBuffer == null || _compressBuffer.Length < buffer.Length)
         _compressBuffer = new byte[(int)buffer.Length];

      Marshal.Copy(buffer.Data, _compressBuffer, 0, (int)buffer.Length);

      _compressStream.Write(_compressBuffer, 0, (int)buffer.Length);

      return true;
   }

static class LEAD_VARS
{
   public const string ImagesDir = @"C:\Users\Public\Documents\LEADTOOLS Images";
}