Geht das noch schneller? - Bitmap-Verrechnung

[manfred42]

Hallo, ich bin hier neu hinzugestoßen und versuche mich am Beschleunigen.
Zuförderst ein paar Fragen zu den Details:
● Ist der Nenner in der Formel 255 oder 256? Bei 255 sind einige Klimmzüge nötig
● Ist Round vonnöten, oder dient es nur zur Float-Integer-Konvertierung?
● Von welcher WEB-Site kann ich 2 repräsentative 32-bittige Bitmaps absaugen?

Da ich schon einmal mit MMX-Befehlen Antialiasing veranstaltet habe,
würde ich mich gern an der Bitmap-Verrechnung versuchen.

MfG Manfred(19)42

[Harry Stahl]

Zitat von manfred42:

Hallo, ich bin hier neu hinzugestoßen und versuche mich am Beschleunigen.
Zuförderst ein paar Fragen zu den Details:
● Ist der Nenner in der Formel 255 oder 256? Bei 255 sind einige Klimmzüge nötig
● Ist Round vonnöten, oder dient es nur zur Float-Integer-Konvertierung?
● Von welcher WEB-Site kann ich 2 repräsentative 32-bittige Bitmaps absaugen?

Da ich schon einmal mit MMX-Befehlen Antialiasing veranstaltet habe,
würde ich mich gern an der Bitmap-Verrechnung versuchen.

MfG Manfred(19)42

256 wäre wohl richtig.
Round wäre gut, zur Not aber auch ohne.
Erstelle Dir doch einfach selber 2 passende Bitmaps, hier die Größe und Bedingungen, mit denen ich hier teste:

- 3548x2558 Pixel, 32 Bit-Format.
- Das untere Bitmap hat einen Verlaufsuntergrund, das obere Bitmap hat zwei rechteckige Bereiche (jeweils 340 x 2300), die zu 100% transparent sind.

[manfred42]

Danke für den Ratschlag (um diese Uhrzeit)!
Ich hatte mit 2 kleineren Bitmaps experimentiert und werde
dem Ratschlag folgen.
Jetzt habe die letzte (Pointer)-Version der Prozedur probiert.
Sie läuft sehr flott und schreit förmlich nach dem Einsatz von
MMX-Code.
An einer Thread-Version will ich mich später versuchen. Ich
habe da schon eine Idee. Bei Threads bin ich aber nicht sehr
sattelfest. Auf meinem DualCore-Notebook für Rentner wird es
nicht viel bringen
Wenn ich mit den technischen Rahmenbedingungen der DP
mehr vertraut bin, werde ich auch Codepassagen präsentieren.
Gute Nacht!

[Amateurprofi]

Delphi-Quellcode:

PROCEDURE Blend32(Source,Dest:pRGBQuad; Width,Height,OOffset,UOffset:Integer);
const
   RegSize=4;
   WOffs=6*RegSize; HOffs=12*RegSize; OOffs=11*RegSize; UOffs=10*RegSize;
asm
         pushad
         mov      ebp,ecx                // Width
         lea      esi,[eax+ebp*4]        // Source
         lea      edi,[edx+ebp*4]        // Dest
         neg      ebp
         mov      [esp+WOffs],ebp
