mORMot Open Source

Reporting a possible issue: I'm getting an exception "ZIP format." with a very specific zip file, after calling

TZipRead.Create(zip)

it triggers here in SynZip.pas

  for i := 0 to 127 do begin // resources size may be rounded up to alignment
    lhr := @BufZip[Size-sizeof(TLastHeader)];
    if lhr^.signature+1=(LASTHEADER_SIGNATURE+1) then
      break;
    dec(Size);
    if Size<=sizeof(lhr^) then
      break;
  end;
  if lhr^.signature+1<>(LASTHEADER_SIGNATURE+1) then begin
    UnMap;
    raise ESynZipException.Create('ZIP format');
  end;

The file opens fine with winrar and 7zip, and if I make a new file with the contents (unpack and repack with winrar), it works fine as well with SynZip

That works great, didn't see the overloads somehow, thanks.

ps: does the board support watching threads? it would be nice to be able to receive email notifications of replies.

Found an ever faster one than all those: the latest libjpeg from this jp guy:
http://cetus.sakura.ne.jp/softlab/jpeg- … html#win32

SynGDIPlus: 981 ms
XE6 jpeg: 5486 ms
Intel JIL: 2912 ms
SSE2 JpegDecoder: 873 ms
JpegTurbo: 766 ms

SSE2 JpegDecoder: 871 ms
SSE2 JpegDecoder: 888 ms
SSE2 JpegDecoder: 889 ms
JpegTurbo: 765 ms
JpegTurbo: 763 ms
JpegTurbo: 761 ms

For smaller files it seems your SSE2 one is still faster though, probably less stuff to init etc.

ps: no way to subscribe to thread replies?

~edit

this is the culprit of the slowdown, the way it converts the jpeg into a bitmap after decompression, slower than the decoding

  // reading image
  jpeg_start_decompress(@jpeg);

  // allocate row
  GetMem(prow, jpeg.output_width * 3);

  Inherited SetSize(jpeg.output_width, jpeg.output_height);
  Inherited PixelFormat := pf24bit;
  For y := 0 To jpeg.output_height - 1 Do
  Begin
    // reading row
   jpeg_read_scanlines(@jpeg, @prow, 1);
   rowD := scanline[y];
    For x := 0 To jpeg.output_width - 1 Do
    Begin
      rowD[x].RgbtRed   := prow[x].rgbtBlue;
      rowD[x].rgbtGreen := prow[x].rgbtGreen;
      rowD[x].rgbtBlue  := prow[x].RgbtRed;
    End;
    // do anything with the data
  End;
  // freeing row
  FreeMem(prow);

Thanks that's ok, speedup makes up for larger files. I've started changing all my apps that used jpeg/pngimage to GDIPlus after these tests today (except for 32-bit only apps that mostly load jpeg, will keep using the SSE2 one there)

Interesting fact:

32-bit load:
SynGDIPlus: 1021 ms
XE6 jpeg: 5626 ms

64-bit load:
SynGDIPlus: 867 ms
XE6 jpeg: 2745 ms

--

32-bit save:
GDIPlus PNG: 1561 ms
XE6 PNG: 3293 ms

64-bit save:
GDIPlus PNG: 1736 ms
XE6 PNG: 4059 ms

Saving PNG seems also much faster, however file size is bigger

1622 x 976

GDIPlus PNG: 123 ms 3.32 MB
GDIPlus PNG: 125 ms
XE6 PNG: 480 ms 2.34 MB
XE6 PNG: 484 ms

GDI

Delphi

12919 x 4719

GDIPlus PNG: 6510 ms
GDIPlus PNG: 6612 ms
XE6 PNG: 44193 ms
XE6 PNG: 44436 ms

GDI 103 MB
Delphi 64 MB

GDI

Delphi

Saving with Jpeg 100%

SynGDIPlus: 1298 ms
SynGDIPlus: 1283 ms
XE6 jpeg: 5576 ms
XE6 jpeg: 5623 ms

GDI 22,4 MB
XE6 25,2 MB oO

Jpeg 85%

SynGDIPlus: 906 ms
SynGDIPlus: 896 ms
XE6 jpeg: 5573 ms
XE6 jpeg: 5639 ms

Same results with SynPicture which is basically the same

     k: TSynPicture;
begin
//  p := SynGDIPlus.TPNGImage.Create;
k := TSynPicture.Create;
  PerfTimerInit;
k.LoadFromFile('z:\bigjpeg.png');
//  p.LoadFromFile('z:\bigjpeg.png');
  b := k.ToBitmap;
  x := PerfTimerStopMS;
  k.Free;
  b.Free;
  Memo1.Lines.Add('GDIPlus PNG: '+IntToStr(x)+' ms');
end;

= 0ms and empty bitmap

Well I guess the GDI one is not THAT much slower than the SSE2, but why use it vs a faster decoder

I always use a failsafe in case the jpeg type isn't supported anyway. Guess I'll change that to use GDI version when it fails (would rather not include the extra DLLs for libjpegturbo).

Seeing that it's so fast, I thought maybe further optimizations are possible with later extensions.

function FastJpegFileToBitmap(fle: string): Graphics.TBitmap;
Var PJ: PJpegDecode;
     j: TJpegImage;
     m: TMemoryStream;
     err: TJpegDecodeError;
begin
  Result := nil;

  m := TMemoryStream.Create;
  With m do begin
    Try
      LoadFromFile(fle);
    Except
      m.Free;
      Exit;
    End;
    try
      Err := jpegdec.JpegDecode(Memory,Size,PJ);
    except
      On E:Exception
       do ShowMessage('JpegDecode Error: '+fle+' / '+e.Message);
    end;
    if Err <> JPEG_SUCCESS then begin
      m.Free;
      PJ^.Free;
      // use default
      j := TJPEGImage.Create;
      j.Performance := jpBestSpeed;
      try
        Result := Graphics.TBitmap.Create;
        j.LoadFromFile(fle);
        With Result do begin
          Height := j.Height;
          Width  := j.Width;
          Assign(j);
        end;
      except
        FreeAndNil(Result);
        FreeAndNil(j);
        Exit;
      end;
      FreeAndNil(j);
      Exit;
    end;
    // SSE Jpeg success
    Result := PJ^.ToBitmap;
    PJ^.Free;
  end;
  m.Free;
end;

711x400 jpeg

SynGDIPlus: 6 ms
XE6 jpeg: 28 ms
Intel JIL: 12 ms
SSE2 JpegDecoder: 3 ms

SynGDIPlus: 5 ms
XE6 jpeg: 21 ms
Intel JIL: 16 ms
SSE2 JpegDecoder: 3 ms

SynGDIPlus: 6 ms
XE6 jpeg: 35 ms
Intel JIL: 20 ms
SSE2 JpegDecoder: 3 ms