Prüfung eines Bitmaps auf Transparenz (gehts noch schneller)?

[Neutral General]

Hallo,

Ich habe mal ne (Teil-)Assemblerversion gebaut:

Delphi-Quellcode:

function HasTransparentRGBAValues(const bmp: TBitmap): Boolean;
label schleife, ende, hasTrans;
var z: Integer; RGBA: PRGBQuad;
begin
  Result := false;
  RGBA := bmp.Scanline[bmp.Height-1];
  z := bmp.Width * bmp.Height;
  asm
    mov esi, rgba
    mov ecx, z
schleife:
    lodsd
    shr eax, 24
    inc al
    jnz hasTrans
    loop schleife
    jmp ende
hasTrans:
    mov result, true
ende:
  end;
end;

Ich habs nicht mit anderen Lösungen verglichen. Müsste man mal ausprobieren.
Ist in der Form nicht für 64-Bit geeignet, das wäre ein Stück mehr Arbeit.

[Der schöne Günther]

Wenn wir jetzt schon den Assembler rausholen, sollten wir dann nicht wenigstens alle die gleiche(n) Beispieldatei(en) haben um die Ergebnisse überhaupt vergleichen zu können? Harry, lad doch mal ein, zwei typische Bilder hoch bei denen du das prüfen möchtest.

[Uwe Raabe]

Zitat von Neutral General:

Ich habe mal ne (Teil-)Assemblerversion gebaut:

Das gibt einen ganz ulkigen Effekt auf meinem System, wenn man das Beispielprojekt mit DEBUG oder RELEASE compiliert:

Standard DEBUG: 23-24 ms
Assembler DEBUG: 20-21 ms
Standard RELEASE: 7-8 ms
Assembler RELEASE: 23-24 ms

Spricht irgendwie gegen Assembler...

[Neutral General]

Wow, da würde mich aber mal interessieren wie der generierte Assemblercode im Release aussieht
Hab hier grad nur Delphi 7 und mein Assemblercode hat deutlich weniger Anweisungen und kein cmp - Hätte da zumindest keinen so großen Vorsprung erwartet (wenn ich schon verliere )

[Uwe Raabe]

Der Effekt tritt schon auf, wenn man in den Compileroptionen die Optimierung aktiviert (und natürlich ein Rebuild des Projekts macht). Interessanterweise ist die ASM-Variante mit aktiver Optimierung offenbar langsamer also ohne.

Code:

005C61C7 8BC7             mov eax,edi
Unit13.pas.143: for x := 0 to z-1 do begin
005C61C9 48               dec eax
005C61CA 85C0             test eax,eax
005C61CC 7C14             jl $005c61e2
005C61CE 40               inc eax
005C61CF 33D2             xor edx,edx
Unit13.pas.144: if RGBA[x].rgbReserved <> 255 then begin
005C61D1 807C9303FF       cmp byte ptr [ebx+edx*4+$03],$ff
005C61D6 7406             jz $005c61de
Unit13.pas.145: EXIT (TRUE);
005C61D8 C645FF01         mov byte ptr [ebp-$01],$01
005C61DC EB04             jmp $005c61e2
Unit13.pas.147: end;
005C61DE 42               inc edx
Unit13.pas.143: for x := 0 to z-1 do begin
005C61DF 48               dec eax
005C61E0 75EF             jnz $005c61d1

[Namenloser]

Assembler-Befehle wie LOOP sollte man heutzutage nicht mehr verwenden, die sind auf modernen CPUs ziemlich langsam. Vermutlich liegt es daran.

Wenn schon Assembler, dann wäre eher was mit SIMD interessant.

Ansonsten würde mir noch folgende reine Pascal-Alternative einfallen:

Delphi-Quellcode:

function HasTransparentRGBAValues (const bm:TBitmap): Boolean;
var
  x, z: Integer;
  pixel: PLongWord;
begin
  Result := FALSE;
  pixel := bm.Scanline[bm.Height-1];
  z := bm.Width * bm.Height;

  for x := 0 to z-1 do begin
  begin
    if (pixel^ and $FF000000) <> $FF000000 then 
      EXIT (TRUE);
    inc(pixel);
  end;
end;

Statt auf den Pointer einen Offset von 3 Bytes hinzuzuaddieren, werden die 32 Bit einfach maskiert. Ob das schneller ist, keine Ahnung.

[Uwe Raabe]

Zitat von Namenloser:

Ansonsten würde mir noch folgende reine Pascal-Alternative einfallen:

Mal abgesehen, daß die sich wegen eines zusätzlichen begin nicht compilieren lässt, ist sie zeitlich gleichauf mit der ursprünglichen Routine. Insofern ist bisher noch der einzige erfolgreiche Ansatz zur Optimierung das Aktivieren der Optimierung in den Compileroptionen.

[Neutral General]

Hab ne andere Idee:

Delphi-Quellcode:

function HasTransparentRGBAValues (const bm:TBitmap): Boolean;
var
  x, z: Integer;
  pixel: PRGBQuad;
  sum: Cardinal;
begin
  pixel := bm.Scanline[bm.Height-1];
  z := bm.Width * bm.Height;

  sum := 0;
  for x := 0 to z-1 do
  begin
    sum := sum + pixel^.rgbReserved;
    inc(pixel);
  end;

  Result := sum < (z * 255);
end;

Ob das schneller ist, ist natürlich die Frage weil die ganze Schleife durchlaufen muss.
Dafür spart man sich ggf. ne Menge Vergleiche. Ein Versuch ists Wert denke ich.

[himitsu]

Bei Assambler kann keine Codeoptimierung greifen.