Leadtools.Codecs Namespace > Classes > RasterCodecs > Methods > StartCompress Method > StartCompress(Int32,Int32,Int32,RasterByteOrder,RasterViewPerspective,Int32,Byte[],Int32,Int32,CodecsCompression,CodecsCompressDataCallback) Method

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

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

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

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

 function Leadtools.Codecs.RasterCodecs.StartCompress(Int32,Int32,Int32,RasterByteOrder,RasterViewPerspective,Int32,Byte[],Int32,Int32,CodecsCompression,CodecsCompressDataCallback)(  
   width , 
   height , 
   bitsPerPixel , 
   order , 
   viewPerspective , 
   inputDataLength , 
   outputData , 
   outputDataIndex , 
   outputDataLength , 
   compression , 
   callback  
) 

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

using Leadtools; 
using Leadtools.Codecs; 
using Leadtools.ImageProcessing; 
using Leadtools.ImageProcessing.Color; 
using Leadtools.Svg; 
using LeadtoolsExamples.Common; 
 
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"; 
} 

Imports Leadtools 
Imports Leadtools.Codecs 
Imports Leadtools.ImageProcessing 
Imports Leadtools.ImageProcessing.Color 
Imports Leadtools.Drawing 
Imports Leadtools.Svg 
 
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 

Products | Support | Contact Us | Copyright Notices
© 1991-2017 LEAD Technologies, Inc. All Rights Reserved.

Leadtools.Codecs Assembly