@Loop:   mov      bl,[esi+ebp*4].TRgbQuad.rgbReserved // S.Reserved
         test     bl,bl
         jz       @Next
         // Red
         mov      al,[esi+ebp*4].TRgbQuad.rgbRed      // S.Red
         mov      cl,[edi+ebp*4].TRgbQuad.rgbRed      // D.Red
         sub      al,cl                               // S.Red-D.Red
         imul     bl                                  // (S.Red-D.Red)*S.Reserved
         add      ah,cl                               // ((S.Red-D.Red)*S.Reserved) shr 8 + D.Red
         mov      dx,ax
         // Green
         mov      al,[esi+ebp*4].TRgbQuad.rgbGreen    // S.Green
         mov      cl,[edi+ebp*4].TRgbQuad.rgbGreen    // D.Green
         sub      al,cl                               // S.Green-D.Green
         imul     bl                                  // (S.Green-D.Green)*S.Reserved
         mov      dl,ah                               // ((S.Green-D.Green)*S.Reserved) shr 8
         add      dl,cl                               // ((S.Green-D.Green)*S.Reserved) shr 8 + D.Green
         shl      edx,8
         // Blue
         mov      al,[esi+ebp*4].TRgbQuad.rgbBlue     // S.Blue
         mov      cl,[edi+ebp*4].TRgbQuad.rgbBlue     // D.Blue
         sub      al,cl                               // S.Blue-D.Blue
         imul     bl                                  // (S.Blue-D.Blue)*S.Reserved
         mov      dl,ah                               // ((S.Blue-D.Blue)*S.Reserved) shr 8
         add      dl,cl                               // ((S.Blue-D.Blue)*S.Reserved) shr 8 + D.Blue
         // Reserved
         or       edx,$FF000000
         mov      [edi+ebp*4],edx
         add      ebp,1
         jl       @Loop
         // Nächste Zeile
@Next:   add      esi,[esp+OOffs]
         add      edi,[esp+UOffs]
         mov      ebp,[esp+WOffs]
         sub      [esp+HOffs],1
         jnz      @Loop
@End:    popad
end;

Delphi-Quellcode:

PROCEDURE AsmDraw32BitToBitmap(Source,Dest:TBitmap);
resourcestring
   sWidthDifferent='Bitmaps haben unterschiedliche Breiten';
   sHeightDifferent='Bitmaps haben unterschiedliche Höhen';
   sZeroWidth='Breite der Bitmaps ist 0';
   sLessTwoLines='Höhe der Bitmaps ist < 2';
   sSourceNone32Bit='Source ist keine 32 Bit Bitmap';
   sDestNone32Bit='Dest ist keine 32 Bit Bitmap';
var PSource,PDest:pRGBQuad; W,H,SOffset,DOffset:Integer;
begin
   W:=Source.Width;
   H:=Source.Height;
   if Dest.Width<>W then raise Exception.Create(sWidthDifferent);
   if Dest.Height<>H then raise Exception.Create(sHeightDifferent);
   if W<1 then raise Exception.Create(sZeroWidth);
   if H<2 then raise Exception.Create(sLessTwoLines);
   if Source.PixelFormat<>pf32bit then raise Exception.Create(sSourceNone32Bit);
   if Dest.PixelFormat<>pf32bit then raise Exception.Create(sDestNone32Bit);
   PSource:=Source.ScanLine[0];
   SOffset:=NativeInt(Source.ScanLine[1])-NativeInt(PSource);
   PDest:=Dest.ScanLine[0];
   DOffset:=NativeInt(Dest.ScanLine[1])-NativeInt(PDest);
   Blend32(PSource,PDest,W,H,SOffset,DOffset);
end;

[Harry Stahl]

Zitat von Amateurprofi:

Delphi-Quellcode:

PROCEDURE Blend32(Source,Dest:pRGBQuad; Width,Height,OOffset,UOffset:Integer);
....

Ja, das gute alte Assembler...

Wäre noch etwas schneller als meine letzte Variante (hier zuletzt ca. 62 MS, die ASM ca. 47 MS), allerdings ist das Ergebnis erkennbar falsch, siehe Screenshot).

[Amateurprofi]

Zitat von Harry Stahl:

Zitat von Amateurprofi:

Delphi-Quellcode:

PROCEDURE Blend32(Source,Dest:pRGBQuad; Width,Height,OOffset,UOffset:Integer);
....

Ja, das gute alte Assembler...

Wäre noch etwas schneller als meine letzte Variante (hier zuletzt ca. 62 MS, die ASM ca. 47 MS), allerdings ist das Ergebnis erkennbar falsch, siehe Screenshot).

