TImage.CreateFromZip

Source/image/simba.image.pas

@@ -77,6 +77,7 @@   TSimbaImage = class(TSimbaBaseClass)
     constructor Create; overload;
     constructor Create(AWidth, AHeight: Integer); overload;
     constructor CreateFromFile(FileName: String);
+    constructor CreateFromZip(ZipFileName, ZipEntryName: String);
     constructor CreateFromString(Str: String);
     constructor CreateFromData(AWidth, AHeight: Integer; AData: PColorBGRA; ADataWidth: Integer);
     constructor CreateFromWindow(Window: TWindowHandle);
@@ -225,6 +226,7 @@   TSimbaImage = class(TSimbaBaseClass)
     function SaveToFile(FileName: String; OverwriteIfExists: Boolean = False): Boolean;
     function SaveToString: String;
 
+    procedure LoadFromStream(Stream: TStream; FileName: String);
     procedure LoadFromFile(FileName: String); overload;
     procedure LoadFromFile(FileName: String; Area: TBox); overload;
     procedure LoadFromString(Str: String);
@@ -247,12 +249,12 @@   TSimbaImage = class(TSimbaBaseClass)
 implementation
 
 uses
-  Math, FPImage, fpqoi_simba,
+  Math, FPImage, fpqoi_simba, Zipper,
   simba.arraybuffer, simba.geometry, simba.tpa, simba.algo_sort,
   simba.encoding, simba.compress,
   simba.nativeinterface, simba.singlematrix,
   simba.image_lazbridge, simba.image_integral, simba.image_gaussblur,
-  simba.image_bitmaparealoader, simba.image_utils;
+  simba.image_bitmaparealoader, simba.image_utils, simba.files;
 
 function TSimbaImage.SaveToFile(FileName: String; OverwriteIfExists: Boolean): Boolean;
 var
@@ -494,12 +496,23 @@ function TSimbaImage.SaveToString: String;
   try
     SimbaImage_ToFPImageWriter(Self, TFPWriterQoi, Stream);
 
-    Result := Header + Base64Encode(CompressString(Stream.DataString));
+    Result := Header + Base64Encode(ZCompressString(Stream.DataString));
   finally
     Stream.Free();
   end;
 end;
 
+procedure TSimbaImage.LoadFromStream(Stream: TStream; FileName: String);
+var
+  ReaderClass: TFPCustomImageReaderClass;
+begin
+  ReaderClass := TFPCustomImage.FindReaderFromFileName(FileName);
+  if (ReaderClass = nil) then
+    SimbaException('TSimbaImage.LoadFromStream: Unknown image format "%s"', [FileName]);
+
+  SimbaImage_FromFPImageReader(Self, ReaderClass, Stream);
+end;
+
 procedure TSimbaImage.LoadFromString(Str: String);
 const
   HEADER = 'IMG:';
@@ -510,7 +523,7 @@ procedure TSimbaImage.LoadFromString(Str: String);
     SimbaException('TImage.LoadFromString: Invalid string "' + Str + '"');
   Str := Str.After(HEADER);
 
-  Stream := TStringStream.Create(DecompressString(Base64Decode(Str)));
+  Stream := TStringStream.Create(ZDecompressString(Base64Decode(Str)));
   try
     SimbaImage_FromFPImageReader(Self, TFPReaderQoi, Stream);
   finally
@@ -2591,6 +2604,20 @@ constructor TSimbaImage.CreateFromFile(FileName: String);
   LoadFromFile(FileName);
 end;
 
+constructor TSimbaImage.CreateFromZip(ZipFileName, ZipEntryName: String);
+var
+  Stream: TMemoryStream;
+begin
+  Create();
+
+  if ZipExtractOne(ZipFileName, ZipEntryName, Stream) then
+  try
+    LoadFromStream(Stream, ZipEntryName);
+  finally
+    Stream.Free();
+  end;
+end;
+
 constructor TSimbaImage.CreateFromString(Str: String);
 begin
   Create();

Source/script/imports/simba.import_encoding.pas

