Nach CopyMemory werden Daten nicht übernommen

[EWeiss]

Nach dem kopieren des einen auf das andere Array werden die Daten im neuen nicht korrekt übernommen.
Was könnte hier schief laufen.?

Delphi-Quellcode:

    BitmapStream.Position := 0;
    Background.LoadFromStream(BitmapStream);
    GetObject(Background.Handle, SizeOf(Bmp), @Bmp);

    size := Bmp.bmWidth * Bmp.bmHeight * Bmp.bmBitsPixel;
    psa  := SafeArrayCreateVector(VT_UI1, 0, size);

    psa.cDims := 2;
    psa.cbElements := 1;
    psa.fFeatures := 0;
    psa.cLocks := 0;
    psa.pvData := Bmp.bmBits;
    psa.rgsabound[0].lLbound := 0;
    psa.rgsabound[0].cElements := Bmp.bmWidth;

    CopyMemory(PpixelDataArr, psa, Bmp.bmBitsPixel);

Eigentlich sollten jetzt alle Daten vom psa Array sich im PpixelDataArr befinden.
Die ersten 4 Einträge ja.. der rest aber nicht.

gruss

[Uwe Raabe]

Dann gib doch einfach die passende Größe an und nicht die Farbtiefe.

Zitat:

bmBitsPixel
The number of bits required to indicate the color of a pixel.

[EWeiss]

Zitat:

Zitat von Uwe Raabe (Beitrag 1242282)

Dann gib doch einfach die passende Größe an und nicht die Farbtiefe.

Zitat:

bmBitsPixel
The number of bits required to indicate the color of a pixel.