Hab ich geprüft.
Das Label "Next:" gehört 2 Code-Zeilen höher.
So wie es war, wurde bei rgbReserved=0 zum nächsten Zeilenanfang gesprungen statt zum nächsten Pixel.
Bei meiner Prüfung auf identische Ergebnisse hatte ich dummerweise immer alle rgbReserved<>0, so dass dieser Fehler nicht auftrat.

Delphi-Quellcode:

PROCEDURE Blend32(Source,Dest:pRGBQuad; Width,Height,OOffset,UOffset:Integer);
const
   RegSize=4;
   WOffs=6*RegSize; HOffs=12*RegSize; OOffs=11*RegSize; UOffs=10*RegSize;
asm
         pushad
         mov      ebp,ecx                // Width
         lea      esi,[eax+ebp*4]        // Source
         lea      edi,[edx+ebp*4]        // Dest
         neg      ebp
         mov      [esp+WOffs],ebp
@Loop:   mov      bl,[esi+ebp*4].TRgbQuad.rgbReserved // S.Reserved
         test     bl,bl
         jz       @Next
         // Red
         mov      al,[esi+ebp*4].TRgbQuad.rgbRed      // S.Red
         mov      cl,[edi+ebp*4].TRgbQuad.rgbRed      // D.Red
         sub      al,cl                               // S.Red-D.Red
         imul     bl                                  // (S.Red-D.Red)*S.Reserved
         add      ah,cl                               // ((S.Red-D.Red)*S.Reserved) shr 8 + D.Red
         mov      dx,ax
         // Green
         mov      al,[esi+ebp*4].TRgbQuad.rgbGreen    // S.Green
         mov      cl,[edi+ebp*4].TRgbQuad.rgbGreen    // D.Green
         sub      al,cl                               // S.Green-D.Green
         imul     bl                                  // (S.Green-D.Green)*S.Reserved
         mov      dl,ah                               // ((S.Green-D.Green)*S.Reserved) shr 8
         add      dl,cl                               // ((S.Green-D.Green)*S.Reserved) shr 8 + D.Green
         shl      edx,8
         // Blue
         mov      al,[esi+ebp*4].TRgbQuad.rgbBlue     // S.Blue
         mov      cl,[edi+ebp*4].TRgbQuad.rgbBlue     // D.Blue
         sub      al,cl                               // S.Blue-D.Blue
         imul     bl                                  // (S.Blue-D.Blue)*S.Reserved
         mov      dl,ah                               // ((S.Blue-D.Blue)*S.Reserved) shr 8
         add      dl,cl                               // ((S.Blue-D.Blue)*S.Reserved) shr 8 + D.Blue
         // Reserved
         or       edx,$FF000000
         mov      [edi+ebp*4],edx
@Next:   add      ebp,1
         jl       @Loop
         // Nächste Zeile
         add      esi,[esp+OOffs]
         add      edi,[esp+UOffs]
         mov      ebp,[esp+WOffs]
         sub      [esp+HOffs],1
         jnz      @Loop
@End:    popad
end;

[Harry Stahl]

@Amateurprofi:

Danke, dass Du Dich der Sache noch mal angenommen hast. Allerdings stimmt das Ergebnis immer noch nicht.

Falls Du die Sache noch weiter verfolgen willst, kannst Du hier im Thread-Beitrag Nr. 26 das Demoprojekt laden, das ich gepostet habe.

Da brauchst Du nur im Button-Click Event folgendes zu machen, um Deine Procedure einzubinden:

Delphi-Quellcode:

  for L := 1 to count do begin
    AsmDraw32BitToBitmap (b, b3);
    //Draw32BitToBitmapnew (b, b3);
  end;

Dann Siehst Du direkt im Vergleich, ob beide Bilder den gleichen Inhalt haben.