Bitmap zeichen (gehts noch schneller?)

[Amateurprofi]

Mit den in der untenstehenden Test-Prozedur enthaltenen Prozeduren DrawBitmap und DrawGPBitmap zeichne ich eine Bitmap auf den Canvas einer maximierten Form.
Größe der Bitmap : 4000 x 3000 Pixel
Größe des Canvass : 1920 x 1000 Pixel

Meine Erwartung war, das das mit der GPBitmap (TGPGraphics.DrawImage) schneller geht als mit DrawBitmap (StretchBlt).

Ich habe folgende Zeiten gemessen, jeweils für 100 maliges Zeichnen:

DrawBitmap : 234 ms.
DrawGPBitmap: 31809 ms, also knapp 136 mal so lange.

Da ich mir kaum vorstellen kann, dass das DrawImage (immerhin GDI+) so viel langsamer ist, als das StretchBlt, vermute ich, dass ich irgend etwas verkehrt mache.

Weiß jemand, wie man eine GPBitmap schnell ausgibt?

Das Bild kann hier [URL="https://commons.wikimedia.org/w/index.php?curid=6558322"] heruntergeladen werden.

Delphi-Quellcode:

PROCEDURE TMain.Test;
//------------------------------------------------------------------------------
FUNCTION DrawBitmap(const Dsn:String; Count:Integer):Cardinal;
var I,W,H:Integer; Image:TGPImage; Graphics:TGPGraphics; Bmp:TBitmap;
begin
   Bmp:=TBitmap.Create;
   Image:=TGPImage.Create(Dsn);
   W:=Image.GetWidth;
   H:=Image.GetHeight;
   Bmp.SetSize(W,H);
   Graphics:=TGPGraphics.Create(Bmp.Canvas.Handle);
   Graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
   Graphics.DrawImage(Image,MakeRect(0,0,W,H));
   Graphics.Free;
   Image.Free;
   Result:=GetTickCount;
   for I:=1 to Count do begin
      SetStretchBltMode(Canvas.Handle,COLORONCOLOR);
      SetBrushOrgEx(Canvas.Handle,0,0,nil);
      StretchBlt(Canvas.Handle,0,0,ClientWidth,ClientHeight,
                 Bmp.Canvas.Handle,0,0,Bmp.Width,Bmp.Height,SrcCopy);
   end;
   Result:=GetTickCount-Result;
   Bmp.Free
end;
//------------------------------------------------------------------------------
FUNCTION DrawGPBitmap(const Dsn:String; Count:Integer):Cardinal;
var I:Integer; Image:TGPBitmap; Graphics:TGPGraphics;
begin
   Image:=TGPBitmap.Create(Dsn);
   Result:=GetTickCount;
   for I:=1 to Count do begin
      Graphics:=TGPGraphics.Create(Canvas.Handle);
      Graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
      Graphics.DrawImage(Image,MakeRect(0,0,ClientWidth,ClientHeight));
      Graphics.Free;
   end;
   Result:=GetTickCount-Result;
   Image.Free;
