ich möchte mit einer Assembler Funktion in ein Image schreiben.

Geht so was und wenn ja wie komme ich an die Speicher Adresse.

aus der Borlandhilfe,

void __fastcall TForm1::Button1Click(TObject *Sender)

{
Graphics::TBitmap *pBitmap = new Graphics::TBitmap();
// Dieses Beispiel zeigt das direkte Zeichnen in das Bitmap
Byte *ptr;
try
{
pBitmap->LoadFromFile("C:\\Program Files\\Common Files\\Borland Shared\\Images\\Splash\\256color\\factory.bmp ");
for (int y = 0; y < pBitmap->Height; y++)
{
ptr = (Byte *)pBitmap->ScanLine[y];
for (int x = 0; x < pBitmap->Width; x++)

= (Byte)y;

}
Canvas->Draw(0,0,pBitmap);
}
catch (...)
{
ShowMessage("Bitmap konnte nicht geladen oder geändert werden!");
}
delete pBitmap;
}

Es wir ein Datentyp Byte *ptr instanziert, dann wird die Zeilen Adresse
über den Index y ermittelt und in den Pointer gelesen.

Was soll dann aber das?
Hier ist ptr plötzlich ein Array.

for (int x = 0; x < pBitmap->Width; x++)

        ptr[x] = (Byte)y;

Ich kann doch einfach die Adresse der ersten Zeile, Bitmap Height sowie Width
meiner Assembler Funktion übergeben und einfach in den Speicherbereich schreiben.

Ist schon klar, der Pointer zeigt auf eine Speicheradresse beschreibe ich nun
den Speicher über den Ptr[1] wird die Ptr Adresse Ptr+1 beschrieben.(oder)

Habe mal folgendes probiert,

int *Ptr;
  int Color;
	pBitmap->Canvas->Pixels[0][0] = 0x00909090;
	Ptr = (int*)pBitmap->ScanLine[0];
	Color = *Ptr;
     *Ptr = 0;
     Image1->Canvas->Draw(0,0,pBitmap);

Ich lese den korrekten Wert(0x00909090) über den Pointer nach Color zurück.
Nur funktioniert das schreiben über den Pointer nicht.

Wo ist Assembler?

void __fastcall TForm1::Button1Click(TObject *Sender)
{
	pBitmap->Canvas->Pixels[0][0] = 0x00e0e0e0;
	Ptr = (int*)pBitmap->ScanLine[0];
	cColor = GetColor(Ptr); //Hier kommt die mit Pixels geschriebene Farbe          
                                //zurück 0x00e0e0e0;
     WriteColor(Ptr,0); // Farbe an Zeile 0 Spalte 0 auf schwarz ändern
                        // funkt nicht
     Image1->Canvas->Draw(0,0,pBitmap);
}
//---------------------------------------------------------------------------
int TForm1::GetColor(int *Ptr)
{
	int *Ptr_ = Ptr;
	int Color;
	asm
     {
     	//Entspricht Color = *Ptr
		mov esi,Ptr_;
          lodsd;
          mov Color,eax;
     }
     return Color;
}
//---------------------------------------------------------------------------
void TForm1::WriteColor(int *Ptr,int Color)
{
	int *Ptr_ = Ptr;
	int Color_ = Color;
	asm
     {
          //Entspricht *Ptr = Color
		mov edi,Ptr_;
          mov eax,Color_;
          stosd;
     }
     return;
}

int *Ptr;
int  Color;

Image1->Picture->Bitmap->Canvas->Pixels[0][0] = 0x00909090;

Ptr = (int*) Image1->Picture->Bitmap->ScanLine[0];

// Wert auslesen
Color = *Ptr;

// auf 0 setzen
*Ptr  = 0;

// nochmal auslesen -> ist 0
Color = *Ptr;

void __fastcall TForm1::Button1Click(TObject *Sender)
{
	int *Ptr;
	int cColor;
	pBitmap->Canvas->Pixels[0][0] = clGray;
	Ptr = (int*)pBitmap->ScanLine[0];
	cColor = *Ptr;    //Farbe für Grau gelesen
	*Ptr   = 0;       //Farbe Schwarz schreiben
     cColor = *Ptr;       //Lese 0 zurück
     Image1->Canvas->Draw(0,0,pBitmap); //Die Pixelfarbe ist immer noch Grau
}

Ich lese nach dem 0 schreiben auch wieder 0 zurück, doch die Pixelfarbe
nach dem Draw bleibt Grau.

BCB-Hilfe TCanvas::Draw schrieb:

Wenn die Grafik ein TBitmap-Objekt ist, wird das Bitmap mit dem Wert von CoypMode gezeichnet.

Kann ich mir nicht gleich die Speicher Adresse des Image
besorgen und direkt in das Image schreiben, spart die Funktion
Draw.

Nur wie kommt man an die Image Speicher Adresse?

void __fastcall TForm1::Button1Click(TObject *Sender)
{
  int        ImageHeight = Image1->Picture->Bitmap->Height;
  int        ImageWidth  = Image1->Picture->Bitmap->Width;
  RGBTRIPLE *ScanLine;

  for (int y = 0; y < ImageHeight; ++y)
  {
    // Zeiger auf den Anfang einer Bildzeile setzen
    ScanLine = (RGBTRIPLE*) Image1->Picture->Bitmap->ScanLine[y];

    for (int x = 0; x < ImageWidth; ++x)
    {
      // RGB-Farbwert in Grau (nach Intensität) konvertieren
      unsigned char GrayColor = (ScanLine->rgbtRed + ScanLine->rgbtGreen + ScanLine->rgbtBlue) / 3;

      // Grauwert zu weisen
      ScanLine->rgbtRed   = GrayColor;
      ScanLine->rgbtGreen = GrayColor;
      ScanLine->rgbtBlue  = GrayColor;

      // Zeiger auf nächstes RGB-Triple setzen
      ++ScanLine;
    }
  }

  // Anzeige des Bildes erneuern
  Image1->Invalidate();
}

Oder wie meist du das.

Sorry letzten Beitrag von dir noch nicht gesehen.