Assemler Routine ummodeln - wer kann bitte helfen

[turboPASCAL]

Hi,

ich habe volgende Procedure:

Delphi-Quellcode:

{------------------------------------------------------------------}
{  Swap bitmap format from BGR to RGB                              }
{------------------------------------------------------------------}
procedure SwapRGB(data : Pointer; Size : Integer);
asm
  mov ebx, eax
  mov ecx, size

@@loop :
  mov al,[ebx+0]
  mov ah,[ebx+2]
  mov [ebx+2],al
  mov [ebx+0],ah
  add ebx,3
  dec ecx
  jnz @@loop
end;

und möchte sie wiefolgt verändern:

Delphi-Quellcode:

procedure SwapRGB(data : Pointer; Size : Integer; Step: Byte);
asm
  mov ebx, eax
  mov ecx, size
  mov ???, step

@@loop :
  mov al,[ebx+0]
  mov ah,[ebx+2]
  mov [ebx+2],al
  mov [ebx+0],ah
  add ebx, ??? (4)
  dec ecx
  jnz @@loop
end;

Das soll ein Array umformen in etwa so:

Code:

BGRA, BGRA, BGRA...
// nach:
RGBA, RGBA, RGBA...

und das ergibt dann eine Bitmapladeroutiene für zB. OpenGl:

Delphi-Quellcode:

function LoadBMPTexture(ResID: Integer; var Texture : GLuint) : Boolean;
var
  BitmapLength: LongWord;
  bmpBits: array of byte;
  hBmp: HBitmap;
  bi: tagBITMAP;
begin
  hBmp := Loadimage(HInstance, MAKEINTRESOURCE(ResID), IMAGE_BITMAP, 0,0,0);
  GetObject(hBmp, sizeof(bi), @bi);
  BitmapLength := bi.bmWidth * bi.bmHeight * bi.bmBitsPixel Div 8;
  SetLength(bmpBits, BitmapLength+1);
  GetBitmapBits(hBmp, BitmapLength, @bmpBits[0]);

  if @bmpBits[0] <> nil then
  begin
    SwapRGB(@bmpBits[0], bi.bmWidth * bi.bmHeight);   // Swap Bitmap Bits BGR(A) to RGB(A)
    Texture := CreateTexture(bi.bmWidth, bi.bmHeight, GL_RGBA, @bmpBits[0]);
    Result := (Texture <> 0);
  end else
    Result := False;

  DeleteObject(hBmp);
end;

[kolbaschedder]

Hallo,

wenn ich das richtig verstehe, macht das die vorhandene Funktion bereits.

Delphi-Quellcode:

  dec ecx  <-- size um 1 erniedrigen
  jnz @@loop <--jnz = jump if not zero, also springe nach @@loop wenn size noch nicht null

MfG

Kolbaschedder

[sirius]

Also:
1. Diese Routine ist ganz gefährlich, da sie ebx verändert und nicht zurücksetzt!
Bsp: Falls du sie aus einer längeren Methode aufrufst (Delphi legt self meist in ebx) wird self verändert du hast einen fehler beim Zugriff auf Objekteigene Properties etc. Auch sonst kann etwas wichtiges in ebx liegen, was die aufrufende Routine gerne so wieder vorfinden möchte. Hingegen darf eax, ecx und edx verändert werden.
2. wäre ja noch edx frei, da muss ich mal schauen. Warum willst du es eigentlich in Assembler?

Edit: und 3. Was soll jetzt step bei dir bzw. dem Beispiel bewirken?

[sirius]

Ich glaube, ich weis jetzt, was du meinst.
Für deinen Fall müsstest du in step 1 übergeben.

Delphi-Quellcode:

procedure SwapRGB(data : Pointer; Size : Integer; Step: Integer); 
asm
  push ebx
  add ecx,3
  test edx,edx
  jz @@end  

@@loop : 
  mov bl,[eax+0] 
  mov bh,[eax+2] 
  mov [eax+2],bl 
  mov [eax+0],bh 
  add eax, ecx
  dec edx 
  jnz @@loop 
@@end:
  pop ebx
end;

[turboPASCAL]

Tja, nun steig ich nicht mehr so recht druch. wo werden denn
die Parameter wie step übergeben (an den asm-Teil)?

[Apollonius]

Aufrufkonvention ist Register, folglich liegt Data in EAX, Size in EDX und Step in ECX.

[turboPASCAL]

thx Apollonius.


Also nochmal für Dummies, wie müsste folgender Code als ASM aussehen ?

Delphi-Quellcode:

 // pData als Pointer übergeben ?!... (to do...)

  procedure _SwapRGB(pData: TByteArray; pDataLength: DWORD; Alpha: Byte);
  var
    n: DWORD;
    b, r: byte;
  begin
    n := 0;
    while n <= pDataLength-4 do
    begin
      b := pData[n];
      r := pData[n + 2];
      pData[n] := r;
      pData[n + 2] := b;
      pData[n + 3] := Alpha;
      inc(n, 4);
    end;
  end;