end;
//------------------------------------------------------------------------------
// https://commons.wikimedia.org/w/index.php?curid=6558322
const Dsn='E:\Daten\DownLoads\PfauVonVorne.jpg';
var T1,T2:Cardinal;
begin
   T1:=DrawBitmap(Dsn,100);
   T2:=DrawGPBitmap(Dsn,100);
   ShowMessage(IntToStr(T1)+#13+IntToStr(T2));
// Ausgabe
//   DrawBitmap              234 ms  bei 100 Durchläufen
//   DrawGPBitmap          31809 ms  bei 100 Durchläufen
end;

[TiGü]

Mach doch mal das erzeugen und freigeben des Bildes außerhalb der Schleife. Und der Rückgabewert von makerect kann man auch vorher holen und zwischenspeichern.

[Progman]

Canvas verfügt doch selbst über die Methoden Draw, StretchDraw u.a.
Warum nicht gleich direkt zeichnen ohne den Umweg über das Bitmap?

[Memnarch]

BitBlt, StretchBlt und andere Funktionen der GDI-Lib sind Hardwarebeschleunigt(XP, Vista Nicht, ab W7 wieder). GDI+ ist es nicht.
GDIP hat außerdem bessere interpolationen, die brauchen aber auch mehr cpu.

Wobei zugegeben 136 mal langsamer schon komisch aussieht.

Konnte nur noch diesen Artikel wiederfinden. Den wo GDI+ als nicht HW-beschleunigt genannt wird, nicht
https://msdn.microsoft.com/en-us/lib...=vs.85%29.aspx

PS: Wäre natürlich gut zu wissen unter welchem OS du bist. Ab W8 wurde dass ja schonwieder geändert.

[Amateurprofi]

Zitat von TiGü:

Mach doch mal das erzeugen und freigeben des Bildes außerhalb der Schleife. Und der Rückgabewert von makerect kann man auch vorher holen und zwischenspeichern.

Das MakeRect dauert etwa 1.1 MicroSekunden, beeinflußt also das Ergebnis kaum.

Zudem geht es ja nicht darum 100 Mal das gleiche hintereinander zu zeichnen sondern darum entweder ein TBitmap oder ein TGPBitmap zu zeichnen. Zu diesem Zeichnen gehört nun mal auch das MakeRect.
Dass ich hie das Zeichnen 100 mal wiederhole ist nur, damit die Messung per GetTickCount verwertbar ist.

Unter diesem Gesichtspunkt wäre ein separates MakeRect also eher schädlich, allerdings auch nur unwesentlich.

Und was meinst du mit "erzeugen und freigeben des Bildes außerhalb der Schleife" ?
Die Bitmaps werden doch außerhalb der Schleife erzeugt und freigegeben.
Falls du damit das TGPGraphics.Create / und Free meinst, gilt ähnliches wie für MakeRect.

Trotzdem Danke für Deinen Input.

[Amateurprofi]

Zitat von Progman:

Canvas verfügt doch selbst über die Methoden Draw, StretchDraw u.a.
Warum nicht gleich direkt zeichnen ohne den Umweg über das Bitmap?

Verstehe ich nicht.
Canvas.StretchDraw braucht doch eine Info, WAS gezeichnet werden soll, in diesem Fall eben das Bitmap.

Oder meinst du die TGPGraphic mit Canvas.StretchDraw zu zeichnen?
Das geht leider nicht.

[Amateurprofi]

Zitat von Memnarch:

BitBlt, StretchBlt und andere Funktionen der GDI-Lib sind Hardwarebeschleunigt(XP, Vista Nicht, ab W7 wieder). GDI+ ist es nicht.
GDIP hat außerdem bessere interpolationen, die brauchen aber auch mehr cpu.

Wobei zugegeben 136 mal langsamer schon komisch aussieht.

Konnte nur noch diesen Artikel wiederfinden. Den wo GDI+ als nicht HW-beschleunigt genannt wird, nicht
https://msdn.microsoft.com/en-us/lib...=vs.85%29.aspx

PS: Wäre natürlich gut zu wissen unter welchem OS du bist. Ab W8 wurde dass ja schonwieder geändert.

Danke Memnarch,
Das wusste ich bisher nicht.
Aber einen offensichtlichen Fehler in meinem Code, der das langsame Zeichnen verursacht siehst du auch nicht, oder?
Siehst du denn eine Möglichkeit aus einer TGPBitmap SCHNELL eine TBitmap zu machen?
Wie ich das bisher mache siehst du in der Prozedur DrawBitmap.

Mein OS ist übrigens Win 7 Prof.

[Memnarch]

Um überhaupt vergleichen zu können, würde ich erstmal die interpolationen in TGPGraphic abstellen. Dann die Frage warum überhaupt GDI+? Wenn du ein so hochauflösendes Bild hast, kannst du nicht auch SetStretchBLTMode HalfTone zum runterskalieren nehmen?

Benutz ich z.B. in meinem AsciiImage:
TGDIRenderContext.EndScene(Zeile 135)

Und so schauts aus:
AsciiImage for Delphi: GDI-Downsampling, FireMonkey and more!

EDIT: Vergiss nicht, dass du da bei GDI+ mitunter unsäglich viel konvertierst(Kann dir auch bei GDI passieren). Wenn die Pixel-Formate zwischen Source und Target nicht gleich sind, wird die source immer konvertiert beim Zeichnen! IIRC solltest du am besten mit 32bit Grafiken arbeiten.

[Amateurprofi]

Zitat von Memnarch:

Um überhaupt vergleichen zu können, würde ich erstmal die interpolationen in TGPGraphic abstellen. Dann die Frage warum überhaupt GDI+? Wenn du ein so hochauflösendes Bild hast, kannst du nicht auch SetStretchBLTMode HalfTone zum runterskalieren nehmen?

Benutz ich z.B. in meinem AsciiImage:
TGDIRenderContext.EndScene(Zeile 135)

Und so schauts aus:
AsciiImage for Delphi: GDI-Downsampling, FireMonkey and more!

EDIT: Vergiss nicht, dass du da bei GDI+ mitunter unsäglich viel konvertierst(Kann dir auch bei GDI passieren). Wenn die Pixel-Formate zwischen Source und Target nicht gleich sind, wird die source immer konvertiert beim Zeichnen! IIRC solltest du am besten mit 32bit Grafiken arbeiten.

zu: "würde ich erstmal die interpolationen in TGPGraphic abstellen"
ich hab alle Modi probiert:
InterpolationModeInvalid 270 ms
InterpolationModeDefault 270 ms
InterpolationModeLowQuality 270 ms
InterpolationModeHighQuality 325 ms
InterpolationModeBilinear 270 ms
InterpolationModeBicubic 620 ms
InterpolationModeNearestNeighbor 180 ms
InterpolationModeHighQualityBilinear 370 ms
InterpolationModeHighQualityBicubic 320 MS
Alle Zeiten für einmal zeichnen.
Dagegen StretchBlt 2 ms
Bringt also die benötigte Zeit nicht einmal ansatzweise in die Zeit für StretchBlt.

Und warum bin ich so spitz auf TGPBitmap bin, statt TBitmap?
Das Bild liegt idR als .jpg vor, kann aber auch als .png oder .tif oder .bmp sein.

Bisher habe ich z.B. .jpg entsprechend der untenstehenden "LoadBmpViaJPEG" geladen.
Zur Zeit benutze ich die untenstehende "LoadBmpViaGPBitmap"
Und dann hab ich die untenstehende "LoadGPBitmap" getestet.
Die jeweils benötigten Zeiten:
"LoadBmpViaJPEG" : 970 ms
"LoadBmpViaGPBitmap" 270 ms
"LoadGPBitmap" 319 µs

Da ich das Bild nur ausgeben kann, wenn ich es vorher lade, drängt sich das laden in eine TGPBitmap förmlich auf.
Deshalb möchte auch bei allem was folgt am liebsten mit TGPBitmap weitermachen.

Delphi-Quellcode:

FUNCTION LoadBmpViaJPEG(const Dsn:String):Int64;
var Jpg:TJpegImage; Bmp:TBitmap;
begin
   Result:=TimeStamp;
   Jpg:=TJPEGImage.Create;
   Bmp:=TBitmap.Create;
   Jpg.LoadFromFile(Dsn);
   Bmp.Assign(Jpg);
   Jpg.Free;
   Result:=TimeStamp-Result;
   Bmp.Free;
end;

Delphi-Quellcode:

FUNCTION LoadBmpViaGPBitmap(const Dsn:String):Int64;
var W,H:Integer; Image:TGPBitmap; Graphics:TGPGraphics; Bmp:TBitmap;
begin
   Result:=TimeStamp;
   Bmp:=TBitmap.Create;
   Image:=TGPBitmap.Create(Dsn);
   W:=Image.GetWidth;
   H:=Image.GetHeight;
   Bmp.SetSize(W,H);
   Graphics:=TGPGraphics.Create(Bmp.Canvas.Handle);
   Graphics.SetInterpolationMode(InterpolationModeHighQualityBicubic);
   Graphics.DrawImage(Image,MakeRect(0,0,W,H));
   Graphics.Free;
   Image.Free;
   Result:=TimeStamp-Result;
   Bmp.Free;
end;

Delphi-Quellcode:

FUNCTION LoadGPBitmap(const Dsn:String):Int64;
var I:Integer; Image:TGPBitmap;
begin
   Result:=TimeStamp;
   Image:=TGPBitmap.Create(Dsn);
   Result:=TimeStamp-Result;
   Image.Free;
end;

Zur Vollständigkeit:

Delphi-Quellcode:

FUNCTION TimeStamp:Int64;
asm
   rdtsc
   {$IFDEF CPUX64}
   shl   rdx,32
   or    rax,rdx
   {$ENDIF}
end;

[TiGü]

Zitat von Amateurprofi:

Da ich das Bild nur ausgeben kann, wenn ich es vorher lade, drängt sich das laden in eine TGPBitmap förmlich auf.

Wenn es dir einzig und allein darum geht, verschiedene Grafik-Formate zu laden und du sonst nichts mit der GDI+-Biblothek machst, kannst du auch Vcl.Graphics.TWicImage nehmen.

Siehe hier:
http://www.tek-tips.com/faqs.cfm?fid=7568