@@ -145,7 +145,7 @@ procedure _LapeHMACSHA1(const Params: PParamArray; const Result: Pointer); LAPE_
 *)
 procedure _LapeBase64Encode(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
-  Pstring(Result)^ := Base64Encode(PString(Params^[0])^);
+  PString(Result)^ := Base64Encode(PString(Params^[0])^);
 end;
 
 (*
@@ -155,7 +155,7 @@ procedure _LapeBase64Encode(const Params: PParamArray; const Result: Pointer); L
 *)
 procedure _LapeBase64Decode(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
-  Pstring(Result)^ := Base64Decode(PString(Params^[0])^);
+  PString(Result)^ := Base64Decode(PString(Params^[0])^);
 end;
 
 (*
@@ -209,130 +209,90 @@ procedure _LapeGetOTPToken(const Params: PParamArray; const Result: Pointer); LA
 end;
 
 (*
-CompressString
-~~~~~~~~~~~~~~
-> function CompressString(S: String): String;
+ZCompressString
+~~~~~~~~~~~~~~~
+> function ZCompressString(S: String): String;
 *)
-procedure _LapeCompressString(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
+procedure _LapeZCompressString(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
-  Pstring(Result)^ := CompressString(PString(Params^[0])^);
+  PString(Result)^ := ZCompressString(PString(Params^[0])^);
 end;
 
 (*
-DecompressString
-~~~~~~~~~~~~~~~~
-> function DecompressString(S: String): String;
+ZDecompressString
+~~~~~~~~~~~~~~~~~
+> function ZDecompressString(S: String): String;
 *)
-procedure _LapeDecompressString(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
+procedure _LapeZDecompressString(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
-  Pstring(Result)^ := DecompressString(PString(Params^[0])^);
+  PString(Result)^ := ZDecompressString(PString(Params^[0])^);
 end;
 
 (*
-LZCompress
-~~~~~~~~~~
-> function LZCompress(Src: Pointer; Size: Integer; Dest: Pointer): Integer;
+SynLZCompress
+~~~~~~~~~~~~~
+> function SynLZCompress(Src: Pointer; Size: Integer; Dest: Pointer): Integer;
 *)
 procedure _LapeSynLZCompress(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
   PInteger(Result)^ := SynLZcompress1pas(PPAnsiChar(Params^[0])^, PInteger(Params^[1])^, PPAnsiChar(Params^[2])^);
 end;
 
 (*
-LZDecompress
-~~~~~~~~~~~~
-> function LZDecompress(Src: Pointer; Size: Integer; Dest: Pointer): Integer;
+SynLZDecompress
+~~~~~~~~~~~~~~~
+> function SynLZDecompress(Src: Pointer; Size: Integer; Dest: Pointer): Integer;
 *)
 procedure _LapeSynLZDecompress(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
   PInteger(Result)^ := SynLZdecompress1pas(PPAnsiChar(Params^[0])^, PInteger(Params^[1])^, PPAnsiChar(Params^[2])^);
 end;
 
 (*
-LZCompressDestLen
-~~~~~~~~~~~~~~~~~
-> function LZCompressDestLen(Len: Integer): Integer;
+SynLZCompressDestLen
+~~~~~~~~~~~~~~~~~~~~
+> function SynLZCompressDestLen(Len: Integer): Integer;
 *)
 procedure _LapeSynLZCompressDestLen(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
   PInteger(Result)^ := SynLZcompressdestlen(PInteger(Params^[0])^);
 end;
 
 (*
-LZDecompressDestLen
-~~~~~~~~~~~~~~~~~~~
-> function LZDecompressDestLen(Src: Pointer): Integer;
+SynLZDecompressDestLen
+~~~~~~~~~~~~~~~~~~~~~~
+> function SynLZDecompressDestLen(Src: Pointer): Integer;
 *)
 procedure _LapeSynLZDecompressDestLen(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
   PInteger(Result)^ := SynLZdecompressdestlen(PPAnsiChar(Params^[0])^);
 end;
 
-(*
-TLZCompressionThread.Create
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-> function TLZCompressionThread.Create: TLZCompressionThread; static;
-*)
 procedure _LapeLZCompressionThread_Create(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
   PLZCompressionThread(Result)^ := TLZCompressionThread.Create();
 end;
 
-(*
-TLZCompressionThread.Free
-~~~~~~~~~~~~~~~~~~~~~~~~~
-> procedure TLZCompressionThread.Free;
-*)
-procedure _LapeLZCompressionThread_Free(const Params: PParamArray); LAPE_WRAPPER_CALLING_CONV
-begin
-  PLZCompressionThread(Params^[0])^.Free();
-end;
-
-(*
-TLZCompressionThread.Write
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-> procedure TLZCompressionThread.Write(constref Data; DataSize: Integer);
-*)
 procedure _LapeLZCompressionThread_Write(const Params: PParamArray); LAPE_WRAPPER_CALLING_CONV
 begin
   PLZCompressionThread(Params^[0])^.Write(PPointer(Params^[1])^, PInteger(Params^[2])^);
 end;
 
-(*
-TLZCompressionThread.WaitCompressing
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-> procedure TLZCompressionThread.WaitCompressing;
-*)
 procedure _LapeLZCompressionThread_WaitCompressing(const Params: PParamArray); LAPE_WRAPPER_CALLING_CONV
 begin
   PLZCompressionThread(Params^[0])^.WaitCompressing();
 end;
 
-(*
-TLZCompressionThread.IsCompressing
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-> function TLZCompressionThread.IsCompressing: Boolean;
-*)
 procedure _LapeLZCompressionThread_IsCompressing(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
   PBoolean(Result)^ := PLZCompressionThread(Params^[0])^.IsCompressing;
 end;
 
-(*
-TLZCompressionThread.GetOnCompressed
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-> function TLZCompressionThread.GetOnCompressed: TLZCompressedEvent;
-*)
 procedure _LapeLZCompressionThreadOnCompressed_Read(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
   PLZCompressedEvent(Result)^ := PLZCompressionThread(Params^[0])^.OnCompressed;
 end;
 
-(*
-TLZCompressionThread.SetOnCompressed
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-> procedure TLZCompressionThread.SetOnCompressed(Value: TLZCompressedEvent);
-*)
 procedure _LapeLZCompressionThreadOnCompressed_Write(const Params: PParamArray); LAPE_WRAPPER_CALLING_CONV
 begin
   PLZCompressionThread(Params^[0])^.OnCompressed := PLZCompressedEvent(Params^[1])^;
@@ -363,26 +323,24 @@ procedure ImportEncoding(Compiler: TSimbaScript_Compiler);
     addGlobalFunc('function HMACMD5(const Key, Message: String): String', @_LapeHMACMD5);
     addGlobalFunc('function HMACSHA1(const Key, Message: String): String', @_LapeHMACSHA1);
 
-    addGlobalFunc('function CompressString(S: String): String', @_LapeCompressString);
-    addGlobalFunc('function DecompressString(S: String): String', @_LapeDecompressString);
+    addGlobalFunc('function ZCompressString(S: String): String', @_LapeZCompressString);
+    addGlobalFunc('function ZDecompressString(S: String): String', @_LapeZDecompressString);
 
-    addGlobalFunc('function LZCompressDestLen(Len: Integer): Integer', @_LapeSynLZCompressDestLen);
-    addGlobalFunc('function LZDecompressDestLen(Src: Pointer): Integer', @_LapeSynLZDecompressDestLen);
-    addGlobalFunc('function LZCompress(Src: Pointer; Size: Integer; Dest: Pointer): Integer', @_LapeSynLZCompress);
-    addGlobalFunc('function LZDecompress(Src: Pointer; Size: Integer; Dest: Pointer): Integer', @_LapeSynLZDecompress);
-
-    addGlobalType('type Pointer', 'TLZCompressionThread');
-    addGlobalType('procedure(Sender: TLZCompressionThread; Data: Pointer; DataSize: Integer; TimeUsed: Double) of object', 'TLZCompressedEvent', FFI_DEFAULT_ABI);
-
-    addGlobalFunc('function TLZCompressionThread.Create: TLZCompressionThread; static', @_LapeLZCompressionThread_Create);
-    addGlobalFunc('procedure TLZCompressionThread.Free;', @_LapeLZCompressionThread_Free);
-    addGlobalFunc('procedure TLZCompressionThread.Write(constref Data; DataSize: Integer)', @_LapeLZCompressionThread_Write);
-    addGlobalFunc('procedure TLZCompressionThread.WaitCompressing', @_LapeLZCompressionThread_WaitCompressing);
-    addGlobalFunc('procedure TLZCompressionThread.SetOnCompressed(Value: TLZCompressedEvent)', @_LapeLZCompressionThreadOnCompressed_Write);
-    addGlobalFunc('function TLZCompressionThread.GetOnCompressed: TLZCompressedEvent', @_LapeLZCompressionThreadOnCompressed_Read);
-    addGlobalFunc('function TLZCompressionThread.IsCompressing: Boolean', @_LapeLZCompressionThread_IsCompressing);
+    addGlobalFunc('function SynLZCompressDestLen(Len: Integer): Integer', @_LapeSynLZCompressDestLen);
+    addGlobalFunc('function SynLZDecompressDestLen(Src: Pointer): Integer', @_LapeSynLZDecompressDestLen);
+    addGlobalFunc('function SynLZCompress(Src: Pointer; Size: Integer; Dest: Pointer): Integer', @_LapeSynLZCompress);
+    addGlobalFunc('function SynLZDecompress(Src: Pointer; Size: Integer; Dest: Pointer): Integer', @_LapeSynLZDecompress);
 
     ImportingSection := '';
+
+    addClass('TSynLZThread');
+    addClassConstructor('TSynLZThread', '', @_LapeLZCompressionThread_Create);
+    addGlobalType('procedure(Sender: TSynLZThread; Data: Pointer; DataSize: Integer; TimeUsed: Double) of object', 'TSynLZCompressedEvent', FFI_DEFAULT_ABI);
+    addGlobalFunc('procedure TSynLZThread.Write(constref Data; DataSize: Integer)', @_LapeLZCompressionThread_Write);
+    addGlobalFunc('procedure TSynLZThread.WaitCompressing', @_LapeLZCompressionThread_WaitCompressing);
+    addGlobalFunc('procedure TSynLZThread.SetOnCompressed(Value: TSynLZCompressedEvent)', @_LapeLZCompressionThreadOnCompressed_Write);
+    addGlobalFunc('function TSynLZThread.GetOnCompressed: TSynLZCompressedEvent', @_LapeLZCompressionThreadOnCompressed_Read);
+    addGlobalFunc('function TSynLZThread.IsCompressing: Boolean', @_LapeLZCompressionThread_IsCompressing);
   end;
 end;
 

Source/script/imports/simba.import_image.pas

@@ -1167,6 +1167,18 @@ procedure _LapeImage_CreateFromString(const Params: PParamArray; const Result: P
   PSimbaImage(Result)^ := TSimbaImage.CreateFromString(PString(Params^[0])^);
 end;
 
+(*
+TImage.CreateFromZip
+~~~~~~~~~~~~~~~~~~~~
+> function TImage.CreateFromZip(ZipFileName, ZipEntryName: String): TImage; static;
+
+Load an image from a file inside a zip file.
+*)
+procedure _LapeImage_CreateFromZip(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
+begin
+  PSimbaImage(Result)^ := TSimbaImage.CreateFromZip(PString(Params^[0])^, PString(Params^[1])^);
+end;
+
 (*
 TImage.Compare
 ~~~~~~~~~~~~~~
@@ -1364,8 +1376,9 @@ procedure ImportSimbaImage(Compiler: TSimbaScript_Compiler);
 
     addGlobalFunc('function TImage.Create: TImage; static; overload', @_LapeImage_Create);
     addGlobalFunc('function TImage.Create(Width, Height: Integer): TImage; static; overload', @_LapeImage_CreateEx);
-    addGlobalFunc('function TImage.CreateFromFile(FileName: String): TImage; static; overload', @_LapeImage_CreateFromFile);
-    addGlobalFunc('function TImage.CreateFromString(Str: String): TImage; static; overload', @_LapeImage_CreateFromString);
+    addGlobalFunc('function TImage.CreateFromFile(FileName: String): TImage; static', @_LapeImage_CreateFromFile);
+    addGlobalFunc('function TImage.CreateFromString(Str: String): TImage; static', @_LapeImage_CreateFromString);
+    addGlobalFunc('function TImage.CreateFromZip(ZipFileName, ZipEntryName: String): TImage; static', @_LapeImage_CreateFromZip);
 
     addGlobalFunc('function TImage.Equals(Other: TImage): Boolean;', @_LapeImage_Equals);
 

Source/script/imports/simba.import_misc.pas

@@ -82,7 +82,7 @@ procedure _LapeStopSound(const Params: PParamArray); LAPE_WRAPPER_CALLING_CONV
 *)
 procedure _LapeSimba(const Params: PParamArray); LAPE_WRAPPER_CALLING_CONV
 begin
-  WriteLn(DecompressString(Base64Decode(
+  WriteLn(ZDecompressString(Base64Decode(
     '9AoAAHicldU7b+0gDADgvdL9D+AisSDOTrpUvWvGuzNVOkMn9v72a942j6T1dJrEX7AxqRAXYaS9up3iz8suVxoMKe+' +
     'NC6LGnbEhiCCfTzPfJ5cmgidj5J9MsezSQAyApGHGR17N9SpGoBj1tkuRkJHoAk3WeMfTC66GWbaTFtMAwZDPRjh73U4uCKGnRTh3NMK0mAjiXxA975iERASl' +
     'QjfcRLBVS963TKCQDb0m8Brwwv1IKAWkErcipPNAC5+JdPmY62hE/O3L8yE+T4k4PpGwi2aiEIn25zcqKMQ1a6bgNtGN4kJqJ1tYeqFwrMNDcCFvKjMsWXLOK' +

Source/simba.compress.pas

@@ -35,16 +35,16 @@   TLZCompressionThread = class(TSimbaBaseClass)
     property IsCompressing: Boolean read GetIsCompressing;
   end;
 
-function CompressString(const Str: String): String;
-function DecompressString(const Str: String) : String;
+function ZCompressString(const Str: String): String;
+function ZDecompressString(const Str: String) : String;
 
 implementation
 
 uses
   zstream,
   simba.datetime;
 
-function CompressString(const Str: String): String;
+function ZCompressString(const Str: String): String;
 var
   Len: Integer;
   Output: TMemoryStream;
@@ -78,7 +78,7 @@ function CompressString(const Str: String): String;
     Output.Free();
 end;
 
-function DecompressString(const Str: String): String;
+function ZDecompressString(const Str: String): String;
 var
   Input: TStringStream;
   Stream: TDeCompressionStream;

Source/simba.dtm.pas

@@ -57,7 +57,7 @@ procedure TDTM.FromString(Str: String);
   if not Str.StartsWith('DTM:', True) then
     raise Exception.Create('TDTM.FromString: Invalid string "' + Str + '"');
 
-  Stream := TStringStream.Create(DecompressString(Base64Decode(Str.After('DTM:'))));
+  Stream := TStringStream.Create(ZDecompressString(Base64Decode(Str.After('DTM:'))));
 
   SetLength(Points, Stream.ReadDWord());
   for I := 0 to High(Points) do
@@ -103,7 +103,7 @@ function TDTM.ToString: String;
   for I := 0 to High(Points) do
     Stream.WriteDWord(Points[I].AreaSize);
 
-  Result := 'DTM:' + Base64Encode(CompressString(Stream.DataString));
+  Result := 'DTM:' + Base64Encode(ZCompressString(Stream.DataString));
 
   Stream.Free();
 end;