Wo ist der Unterschied?`
ob ich nun 4 oder Bmp.bmBitsPixel = 4 angebe bleibt sich doch gleich.

4 ist 4

rgsabound ist 64
wird aber im neuem Array mit 12288 beziffert.

ab psa.pvData werden die Daten nicht übernommen.


gruss

[Uwe Raabe]

Du kopierst aber nur die ersten 4 Byte der Struktur psa und nicht die Inhalte der einzelnen Array-Elemente. CopyMemory kopiert ja nur eine Anzahl Bytes von einer Speicheradresse zu einer anderen - was auch immer sich dahinter verbirgt. Mit ziemlicher Sicherheit ist es der falsche Ansatz um ein SafeArray zu kopieren (dafür gibt es SafeArrayCopy und SafeArrayCopyData).

Ein SafeArray ist halt etwas völlig anderes als ein normales Delphi Array. Der Typ von PpixelDataArr ist aus dem Code-Abschnitt ja nicht zu ersehen, aber selbst wenn es auch ein PSafeArray ist, wird mit dem CopyMemory die Speicherverwaltung von Windows einfach unterlaufen. Du könntest zwar mit

Delphi-Quellcode:

CopyMemory(PpixelDataArr, psa, Sizeof(psa^));

eine Kopie des SafeArray herstellen, aber das ginge mit

Delphi-Quellcode:

PpixelDataArr^ :=  psa^

viel einfacher. Der Speicher für die Daten ist aber nur einmal angelegt und da muss man schon aufpassen, wer den dann wann wieder freigibt.

Warum überhaupt das SafeArray? Brauchst du das anderweitig irgendwo?

[EWeiss]

Ja mich nervt das auch sehr aber die Ole-Schnittstelle an der ich das Array senden muss ist nun mal auf SafeArray ausgelegt.
In Delphi gibt es da fast keine Informationen drüber wie man ein PixelArray einer Bitmap in ein SafeArray kopiert.

gruss

[Furtbichler]

Wieviel Bytes werden denn hier kopiert?

Delphi-Quellcode:

CopyMemory(PpixelDataArr, psa, Bmp.bmBitsPixel);

wenn

Delphi-Quellcode:

Bmp.bmBitsPixel=4

ist

[EWeiss]

Zitat:

Zitat von Furtbichler (Beitrag 1242311)

Wieviel Bytes werden denn hier kopiert?

Delphi-Quellcode:

CopyMemory(PpixelDataArr, psa, Bmp.bmBitsPixel);

wenn

Delphi-Quellcode:

Bmp.bmBitsPixel=4

ist

Ich habe es ja geändert aber es hilft nichts :oops:
Auch wenn ich das eine auf das andere Caste.

gruss

[jaenicke]

Wie sieht es denn aktuell aus, wenn du schreibst du hast es geändert?

[EWeiss]

Zitat:

Zitat von jaenicke (Beitrag 1242314)

Wie sieht es denn aktuell aus, wenn du schreibst du hast es geändert?

Delphi-Quellcode:

    GetObject(Background.Handle, SizeOf(Bmp), @Bmp);

    size := Bmp.bmWidth * Bmp.bmHeight * Bmp.bmBitsPixel;
    PpixelDataArr  := SafeArrayCreateVector(VT_UI1, 0, size);

    PpixelDataArr.cDims := 2;
    PpixelDataArr.cbElements := 1;
    PpixelDataArr.fFeatures := 0;
    PpixelDataArr.cLocks := 0;
    PpixelDataArr.pvData := Bmp.bmBits;
    PpixelDataArr.rgsabound[0].lLbound := 0;
    PpixelDataArr.rgsabound[0].cElements := Bmp.bmWidth;

Hab das Temporäre gelöscht dann kann mir das casten sparen..
Aber funktioniert trotzdem nicht.. Ich vermisse das PixelArray innerhalb des SafeArray
Versteh die Technik wohl nicht die dahinter steckt.


gruss

[jaenicke]

Da du schreibst, dass es in Delphi nicht so viele Informationen dazu gibt:
Das liegt daran, dass du direkt mit der API arbeitest. Delphi selbst hat Funktionen wie VarArrayCreate um mit solchen Arrays zu arbeiten.
Ein wenig Material dazu findest du hier:
http://www.gekko-software.nl/Delphi/index.htm

Und hier noch ein Beispiel zu der API selbst in Delphi (erste Antwort):
https://forums.embarcadero.com/threa...threadID=53288
Bei dir fehlt jetzt das Kopieren der Daten würde ich mal sagen. Du musst nur die richtige Anzahl Bytes kopieren.

[Zacherl]

Ohne die SaveArrays jetzt wirklich zu kennen: Wie ich das sehe, reicht es nicht einfach per

Delphi-Quellcode:

PpixelDataArr.pvData := Bmp.bmBits

die Daten zuweisen zu wollen. Ich würde hier SafeArrayAccessData verwenden, um mir einen Zeiger auf die tatsächlichen Daten zu holen. Danach sollte ein

Delphi-Quellcode:

CopyMemory(PtrFromAccessDataAPI, Bmp.bmBits, size)

ausreichen, um die Daten zu kopieren. Abschließend aber SafeArrayUnaccessData nicht vergessen.

[EWeiss]

Zitat:

Zitat von Zacherl (Beitrag 1242321)

Ohne die SaveArrays jetzt wirklich zu kennen: Wie ich das sehe, reicht es nicht einfach per

Delphi-Quellcode:

PpixelDataArr.pvData := Bmp.bmBits

die Daten zuweisen zu wollen. Ich würde hier SafeArrayAccessData verwenden, um mir einen Zeiger auf die tatsächlichen Daten zu holen. Danach sollte ein

Delphi-Quellcode:

CopyMemory(PtrFromAccessDataAPI, Bmp.bmBits, size)

ausreichen, um die Daten zu kopieren. Abschließend aber SafeArrayUnaccessData nicht vergessen.

Funktioniert leider nicht.. :)
Danke..

Ich habe schon das Problem mit dem Header der kommt auch schon nicht an.

Delphi-Quellcode:

var
  BitmapInfo : Pointer;
.....
BitmapStream.Position := 0;
Background.LoadFromStream(BitmapStream);

BitmapStream.Position := 0;
BitmapInfo := @BitmapInfoHeader;
SafeArrayAccessData(PbitmapInfoArr, BitmapInfo);
SafeArrayUnaccessData(PbitmapInfoArr);

Danach sende ich die Daten das Resultat siehe Anhang..
Na egal dauert halt seine zeit bis ich weis wie es funktioniert. ;)

ops.. der falsche punkt im Anhang aber spielt keine rolle ist überall 0

gruss

[Zacherl]

Du schreibst den Header ja auch nirgendwo in das Array rein :P Probiers mal so:

Delphi-Quellcode:

var
  BitmapInfo: TBitmapInfoHeader;
  Data: Pointer;
{ ... }
SafeArrayAccessData(PbitmapInfoArr, Data);
CopyMemory(Data, @BitmapInfo, SizeOf(BitmapInfo));
SafeArrayUnaccessData(PbitmapInfoArr);

Die SafeArrayAccessData liefert dir als Output Parameter einen komplett neuen Pointer. Du weißt zwar vor dem Aufruf

Delphi-Quellcode:

BitmapInfo := @BitmapInfoHeader

zu, aber nach dem Aufruf von SafeArrayAccessData, wurde der Zeiger bereits wieder überschrieben.

[EWeiss]

Danke du bist wirklich hilfsbereit.. ohne den unnötigen Schnick,schnack Drumherum ;)

Ich hatte die Funktion ja schon geschrieben

Delphi-Quellcode:

var
   size: Integer;
   header: BITMAPINFOHEADER;
   pHeader: Pointer;

begin
   if Assigned(PpixelDataArr) then
     SafeArrayDestroy(PpixelDataArr);

   if Assigned(PbitmapInfoArr) then
     SafeArrayDestroy(PbitmapInfoArr);

     size := width * height * bytePerPixel;
     PpixelDataArr := SafeArrayCreateVector(VT_UI1, 0, size);

     PbitmapInfoArr := SafeArrayCreateVector(VT_UI1, 0, sizeof(BITMAPINFOHEADER));

     pHeader := @Header;

     SafeArrayAccessData(PbitmapInfoArr, pHeader);
     Header.biSize := sizeof(BITMAPINFOHEADER);
     Header.biWidth := width;
     Header.biHeight := height;
     Header.biBitCount := bytePerPixel*8;
     Header.biCompression := FourCC;
     SafeArrayUnaccessData(PbitmapInfoArr);

Was sich nicht vertragen hat war diese Umsetzung auf die mir niemand geantwortet hat als ich danach fragte. ;)
Nun habe ich diese Verändert da die Konvertierung "pHeader := @Header" tatsächlich nicht funktioniert hat.
Jetzt kommen die Daten auch richtig an. Zumindest was den Header betrifft mit dem anderen muss ich noch schaun.

Delphi-Quellcode:

procedure TAtmoCtrlLib.AtmoCreateTransferBuffers(header: PBITMAPINFOHEADER; FourCC, bytePerPixel, width,
  height: Integer);
var
  size: Integer;

begin
  if Assigned(PpixelDataArr) then
    SafeArrayDestroy(PpixelDataArr);

  if Assigned(PbitmapInfoArr) then
    SafeArrayDestroy(PbitmapInfoArr);

    size := width * height * bytePerPixel;
    PpixelDataArr  := SafeArrayCreateVector(VT_UI1, 0, size);

    PbitmapInfoArr := SafeArrayCreateVector(VT_UI1, 0, sizeof(BITMAPINFOHEADER));

    SafeArrayAccessData(PbitmapInfoArr, Pointer(Header));
    Header.biSize := sizeof(BITMAPINFOHEADER);
    Header.biWidth := width;
    Header.biHeight := height;
    Header.biBitCount := bytePerPixel*8;
    Header.biCompression := FourCC;
    SafeArrayUnaccessData(PbitmapInfoArr);
end;

Delphi-Quellcode:

AtmoCtrlLib.AtmoCreateTransferBuffers(@BitmapInfoHeader, BI_RGB, 4, 64, 48);

Wie gesagt ich muss den Kram alles selber machen da gibt es nichts vergleichbares.
War wohl nur für C++ C# gedacht!

EDIT:
Eigentlich müssten doch die Pixel inklusive der Farben in Bmp.bmBits vorhanden sein oder?
Hmm wenn nicht muss ich diese wohl noch zu psa.rgsabound[0] hinzufügen sehe ich das richtig?

Das will irgendwie nicht mit den PixelArray :oops::wall:
Im Moment fällt mir nichts mehr ein.

gruss und Danke..

[Zacherl]

Kannst du mal den Code zeigen, den du für das Kopieren der Pixeldaten verwendest? Eigentlich sollte das ja analog zum Header funktionieren.

[EWeiss]

Zitat:

Zitat von Zacherl (Beitrag 1242352)

Kannst du mal den Code zeigen, den du für das Kopieren der Pixeldaten verwendest? Eigentlich sollte das ja analog zum Header funktionieren.

So wie ich das verstehe muss ich meinen Zeiger von .bmBits in den Array Deskriptor setzen nur wie wo an welcher stelle.
Ohne das die Daten zwischenzeitlich wieder überschrieben werden.

gruss

[Zacherl]

Sollte analog zum Header folgendermaßen funktionieren:

Delphi-Quellcode:

var
  Data: Pointer;
{ ... }
  size := width * height * bytePerPixel;
  PpixelDataArr := SafeArrayCreateVector(VT_UI1, 0, size);
  SafeArrayAccessData(PpixelDataArr, Data);
  CopyMemory(Data, Pointer(NativeUInt(BitmapStream.Memory) + SizeOf(TBitmapFileHeader) + SizeOf(TBitmapInfoHeader)), size);
  SafeArrayUnaccessData(PpixelDataArr);

[EWeiss]

Zitat:

Zitat von Zacherl (Beitrag 1242462)

Sollte analog zum Header folgendermaßen funktionieren:

Delphi-Quellcode:

var
  Data: Pointer;
{ ... }
  size := width * height * bytePerPixel;
  PpixelDataArr := SafeArrayCreateVector(VT_UI1, 0, size);
  SafeArrayAccessData(PpixelDataArr, Data);
  CopyMemory(Data, Pointer(NativeUInt(BitmapStream.Memory) + SizeOf(TBitmapFileHeader) + SizeOf(TBitmapInfoHeader)), size);
  SafeArrayUnaccessData(PpixelDataArr);

Danke dir..

Ich habe es mittlerweile gelöst es gibt aber noch ein paar kleine Probleme mit der Bitmap.
Ich denke 1 Pixel als Rahmen gezeichnet ist einfach zu wenig werde da mal stufenweise erhöhen da er mir sonst
alle Fenster als Magenta anzeigt.

Ich musste den Zeiger von .bmBits in den Array Deskriptor setzen.
Das ging nur über OLEVariant zusätzlich mußte ich das Bitmap auf 24Bit setzen (ohne Alpha Channel).

Delphi-Quellcode:

  if AtmoInitialize then
  begin
    BitmapStream := TMemoryStream.Create;
    Background.SaveToStream(BitmapStream);
    BitmapStream.Position := 0;

    Background.LoadFromStream(BitmapStream);

    BitmapStream.Position := 0;
    BitmapStream.Read(BitmapFileHeader, SizeOf(TBitmapFileHeader));
    BitmapStream.Read(BitmapInfoHeader, SizeOf(TBitmapInfoHeader));

    pheader := @BitmapInfoHeader;

    AtmoCtrlLib.AtmoCreateTransferBuffers( BI_RGB, 3, BitmapInfoHeader.biWidth,
      BitmapInfoHeader.biHeight);

    GetObject(Background.Handle, SizeOf(Bmp), @Bmp);

    size := Bmp.bmWidth * Bmp.bmHeight * Bmp.bmBitsPixel;
    PpixelDataArr  := SafeArrayCreateVector(VT_UI1, 0, size);

    bitMapSize := Bmp.bmWidth * Bmp.bmHeight;

    VariantInit(ValOUT);
    TVariantArg(ValOUT).VT := VT_ARRAY or VT_UI1;

    rgsabound[0].cElements := bitMapSize;
    rgsabound[0].lLbound := 0;

    TVariantArg(ValOUT).parray := SafeArrayCreate(VT_UI1, 1, rgsabound);
    if Assigned(TVariantArg(ValOUT).parray) then
    begin
      SafeArrayAccessData(TVariantArg(ValOUT).parray, pArrayData);
      CopyMemory(pArrayData, Bmp.bmBits, bitMapSize);
      SafeArrayCopy(TVariantArg(ValOUT).parray, PpixelDataArr);
      SafeArrayUnaccessData(TVariantArg(ValOUT).parray);
      VariantClear(ValOUT);
    end;
    AtmoCtrlLib.AtmoSendPixelData;

    DeleteObject(Background.Handle);
    FreeAndNil(BitmapStream);
  end;
  FreeAndNil(Background);

Hab auch noch ein paar Speicherlecks die ich finden muss.
Nach dieser Änderung.

Bei der ganzen Sache ist halt das Problem das man nicht oder sehr wenig Informationen über diese Thematik hat.
Aber wie man sieht geht es wenn man nur am Ball bleibt ;)

gruss

[EWeiss]

Kann mir jemand sagen warum innerhalb von ein paar Minuten die Funktion im Post eins höher^
Der Speicher innerhalb von Minuten auf ein paar 100 MB hochgeht?

Ich kann doch nicht mehr machen als den Stream und die Bitmap Daten freizugeben.
Vielleicht noch irgendwas vergessen\Übersehn?

Habe den Atmo Kram auskommentiert trotzdem steigt der Speicher.
Deaktiviere ich die ganze Abfrage bleibt der Speicher konstant.

gruss

[himitsu]

Wie wäre es, wenn man sich mal mit dem dafür nötigen Debugwissen beschschäfftigt?

Angefangen bei ReportMemoryLeaksOnShutdown über die vollen Logging-Funktionen vom großen FastMM bis hin zu spezialisierten Frameworks (Delphi Speicherlecks finden).



Aber du kannst ja auch einfach mal prüfen, ob du alles, was DU da reservierst/erstellst, auch wieder freigibst, was sich nicht selber freigibt.
> Bmp, PpixelDataArr, pArrayData usw.


Du kannst natürlich auch einfach von innen nach außen die Funktionen so weit Stück für Stück auskommentieren bis der Speicher konstant bleibt.

[EWeiss]

begin OT;
Ihr mit euren Spitzfindungen!
Warum versucht ihr die Leute immer zu belehren anstatt einfach nur etwas zum Thema zu sagen.
Wenn ihr das nicht wollt last es einfach.
Ist mir lieber als das unnötige Getue Drumherum.
end OT;

Ich weis was den stetigen Anstieg versursacht nur man kann nicht mehr tun als die Ressourcen freizugeben.

SafeArrayCopy speichert mein neu erstelltest Array in mein Arbeits Array.

Delphi-Quellcode:

SafeArrayCopy(TVariantArg(ValOUT).parray, PpixelDataArr);
SafeArrayDestroy(TVariantArg(ValOUT).parray);
SafeArrayDestroy(PpixelDataArr);

Trotzdem steigt der Speicher!

Jetzt erkläre mir mal mit einem wirklich guten Spruch wie ich den Speicher freigeben soll
wenn die Funktion Ansicht intern diesen Speicherleck verursacht?
Kommentiere ich diese Zeile aus funktioniert alles so wie es soll.

Soll ich jetzt noch 100 NIL's hinterherschicken oder was!

Zitat:

mit dem dafür nötigen Debugwissen beschschäfftigt

Und?
Hätte das ganze keinen triftigen Grund gehabt hätte ich nicht gefragt.
Hört doch auf mit eurem unnötigen Gewäsch.. :evil: Trollerei

Nach meiner Korrektur geht es jetzt konstant 14MB Speicher auch ohne dein zutun.

Delphi-Quellcode:

    bitMapSize := Bmp.bmWidth * Bmp.bmHeight;

    rgsabound[0].cElements := bitMapSize;
    rgsabound[0].lLbound := 0;

    PpixelDataArr := SafeArrayCreate(VT_UI1, 1, rgsabound);
    if Assigned(PpixelDataArr) then
    begin
      SafeArrayAccessData(PpixelDataArr, pArrayData);
      CopyMemory(pArrayData, Bmp.bmBits, bitMapSize);
      SafeArrayUnaccessData(PpixelDataArr);
    end;
    AtmoCtrlLib.AtmoSendPixelData;

    pArrayData := nil;
    SafeArrayDestroy(PpixelDataArr);
    DeleteObject(Background.Handle);
    FreeAndNil(BitmapStream);

gruss

[jaenicke]

Also wenn ich die Doku zur einfachen DLL-Version richtig verstehe, funktioniert das ganze bei der DLL Version so:
- Threadstart
AtmoInitialize + AtmoCreateTransferBuffers
- Benutzung
AtmoLockTransferBuffer um den Pointer auf den Buffer zu holen, AtmoSendPixelData zum Senden
- Threadende
AtmoFinalize(1)

Bei dir erzeugst du jedes mal den Buffer neu. Aber warum sollte das bei Verwendung von COM notwendig sein? Dazu habe ich allerdings keine Doku gefunden.

[EWeiss]

Zitat:

AtmoLockTransferBuffer um den Pointer auf den Buffer zu holen

Nö sperrt den Transfer des Buffer (Lock)

Zitat:

Bei dir erzeugst du jedes mal den Buffer neu. Aber warum sollte das bei Verwendung von COM notwendig sein?

Weil das Bild sich jede MS ändert.
Ich habe es auch versucht mit einem Flag welches prüft ob die Funktion schon aufgerufen wurde.
Das Ergebnis war das die Anwendung einen AV gemeldet hat.
Daher gehe ich erstmal davon aus das es so sein muss.

AtmoCreateTransferBuffers
Wird der Header der Bitmap erstellt also vorbereitet zum senden.

Danach werden die Pixel gesendet mit AtmoSendPixelData.

Ich kann mir das aber nochmal genau anschauen ob ich dahingehend noch was ändern kann / muss.

Delphi-Quellcode:

// *********************************************************************//
// richtet den Pixeltransferbuffer für den LiveSource Modus mit externer Quelle ein.
// FourCC enthält dabei den Code wie die Pixeldatei aufgebaut sind - derzeit sind
// folgende Codes in AtmoWinA.exe implementiert - andere Codes werden einfach ignoriert.

// FourCC =  "HSVI"  steht für ein Bild was bereits in HSV Daten vorliegt...
// oder man übergibt die in Windows.h? definierte Konstante "BI_RGB" was
// signalisiert dass es sich um unkomprimierte Pixeldaten handelt.

// bytePerPixel = legt fest wieviel Byte ein Pixel benötigt
// für HSVI wird der Wert 3 erwartet.
// für BI_RGB sind die Werte 2, 3 oder 4 zulässig.
// für 2 ist RGB 565 definiert!
// width = Breite des Bildauszugs derzeit ist nur 64 zulässig!
// height = Höhe des Bildauszugs derzeit ist nur 48 zulässig!
// *********************************************************************//
procedure TAtmoCtrlLib.AtmoCreateTransferBuffers(FourCC, bytePerPixel, width,
  height: Integer);

begin

  if Assigned(PbitmapInfoArr) then
  begin
    SafeArrayDestroy(PbitmapInfoArr);
    PbitmapInfoArr := nil;
  end;

  PbitmapInfoArr := SafeArrayCreateVector(VT_UI1, 0, sizeof(BITMAPINFOHEADER));

  SafeArrayAccessData(PbitmapInfoArr, Pointer(pheader));
  pheader.biSize := sizeof(BITMAPINFOHEADER);
  pheader.biWidth := width;
  pheader.biHeight := height;
  pheader.biBitCount := bytePerPixel * 8;
  pheader.biCompression := FourCC;
  SafeArrayUnaccessData(PbitmapInfoArr);
end;

Danke für die Infos.

PS:
Da bin ich auch noch nicht hinter gestiegen was damit gemeint ist.

Zitat:

für BI_RGB sind die Werte 2, 3 oder 4 zulässig.

Was für einen Wert 2,3 oder 4 bei mir ist BI_RGB = 0 welche Werte sollte man dann da noch addieren.
Na ok! Ich denke die meinen damit die Anzahl der Bytes wie bei 24 Bit Bitmaps = 4 Byte
32 Bit Bitmaps werden dann ignoriert weil mehr als 4 Bytes
Etwas undurchsichtig ;)


gruss

[Zacherl]

Zitat:

Zitat von EWeiss (Beitrag 1242480)

Da bin ich auch noch nicht hinter gestiegen was damit gemeint ist.

Zitat:

für BI_RGB sind die Werte 2, 3 oder 4 zulässig.

Was für einen Wert 2,3 oder 4 bei mir ist BI_RGB = 0 welche Werte sollte man dann da noch addieren.
Na ok! Ich denke die meinen damit die Anzahl der Bytes wie bei 24 Bit Bitmaps = 4 Byte
32 Bit Bitmaps werden dann ignoriert weil mehr als 4 Bytes

So wie ich das verstanden habe, beziehen sich 2, 3 und 4 auf den Wert den bytePerPixel haben kann, wenn FourCC auf BI_RGB gesetzt ist. Das heißt, du kannst in diesem Falle 16, 24 und 32 Bit Bitmaps verwenden.

[EWeiss]

Hmmm hab es mit 32 Bitmaps versucht das geht nicht.
32 Bitmaps sind 8 Byte per Pixel (incl. Alpha Channel) Oder?

gruss

[Zacherl]

Zitat:

Zitat von EWeiss (Beitrag 1242483)

Hmmm hab es mit 32 Bitmaps versucht das geht nicht.
32 Bitmaps sind 8 Byte per Pixel (incl. Alpha Channel) Oder?

32 Bit Bitmaps sind 4 Byte pro Pixel. Jeweils 1 Byte für A, R, G und B.

[EWeiss]

Zitat:

Zitat von Zacherl (Beitrag 1242487)

Zitat:

Zitat von EWeiss (Beitrag 1242483)

Hmmm hab es mit 32 Bitmaps versucht das geht nicht.
32 Bitmaps sind 8 Byte per Pixel (incl. Alpha Channel) Oder?

32 Bit Bitmaps sind 4 Byte pro Pixel. Jeweils 1 Byte für A, R, G und B.

Ich will dir ja gerne glauben .. Aber dann schreibt jeder etwas anderes.

Zitat:

32 bpp.. Das Format ist wie bei BI_BITFIELDS, wenn folgende Farbmasken verwendet würden: 0x00FF0000 für den Rot-Kanal0x0000FF00 für den Grün-Kanal0x000000FF für den Blau-Kanal.
Jeder Farbkanal ist 8 Bit pro Pixel groß; insgesamt ergeben sich 16.777.216 mögliche Farben (8 Bit sind ungenutzt).
Einige Programme wie etwa Adobe Photoshop interpretieren die verbleibenden 8 Bits (0xFF000000) als Alphakanal mit 256 möglichen Transparenzstufen.
Dies ist jedoch von der Spezifikation nicht vorgesehen.

Kann auch sein das ich leicht übermüdet bin ... hehehehee

gruss

[Medium]

Bist du. Da steht 8 Bit pro Pixel, was genau 1 Byte ist. Bit <> Byte. Es gibt keine Windows-Nativen Bitmaps mit mehr als 8 Bit/Pixel, und das sind eben 32Bit Bitmaps. Schon immer gewesen. Oftmals sind sogar 24Bit Bitmaps zu 32Bit Bitmaps identisch ausgerichtet weil es für den Zugriff deutlich günstiger ist als 3 Byte; das vierte bleibt dabei dann (wie das Wiki ja schon sagt) einfach unbenutzt.
(Und sei mal etwas unempfindlicher. Was ist falsch daran, sich mit den verfügbaren Tools mal auseinanderzusetzen? Hilfe zur Selbsthilfe nennt sich das. Wenn du jemanden dein Programm genau vorkauen lassen möchtest, leg wat aufn Tisch.)

[EWeiss]

Zitat:

Bit <> Byte

Arghh... yeah immer das gleiche mit mir sehe den Unterschied zwischen Bit und Byte.. nicht.

Danke für die Richtigstellung.

Zitat:

Und sei mal etwas unempfindlicher. Was ist falsch daran, sich mit den verfügbaren Tools mal auseinanderzusetzen?

Nichts.. Aber darauf hinzuweisen das man zu blöd ist zum debuggen schon..
Aber egal lassen wird das.

Zitat:

Wenn du jemanden dein Programm genau vorkauen lassen möchtest

Mein Programm? Nö ich mache das für die Leute bei MediaPortal (Hobby) und dafür will ich nichts
Warum sollte ich dann anderen was bezahlen? :)

gruss

[jaenicke]

Zitat:

Zitat von EWeiss (Beitrag 1242480)

Zitat:

AtmoLockTransferBuffer um den Pointer auf den Buffer zu holen

Nö sperrt den Transfer des Buffer (Lock)

:?:

Zitat:

sperrt den Transferbuffer für den aktuellen Thread und liefert einen Zeiger auf den
Speicherblock zurück.

Wo du das Array überhaupt mit der AtmoCtrlLib in Verbindung bringst, ist mir aus deinem letzten Quelltext auch nicht klar. Du rufst dort nur AtmoCtrlLib.AtmoCreateTransferBuffers auf und dann AtmoCtrlLib.AtmoSendPixelData. Bei beiden Aufrufen ist aber keinerlei Verbindung zu deinem Array involviert.

Deshalb würde ich erwarten, dass es in dem Objekt irgendwo auch ein Zugriff auf den Buffer möglich ist.

[EWeiss]

Zitat:

Wo du das Array überhaupt mit der AtmoCtrlLib in Verbindung bringst, ist mir aus deinem letzten Quelltext auch nicht klar.

Delphi-Quellcode:

PpixelDataArr: PSafeArray = nil;

Ist global in der AtmoCtrl Unit definiert.

Delphi-Quellcode:

// *********************************************************************//
// schickt den Inhalt des Buffers an den COM Server der AtmoWinA.exe und hebt die Sperre
// des Buffers auf.
// *********************************************************************//
procedure TAtmoCtrlLib.AtmoSendPixelData; stdcall;
var
  pALVC: IAtmoLiveViewControl;

begin
  pALVC := getAtmoLiveViewControl;
  if Assigned(PpixelDataArr) and Assigned(pALVC) then
  begin
    SafeArrayUnaccessData(PpixelDataArr);
    pALVC.setPixelData(PbitmapInfoArr, PpixelDataArr);
  end;

  if Assigned(pALVC) then
  begin
    if Assigned(PpixelDataArr) then
    begin
      SafeArrayDestroy(PpixelDataArr);
      PpixelDataArr := nil;
    end;

    if Assigned(PbitmapInfoArr) then
    begin
      SafeArrayDestroy(PbitmapInfoArr);
      PbitmapInfoArr := nil;
    end;

    pALVC := nil;

  end;

end;

Delphi-Quellcode:

// *********************************************************************//
//sperrt den Transferbuffer für den aktuellen Thread und liefert einen Zeiger auf den
//Speicherblock zurück.
//Sollte die DLL noch nicht initialisiert oder kein Aufruf von AtmoCreateTransferBuffers
//im voraus erfolgt sein - liefert die Funktion "NULL"!
// *********************************************************************//
function TAtmoCtrlLib.AtmoLockTransferBuffer: Pointer; stdcall;
var
  pixelData: pByte;

begin
  if Assigned(PpixelDataArr) then
    SafeArrayAccessData(PpixelDataArr, Pointer(pixelData));

  result := pixelData;
end;

gruss

[Zacherl]

Da ich den Source nicht mehr wirklich durchblicke, habe ich mir schnell mal ein eigenes Testprogramm angelegt, welches soweit zu meiner Zufriedenheit funktioniert :)

Der Start des Live Bildes sieht etwa so aus:

Delphi-Quellcode:

procedure TAtmoWinLive.Start(Format: TPixelFormat);
begin
  if (not (Format in [pf16Bit, pf24Bit, pf32Bit])) then
  begin
    raise Exception.Create('Unsupported pixel format.');
  end;
  FFormat := Format;
  FAtmoWin.SetEffect(cemLivePicture, FOldEffect);
  FOldLiveViewSource := FAtmoWin.GetLiveViewSource;
  FAtmoWin.SetLiveViewSource(lvsExternal);
  CreateTransferBuffers;
  FInitialized := true;
end;

Die Transfer Buffer werden, wie schon von jaenicke korrekt vorgeschlagen, nur einmal pro "Session" erstellt und für jeden Frame wiederverwendet. Ebenfalls initialisiere ich hier ein internes Bitmap mit der von AtmoWin gelieferten Zielgröße:

Delphi-Quellcode:

procedure TAtmoWinLive.CreateTransferBuffers;
var
  W, H, ImageSize: Integer;
  Header: PBitmapInfoHeader;
begin
  FAtmoWin.GetLiveViewResolution(W, H);
  FBitmapHeader := SafeArrayCreateVector(VT_UI1, 0, SizeOf(TBitmapInfoHeader));
  if (not Assigned(FBitmapHeader)) then
  begin
    raise Exception.Create('Failed to create bitmap header buffer.');
  end;
  OleCheck(SafeArrayAccessData(FBitmapHeader, Pointer(Header)));
  try
    ZeroMemory(Header, SizeOf(Header));
    Header^.biSize := SizeOf(TBitmapInfoHeader);
    Header^.biWidth := W;
    Header^.biHeight := H;
    Header^.biPlanes := 1;
    case FFormat of
      pf16bit: Header^.biBitCount := 16;
      pf24bit: Header^.biBitCount := 24;
      pf32bit: Header^.biBitCount := 32;
    end;
    Header^.biCompression := BI_RGB;
    ImageSize := W * H * Header^.biBitCount;
  finally
    OleCheck(SafeArrayUnaccessData(FBitmapHeader));
  end;
  FBitmapData := SafeArrayCreateVector(VT_UI1, 0, ImageSize);
  if (not Assigned(FBitmapData)) then
  begin
    DestroyTransferBuffers;
    raise Exception.Create('Failed to create bitmap data buffer.');
  end;
  FBitmap := TBitmap.Create;
  FBitmap.PixelFormat := FFormat;
  FBitmap.Width := W;
  FBitmap.Height := H;
end;

Die eigentlichen Farbwerte sende ich mit folgender Funktion. Hierbei mache ich mir zu nutzen, dass die Berechnung der AmbiLight Farben im Grunde genommen ja nur auf der Berechnung des Durchschnittsfarbwertes für einen bestimmten Quadranten des Bildschirms beruht. Diese Berechnung nehme ich nicht per Hand vor, sondern benutze ein einfaches GDI StretchBlt im HALFTONE Mode. Danach werden die Pixel Daten in das entsprechende Array kopiert und an AtmoWin gesendet:

Delphi-Quellcode:

procedure TAtmoWinLive.Update(B: TBitmap);
var
  Data: Pointer;
  BPP, H: Integer;
begin
  if (not FInitialized) then Exit;
  if (B.PixelFormat <> FFormat) then
  begin
    raise Exception.Create('Invalid pixel format.');
  end;
  SetStretchBltMode(FBitmap.Canvas.Handle, HALFTONE);
  StretchBlt(FBitmap.Canvas.Handle, 0, 0, FBitmap.Width, FBitmap.Height, B.Canvas.Handle,
    0, 0, B.Width, B.Height, SRCCOPY);
  OleCheck(SafeArrayAccessData(FBitmapData, Data));
  try
    BPP := 2;
    case FFormat of
      pf24bit: BPP := 3;
      pf32bit: BPP := 4;
    end;
    for H := 0 to FBitmap.Height - 1 do
    begin
      {$WARNINGS OFF}
      CopyMemory(Pointer(NativeUInt(Data) + H * FBitmap.Width * BPP),
        FBitmap.ScanLine[H], FBitmap.Width * BPP);
      {$WARNINGS ON}
    end;
  finally
    OleCheck(SafeArrayUnaccessData(FBitmapData));
  end;
  FAtmoWin.SetLiveViewPixelData(FBitmapHeader, FBitmapData);
end;

Und schließlich wird beim Beenden des Live Bilds noch der vorher gesicherte Modus wiederhergestellt:

Delphi-Quellcode:

procedure TAtmoWinLive.Stop;
begin
  FInitialized := false;
  DestroyTransferBuffers;
  if (FOldLiveViewSource <> lvsExternal) then
  begin
    FAtmoWin.SetLiveViewSource(FOldLiveViewSource);
  end;
  if (FOldEffect <> cemLivePicture) then
  begin
    FAtmoWin.SetEffect(FOldEffect);
  end;
end;

@Emil: Wenn du magst, kannst du meine Klassen gerne für dein Projekt übernehmen. Im Grunde musst du nur die Update Funktion mit deinem DirectX Screenshot füttern :)

Viele Grüße
Zacherl

[EWeiss]

@Zacherl

Zitat:

@Emil: Wenn du magst, kannst du meine Klassen gerne für dein Projekt übernehmen. Im Grunde musst du nur die Update Funktion mit deinem DirectX Screenshot füttern

Aber gerne doch wenn Sie Vorteile für (mein) das Programm bringt ;)

gruss