Changeset 317 for GraphicTest/BGRABitmap/bgracompressablebitmap.pas

Timestamp:

Feb 1, 2012, 3:02:33 PM (13 years ago)

Author:

chronos

Message:

• Modified: Updated BGRABitmap package to version 5.5.
• Modified: Removed draw method ComboBox and reorganized method list to single listview with using ownerdraw facility.
• Added: New draw method TBitmap.RawImage.Data Move which use fast Move operation. It requires same pixel format.
• Added: New draw method Dummy for comparion of empty method and to determine possibily max frame rate limit.

Location:

GraphicTest/BGRABitmap

Files:

• . (modified) (1 prop)
• bgracompressablebitmap.pas (modified) (12 diffs)

GraphicTest/BGRABitmap/bgracompressablebitmap.pas

@@ -1 @@
-unit bgracompressablebitmap;
+unit BGRACompressableBitmap;
 
 {$mode objfpc}{$H+}
 
 interface
+
+{ This unit contains the TBGRACompressableBitmap class, which
+  can be used to temporarily compress bitmaps in memory.
+  To use it, create an instance with the bitmap you want
+  to compress. You can then free the original bitmap because
+  TBGRACompressableBitmap contains all information necessary
+  to build it again. To construct again your bitmap, call
+  the GetBitmap function.
+
+  When you have your bitmap in TBGRACompressableBitmap,
+  you can call Compress function as many times as necessary
+  until all data is compressed. It does only a part of the
+  work at each call, so you can put it in a loop or in
+  a timer. When it's done, Compress returns false to
+  notify that it did nothing, which means you can
+  stop calling Compress.
+
+  In this implementation, the memory usage grows during
+  the compression process and is lower only after it is
+  finished. So it is recommended to compress one bitmap
+  at a time. }
 
 uses
@@ -16 +37 @@
      FWidth,FHeight: integer;
      FCaption: String;
+     FBounds: TRect;
      FCompressedDataArray: array of TMemoryStream;
      FUncompressedData: TMemoryStream;
@@ -25 +47 @@
      constructor Create(Source: TBGRABitmap);
      function GetBitmap: TBGRABitmap;
-     function Compress: boolean;
+     
+     //call Compress as many times as necessary
+     //when it returns false, it means that
+     //the image compression is finished
+     function Compress: boolean; 
+     
      function UsedMemory: Int64;
      procedure Assign(Source: TBGRABitmap);
@@ -38 +65 @@
 uses zstream, BGRABitmapTypes;
 
-const maxPartSize = 1048576;
+// size of each chunk treated by Compress function
+const maxPartSize = 524288;
 
 { TBGRACompressedBitmap }
@@ -63 +91 @@
 end;
 
+{ Constructs the bitmap again, decompressing if necessary.
+  After this, the image is not compressed anymore so the
+  memoy usage grows again and the access becomes fast
+  because there is no need to decompress anymore. }
 function TBGRACompressableBitmap.GetBitmap: TBGRABitmap;
+var UsedPart: TBGRABitmap;
+    UsedNbPixels: Integer;
 begin
   Decompress;
@@ -74 +108 @@
   result.Caption := FCaption;
   FUncompressedData.Position := 0;
-  FUncompressedData.Read(result.Data^,result.NbPixels*Sizeof(TBGRAPixel));
-end;
-
+  if (FBounds.Left <> 0) or (FBounds.Top <> 0)
+    or (FBounds.Right <> FWidth) or (FBounds.Bottom <> FHeight) then
+  begin
+    UsedNbPixels := (FBounds.Right-FBounds.Left)*(FBounds.Bottom-FBounds.Top);
+    if UsedNbPixels > 0 then
+    begin
+      UsedPart := TBGRABitmap.Create(FBounds.Right-FBounds.Left,FBounds.Bottom-FBounds.Top);
+      FUncompressedData.Read(UsedPart.Data^,UsedPart.NbPixels*Sizeof(TBGRAPixel));
+      result.PutImage(FBounds.Left,FBounds.Top,UsedPart,dmSet);
+      UsedPart.Free;
+    end;
+  end else
+    FUncompressedData.Read(result.Data^,result.NbPixels*Sizeof(TBGRAPixel));
+end;
+
+{ Returns the total memory used by this object for storing bitmap data }
 function TBGRACompressableBitmap.UsedMemory: Int64;
 var i: integer;
@@ -86 +133 @@
 end;
 
+{ Do one compress step or return false }
 function TBGRACompressableBitmap.Compress: boolean;
 var comp: Tcompressionstream;
@@ -91 +139 @@
 begin
   if FCompressedDataArray = nil then FCompressionProgress := 0;
-  if FUncompressedData = nil then
+  if (FUncompressedData = nil) or (FUncompressedData.Size = 0) then
   begin
     result := false;
@@ -104 +152 @@
       partSize := maxPartSize else
         partSize := integer(FUncompressedData.Size - FCompressionProgress);
+
+    //use fast compression to avoid slowing down the application
     comp := Tcompressionstream.Create(clfastest,FCompressedDataArray[high(FCompressedDataArray)]);
     comp.write(partSize,sizeof(partSize));
@@ -136 +186 @@
 end;
 
+{ Free all data }
 procedure TBGRACompressableBitmap.FreeData;
 var i: integer;
@@ -148 +199 @@
 end;
 
+{ Copy a bitmap into this object. As it is copied, you need not
+  keep a copy of the source }
 procedure TBGRACompressableBitmap.Assign(Source: TBGRABitmap);
+var
+  UsedPart: TBGRABitmap;
+  NbUsedPixels: integer;
 begin
   FreeData;
@@ -161 +217 @@
   FHeight := Source.Height;
   FCaption := Source.Caption;
+  FBounds := Source.GetImageBounds([cRed,cGreen,cBlue,cAlpha]);
+  NbUsedPixels := (FBounds.Right-FBounds.Left)*(FBounds.Bottom-FBounds.Top);
   FUncompressedData := TMemoryStream.Create;
-  FUncompressedData.Write(Source.Data^,Source.NbPixels*Sizeof(TBGRAPixel));
+  if NbUsedPixels = 0 then exit;
+
+  if (FBounds.Left <> 0) or (FBounds.Top <> 0)
+    or (FBounds.Right <> Source.Width) or (FBounds.Bottom <> Source.Height) then
+  begin
+    UsedPart := Source.GetPart(FBounds) as TBGRABitmap;
+    FUncompressedData.Write(UsedPart.Data^,NbUsedPixels*Sizeof(TBGRAPixel));
+    UsedPart.Free;
+  end else
+    FUncompressedData.Write(Source.Data^,Source.NbPixels*Sizeof(TBGRAPixel));
 end;