AlphaWert jedes Pixels einer BITMAP bzw eines DCs ändern (auf 255 statt 0 setzen)

Guten Tag!

Ich lade in meinem aktuellen Projekt eine .bmp und verknüpfe die BITMAP dann mit einem HDC.
Dieses HDC übergebe ich dann an eine Funktion, welche ich nicht verändern darf.

// DC erstellen
	 HDC bmpDC  = CreateCompatibleDC(GetDC(NULL)); 
	 // .bmp in BITMAP laden
	 HBITMAP loadedBmp    = (HBITMAP) LoadImageA (NULL, "test.bmp", IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
	 // BITMAP und DC miteinander verknüpfen
	 SelectObject (bmpDC, loadedBmp ); 

	 // einen Teilbereich der Bitmap in ein anderes DC, "resultDC", kopieren
	 BitBlt (resultDC, 0, 0, width, height, bmpDC, startx, starty, SRCCOPY);

Soweit so gut!
Jetzt nutzt die Funktion, an die ich resultDC übergebe, GetDIBits() auf dieses DC.
Dabei wird auch der alpha Wert der einzelnen Pixel ausgelesen und verarbeitet.

Das dumme ist nur: GetDIBits() gibt für jedes Pixel als AlphaWert 0 zurück, die Funktion erwartet aber 255 als alpha Wert und funktioniert sonst nicht -.-

Meine Frage: Wie kann ich bei einer, wie oben geladene, BITMAP den Alpha Wert jedes Pixels auf 255 setzen? $:\$

Bin für jede Hilfe dankbar.

DWORD* addr = reinterpret_cast<DWORD*> (Startadresse_der_Pixel);
DWORD* end = addr + _Größe_des_Speicherbereichs_;
while(addr != end)
  *addr++ |= 0xFF<<24;

Jede Rasterzeile des Bitmaps ist aligned, daher sollte obiger Code klappen.

Danke!
Stellt sich nur noch die Frage wie ich an die Adresse der Pixel komme $:\$

mfg

Es ist wahrscheinlich doch nicht so einfach, da es zwei Arten gibt, Bitmaps zu speichern: bottom-up & vice versa. (Lektüre Windowsprogrammierung: "Die durchgeknallte Welt der Dibs" oder so ähnlich).
Am Besten wäre es, wenn du die _einzelnen_ Rasterzeilen jeweils verändern würdest.
Die Adresse ist:

BYTE* Buffer = ..;
int w = /*Breite*/;
int h = /*Höhe*/;
int bc = /*BitCount*/;
int rl = 4*((w*bc+ 31) / 32); // Länge jeder Rasterzeile
if (h > 0) // von unten nach oben: absteigende Adressen
{
  Row[y] = (DWORD_PTR)((Buffer + (h - y - 1)*rl));
}
else // von oben nach unten: aufsteigende Adressen
{
  Row[y] = (DWORD_PTR)(Buffer  + y*rl());
}

So könnte man die Adressen bestimmen, wenn man bspw. einen vector<DWORD_PTR> Row(h) vorher erzeugen würde (andernfalls direkt in einer Schleife).

Den Speicherbereich der Pixel liefert ja GetDIBits (Member: lpvBits).
An die Dimensionen w,h,bc kommst du mittels GetObject.

Jetzt könntest du in einer Schleife von 0 bis h jeweils die Adresse bestimmen, sie in einem DWORD* speichern (da die Pixel bei dir anscheinend 32 Bit breit sind), und in einer verschachtelten zweiten Schleife von 0 bis w die im ersten Post beschriebene Anweisung ausführen.