oder macht das keinen Sinn für die Geschwindigkeit (Delphi oder ASM)

[sirius]

Wenn es einen Unterschied gibt, dann dürfte er sehr gering sein.

[turboPASCAL]

Bei grossen Bitmaps (1024*1024) scheint es noch recht zügig zu laufen. :gruebel:

[sirius]

Kannst ja die probieren:

Delphi-Quellcode:

procedure SwapRGB(data : Pointer; Size : Integer; Alpha:byte);
asm
  push ebx
  test edx,edx
  jz @@end

@@loop :
  mov bl,[eax+0]
  mov bh,[eax+2]
  mov [eax+2],bl
  mov [eax+0],bh
  mov [eax+3],cl

  add eax, 4
  sub edx, 4
  jnle @@loop
@@end:
  pop ebx
end;

[OldGrumpy]

Zitat:

Zitat von turboPASCAL

Hi,

ich habe volgende Procedure:

Delphi-Quellcode:

{------------------------------------------------------------------}
{  Swap bitmap format from BGR to RGB                              }
{------------------------------------------------------------------}
[...]
  add ebx,3
[...]

und möchte sie wiefolgt verändern:
[...]
Das soll ein Array umformen in etwa so:

Code:

BGRA, BGRA, BGRA...
// nach:
RGBA, RGBA, RGBA...

[...]

Abgesehen von allen anderen Kommentaren: Deine ursprüngliche Routine setzte 24 Bit pro Pixel (je 8 für R,G,B) voraus, Du hättest gerne 32 pro Pixel. Alles was dazu notwendig ist, ist die Schleife statt in 3er-Schritten in 4er-Schritten laufen zu lassen. Statt add ebx,3 also einfach add ebx,4 und fertig. Nichtsdestotrotz sind alle restlichen Warnungen bzgl. EBX=self etc. zu beherzigen :)

[turboPASCAL]

@sirius, das tut das was es soll. :thumb:

Es währe noch nett wen mir das jemand kommentiert bis auf die mov ...,... da seh ich durch.
Aber sonst :gruebel:

@OldGrumpy,

Zitat:

Deine ursprüngliche Routine setzte 24 Bit pro Pixel [...]
Alles was dazu notwendig ist, ist die Schleife statt in 3er-Schritten in 4er-Schritten laufen zu lassen

Ja, wenn man weis wie ... ;)

[Apollonius]

Delphi-Quellcode:

procedure SwapRGB(data : Pointer; Size : Integer; Alpha:byte);
asm
  push ebx //ebx sichern
  test edx,edx //Wenn Größe=0, Abbruch
  jz @@end

@@loop :
  mov bl,[eax+0] //R holen
  mov bh,[eax+2] //B holen
  mov [eax+2],bl //und tauschen
  mov [eax+0],bh
  mov [eax+3],cl //den Alpha-Wert speichern

  add eax, 4 //die nächsten vier Byte
  sub edx, 4 //Size:=Size-4
  jnle @@loop //Müssen wir nochmal?
@@end:
  pop ebx //ebx zurückholen
end;

[turboPASCAL]

Ja, danke. :thumb:

Wo kann man so ein Zeugs nachlesen ? :gruebel:

[sirius]

Wahrscheinlich in Büchern :zwinker:

Was willst du denn nachlesen? Also ASM in Delphi ist recht einfach. Die Anzahl der Befehle in ASM sind ja recht übersichtlich (und gibts hier und da im Internet oder im Buch).
Um alle anderen Sachen (Stack einrichten etc.) muss man sich ja unter Delphi nicht mehr kümmern. Das zum Thema ASM benutzen.
(ich habe übrigens nur im Internet nachgelesen und besitze kein Buch)

Jetzt zum besonderen von ASM unter Delphi:
du musst dich eben ein wenig mit dem Compiler arrangieren (z.B. das Wissen wie delphi die Parameter übergibt etc.). Dazu hat balu der Bär mal ein TUT geschrieben.
Edit: Das tut ist hier

[Apollonius]

Ich habe mir das "Zeugs" im Frühjahr angeeignet, ebenfalls nur aus dem Internet. Ungemein geholfen hat es mir, dass beim kostenlsoen Delphi 2005 die Quellcodes der Standardunits nicht dabei sind. Wenn man da wissen will, wie etwas gemacht wird, hilft nur noch eine gute Assembler-Kenntnis. Ich habe da wirklich Stunden daran gesessen, herauszufinden, wie der Aufruf von dynamischen Methoden erfolgt - und nebenbei noch herauszuarbeiten, wie die DMT denn aussieht.
Kurz gesagt gilt auch hier: Übung macht den Meister.