pf8Bit seltsames aussehen der Palette

[EWeiss]

Ich versuche verschiedene Paletten für das Spectrogram zu definieren.

Dazu habe ich die weite verändert.
Die Initialisierung des Bitmap sieht wie folgt aus.

Delphi-Quellcode:

procedure TForm1.InitBitmap;
begin
  PalOrder := PAL_HOT;
  PalNeg := False;
  PalRGB := PAL_RGB;

  BuffBMP := TBitmap.Create;
  BuffBMP.Width := (StreamLength div 512 div 2) div Info.chans;
  BuffBMP.Height := 160;
  BuffBMP.HandleType := bmDIB;
  BuffBMP.PixelFormat := pf8Bit;

  ChangePalette(PalOrder, BuffBMP.Width, BuffBMP.Height, PaletteFile);

  BuffBMP.Canvas.Brush.Color := PaletteIndex(0);
  BuffBMP.Canvas.FillRect(BuffBMP.Canvas.ClipRect);

end;

Das habe ich von

Delphi-Quellcode:

(StreamLength div 512 div 4) //pf24Bit

nach

Delphi-Quellcode:

(StreamLength div 512 div 2) //pf8Bit

geändert
Mein Problem die Linien sind irgendwie gestretcht (bzw.. scheint da mit Scanline was nicht zu stimmen.)
Zudem wird das Spectrogram nun revers gezeichnet.
Es fängt von hinten an zu zeichnen.

was kann ich da machen?
Habe mal die unterschiede als Anhang addiert.

gruss

[Zacherl]

Zitat:

Zitat von EWeiss (Beitrag 1335177)

Delphi-Quellcode:

(StreamLength div 512 div 4) //pf24Bit

Wie genau kommt dieser Wert denn zustande? Das hatte ich mich schon im anderen Thread gefragt, weil ich darin kein logisches Muster erkennen konnte.

24-Bit sind ja bekanntlich 3 Bytes und nicht 4. Ebenfalls ist 8-Bit ja nur 1 Byte. Und unabhängig davon macht das Verhältnis von 24-Bit = 4 und 8-Bit = 2 keinen Sinn für mich. Woher die 512 kommt, sehe ich grade auch nicht, aber das mag daran liegen, dass ich mich mit der BASS Library und Audio-Formaten generell nicht wirklich auskenne.

[EWeiss]

Zitat:

Wie genau kommt dieser Wert denn zustande? Das hatte ich mich schon im anderen Thread gefragt, weil ich darin kein logisches Muster erkennen konnte.

Ist eine Standard variable vom (Bass Forum) muss mich da jetzt auch nochmal schlau machen.

Zitat:

Und unabhängig davon macht das Verhältnis von 24-Bit = 4 und 8-Bit = 2 keinen Sinn für mich.

So gesehen muss ich dir recht geben..

gruss

[Zacherl]

Zitat:

Zitat von EWeiss (Beitrag 1335182)

Zitat:

Wie genau kommt dieser Wert denn zustande? Das hatte ich mich schon im anderen Thread gefragt, weil ich darin kein logisches Muster erkennen konnte.

Ist eine Standard variable vom (Bass Forum) muss mich da jetzt auch nochmal schlau machen.

Kannst ja mal verlinken, falls du den Thread wiederfindest. Würde ich mir rein interessehalber auch gerne mal durchlesen.

[EWeiss]

Zitat:

Zitat von Zacherl (Beitrag 1335183)

Zitat:

Zitat von EWeiss (Beitrag 1335182)

Zitat:

Wie genau kommt dieser Wert denn zustande? Das hatte ich mich schon im anderen Thread gefragt, weil ich darin kein logisches Muster erkennen konnte.

Ist eine Standard variable vom (Bass Forum) muss mich da jetzt auch nochmal schlau machen.

Kannst ja mal verlinken, falls du den Thread wiederfindest. Würde ich mir rein interessehalber auch gerne mal durchlesen.

In irgend welchen Code Samples..
Das Problem dabei ist das meistens dann wenn es darauf ankommt keine Kommentare addiert werden.
Bei nicht würdigen Funktionen wird kommentiert und bei würdigen weniger. ;)

Aber ich kenne jemand der sich 100% mit der Bass Lib auskennt hab den mal angeschrieben.

gruss

[EWeiss]

Also 4 steht für die sample länge FLOAT.
Delphi Single = 4 Byte
Ein Sample hat immer eine länge von 4 Bytes wenn das Flag BASS_SAMPLE_FLOAT verwendet wird.
Anschließend noch mal durch 2 also für jeden Kanal 512 enthält 256 samples für den rechten und 256 samples für den linken Kanal.


Das ist dann also nicht mein Problem muss ich so belassen wie es ist.
Die 4 Bytes haben also nichts mit dem PixelFormat zu tun.

Hmm vielleicht funktioniert das auf diese weise auch nicht, habe keine Palette für 24Bit.
Und wenn ich über HSLtoRGB die Farben hole verändert das die 8Bit Palette.

gruss

[EWeiss]

Wird eine vorgefertigte Palette für ein Bitmap bei ScanLine nicht berücksichtigt?
Wenn doch warum sind dann hier alle Farbwerte "0" ?

Delphi-Quellcode:

  if bScanLines then
  begin
    SetLength(ScanLines, Bitmap.Height);
    for i := 0 to Length(ScanLines) - 1 do
      ScanLines[i] := Bitmap.Scanline[i];
  end;

gruss

[Medium]

Wie verwendest du Scanline hier? Insbesondere der Typ des Pointer wäre hier interessant.

[EWeiss]

Zitat:

Zitat von Medium (Beitrag 1335199)

Wie verwendest du Scanline hier? Insbesondere der Typ des Pointer wäre hier interessant.

Genau so wie im original Sample nur das ich für das Bitmap vorher eine Palette in pf8Bit erstelle.

gruss

[Neutral General]

Zitat:

Zitat von EWeiss (Beitrag 1335200)

Genau so wie im original Sample nur das ich für das Bitmap vorher eine Palette in pf8Bit erstelle.

Hab jetzt nicht alle beide Threads komplett durchgelesen. Kannst du bitte grad sagen welcher Typ es ist?
Was Medium und ich schätzen ist, dass du einen Pointertyp benutzt der größer als 1 Byte ist und du somit Pixel überspringst und dadurch seltsame Ergebnisse bekommst.

[EWeiss]

Zitat:

Kannst du bitte grad sagen welcher Typ es ist?

Ich hänge mal das Beispiel an da ich jetzt nicht genau weiß welchen Typ ihr meint.

Mit ScanLine habe ich ein generelles Problem
In Verbindung mit der Palette funktioniert das nicht mehr. (Ab einer bestimmten Größe einer Datei)

Bei Pixel geht es allerdings werden hier die Farben falsch dargestellt in Verbindung mit HSLtoRGB.

gruss

[Medium]

Wie vermutet.

Delphi-Quellcode:

  ScanLines: TArray<PRGBTriple>;
  P: PRGBTriple;

Bei pf8Bit hast du keine RGBTriples mehr, sondern nur noch 1 Byte pro Pixel (8 Bit halt). Die richtigen Typen wären also:

Delphi-Quellcode:

  ScanLines: TArray<PByte>;
  P: PByte;

Das hier:

Delphi-Quellcode:

if Assigned(P) then HSLtoRGB(H, S, L, P^.rgbtRed, P^.rgbtGreen, P^.rgbtBlue);

geht dann aber natürlich auch nicht mehr! Wenn du ein Bitmap mit Palette hast, hast du keine Farbwerte mehr in den Pixeln stehen, sondern einen Index in die Palette!! Statt also die Farben in die Pixeldaten zu schreiben, musst du dir für jeden Pixel eine Farbe aus der Palette aussuchen und deren Index in die Pixeldaten schreiben. Bitmaps mit Paletten sind da anders als die ohne.

[EWeiss]

Zitat:

Bei pf8Bit hast du keine RGBTriples mehr, sondern nur noch 1 Byte pro Pixel (8 Bit halt). Die richtigen Typen wären also:

Hab ich mir schon gedacht das etwas im argen ist.. Sind halt Dinge die man wissen muss ;)
Wie schon gesagt zu wenig Erfahrung mit der Handhabung von ScanLine.

Zitat:

geht dann aber natürlich auch nicht mehr!

Ja. Wie du schon sagst, da es keine Farbwerte mehr gibt in den Pixeln.

Muss mal sehn wie ich das berechne zu mal das Bitmap jetzt auch noch umgekehrt gezeichnet wird.

gruss

[EWeiss]

Boahh das dauert aber viel länger als mit den RGB Farben.

Delphi-Quellcode:

      if bScanLines then
      begin
        QueryPerformanceCounter(timeDraw0);
        k := BuffBMP.Height - i - 1;
        P := BuffBMP.ScanLine[k];

        Move(P[OffsetX], P[0], (BuffBMP.Width - OffsetX));

        for m := 0 to pred(OffsetX) do
          P[BuffBMP.Width - OffsetX + m] := Value;

        QueryPerformanceCounter(timeDraw1);
        timeDraw := timeDraw + (timeDraw1-timeDraw0);
      end

Da muss ich wohl noch was Tüfteln :)

gruss

[Neutral General]

Okay war bei Scanline nicht das Problem dass du in erster Linie vertikal zeichnen musst?
Wie wärs wenn du das Bitmap um 90° gedreht zeichnest. Also statt

|||||||||||||||||||||||||||||||||||||||||

so:

_
_
_
_
_
_
_

Und dann kannst du das Bitmap per PlgBlt um 90° gedreht dahin zeichnen wo es auftauchen soll.
ScanLine würde ich dann wieder mit pf32Bit versuchen.

Delphi-Quellcode:

// Malt das Bitmap um 90° nach rechts gedreht auf ein Canvas
procedure DrawRotated90(ABitmap: TBitmap; ACanvas: TCanvas; AX, AY: Integer);
var RotatePoints: Array[0..2] of TPoint;
begin
  RotatePoints[0] := Point(ABitmap.Height+AX, AY);
  RotatePoints[1] := Point(ABitmap.Height+AX, ABitmap.Width+AY);
  RotatePoints[2] := Point(AY, AY);
  PlgBlt(ACanvas.Handle, RotatePoints[0], ABitmap.Canvas.Handle, 0, 0, ABitmap.Width, ABitmap.Height, 0, 0, 0);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  DrawRotated90(Image1.Picture.Bitmap, Canvas, 10, 10);
end;

[EWeiss]

Zitat:

ScanLine würde ich dann wieder mit pf32Bit versuchen.

Das geht leider nicht weil ich eine pf8Bit Palette verwende.
Die Farben der Palette werden also nicht geändert wenn ich pf32Bit verwende.


gruss

[Neutral General]

Ich rede ja davon in diesem Fall KEINE Palette mehr zu benutzen.
Die Palette benutzt du doch nur weil du hoffst dass es damit schneller geht oder?

Meine neue Idee für "schneller" ist halt 32-Bit "falschrum" malen und dann drehen.
Siehe meinen vorherigen Post

[EWeiss]

Zitat:

Zitat von Neutral General (Beitrag 1335211)

Ich rede ja davon in diesem Fall KEINE Palette mehr zu benutzen.
Die Palette benutzt du doch nur weil du hoffst dass es damit schneller geht oder?

Meine neue Idee für "schneller" ist halt 32-Bit "falschrum" malen und dann drehen.
Siehe meinen vorherigen Post

Nein diese benutze ich um zur Laufzeit die Farben des Spectrogram zu ändern.
Vordefinierte Farben also. ;)
Vorherige Version mit der Geschwindigkeit war ausreichend nur nach der Umstellung auf Paletten muss ich diese wieder optimieren
was die Geschwindigkeit angeht incl. der korrekten Farben Zuweisung.

gruss

[Neutral General]

Nagut dann eben 8-Bit. Sollte aber vom Prinzip genauso funktionieren.

[EWeiss]

Zitat:

Zitat von Neutral General (Beitrag 1335215)

Nagut dann eben 8-Bit. Sollte aber vom Prinzip genauso funktionieren.

Sorry nein weil es nicht verdreht ist und eine Rotation von 90 Grad in dem Fall nichts bringt.
Es ist umgekehrt.

Zitat:

Okay war bei Scanline nicht das Problem dass du in erster Linie vertikal zeichnen musst?

Ich zeichne vertikal.

gruss

[Neutral General]

Zitat:

Zitat von EWeiss (Beitrag 1335219)

Zitat:

Zitat von Neutral General (Beitrag 1335215)

Nagut dann eben 8-Bit. Sollte aber vom Prinzip genauso funktionieren.

Sorry nein weil es nicht verdreht ist und eine Rotation von 90 Grad in dem Fall nichts bringt.
Es ist umgekehrt.

Zitat:

Okay war bei Scanline nicht das Problem dass du in erster Linie vertikal zeichnen musst?

Ich zeichne vertikal.

gruss

Du verstehst mich scheinbar nicht.
Die Tatsache DASS du vertikal zeichnest bzw. zeichnen musst macht es ja so langsam weil du mit Scanline ja nur zeilenweise Zeichnen kannst.
Wenn du jetzt aber dein Bitmap um 90° drehst kannst du horizontal malen und Scanline effektiv benutzen. (siehe Anhang)
Damit es dann auf dem Bildschirm wieder richtig rum ist musst du das Bitmap da dann (z.B.) per PlgBlt zurückdrehen.

[EWeiss]

Zitat:

Du verstehst mich scheinbar nicht.

Kann sein..
In dem vorherigen Beispiel mache ich es auch nicht anders (falsch oder richtig das wäre dann die frage)
bin mir jetzt nicht so sicher weil hier mit Scanline die RGB Farben übergeben werden. Also eine ganz andere Sache.

Hier ist nochmal mein Code.. Variablen anders vergeben zum besseren Verständnis.
Ok zeichne Horizontal..

Delphi-Quellcode:

x: PByteArray;
Value: Byte;

....

Delphi-Quellcode:

      Value := round(Sqrt(Sqrt(Buffer[i + 1]) * 3 * BuffBMP.Width));

      if bScanLines then
      begin
        QueryPerformanceCounter(timeDraw0);
        k := BuffBMP.Height - i - 1;
        x := BuffBMP.ScanLine[k];

        Move(x[OffsetX], x[0], (BuffBMP.Width - OffsetX));

        x[BuffBMP.Width - OffsetX] := Value;

        QueryPerformanceCounter(timeDraw1);
        timeDraw := timeDraw + (timeDraw1-timeDraw0);
      end

Das Problem das ich habe ist das mein Bitmap dann umgekehrt nicht verdreht ist.
Also das was eigentlich vorne sein soll ist hinten..
Da nutzt auch ein drehen um 90 grad nichts.

Deine Vermutung das ich nicht vertikal zeichne mag das Problem mit meiner Performance sein.
Dem will ich nicht widersprechen.

EDIT:
Ok denke verstehe was du meinst.
Ich soll das leere Bitmap vorher drehen dann mit ScanLine Horizontal zeichen
und anschließend wieder zurück drehen.

Das kann ich aber nicht machen weil beim Fortschritt direkt gezeichnet wird. (sichtbar)

gruss

[himitsu]

Man kann alle Zeilenanfänge auch vorher einmal per Scanline besorgen und zwischenspeichern.
Mit einem eindimensionalen Array, hätte man dann eine zweidimensionale Matrix (ZeilenArray-Offset + Spalten-Offset).

Alle Zeilen liegen im Speicher hintereinander, allerdings oft gerne von unten nach oben
und im Speicher ausgerichtet (Alignment).
Heißt, daß man im Grunde nur einen Anfang bräuchte und die Pixelposition ausgerechnet werden könnte.


Oder, falls es hier geht und praktikabel ist, man dreht seine Zeichenfunktion, damit sie eben nicht Spalten, sondern Zeilenweise arbeitet.

[EWeiss]

Zitat:

Oder, falls es hier geht und praktikabel ist, man dreht seine Zeichenfunktion, damit sie eben nicht Spalten, sondern Zeilenweise arbeitet.

Ja wie von Michael vorgeschlagen.
Ist ohne ein zusätzliches Bitmap nicht ausführbar und zudem möchte ich ja den Fortschritt der Analysierung gleichzeitig visualisieren.

Zitat:

Man kann alle Zeilenanfänge auch vorher einmal per Scanline besorgen und zwischenspeichern.
Mit einem eindimensionalen Array, hätte man dann eine zweidimensionale Matrix (ZeilenArray-Offset + Spalten-Offset).

Da weiß ich nicht wie das gehen soll.
Die x Position bekomme ich ja erst durch die Value.

Delphi-Quellcode:

Value := round(Sqrt(Sqrt(Buffer[i + 1]) * 3 * BuffBMP.Width));

Danke.

gruss

[Neutral General]

Zitat:

Zitat von EWeiss (Beitrag 1335255)

Zitat:

Oder, falls es hier geht und praktikabel ist, man dreht seine Zeichenfunktion, damit sie eben nicht Spalten, sondern Zeilenweise arbeitet.

Ja wie von Michael vorgeschlagen.
Ist ohne ein zusätzliches Bitmap nicht ausführbar und zudem möchte ich ja den Fortschritt der Analysierung gleichzeitig visualisieren.

himitsu meint was anderes als ich. Bei mir wird das Bitmap gedreht und pro Zeile 1 der vertikalen Linie gezeichnet.
Himitsu schlägt vor das Bitmap so zu lassen wie es ist, aber eben nicht Linie für Linie vertikal zu zeichnen sondern zeilenweise von oben nach unten jeweils 1 Pixel jeder Linie zu zeichnen.

[EWeiss]

Zitat:

Himitsu schlägt vor das Bitmap so zu lassen wie es ist, aber eben nicht Linie für Linie vertikal zu zeichnen sondern zeilenweise von oben nach unten jeweils 1 Pixel jeder Linie zu zeichnen.

Ach so hab es falsch verstanden.
Destotrotz brauche ich die Aktuelle (x) in dem Fall dann die Y Position welche ich erst durch die Value erhalte.

Oder?

gruss

[himitsu]

Nee nee :zwinker:, er hat die Zeichenfläche gedreht und nach dem Zeichnen halt nochmal das fertige Bild.

Man kann aber manchmal auch das Zeichnen drehen und nicht das Blatt.

Es ginge auch mitten drinnen, das Drehen SetWorldTransform,
allerdings nicht hier, da hier ja an Allem vorbei direkt in den Speicher gegangen wird.

[EWeiss]

Hatte eigentlich gedacht es wäre schwieriger die RGB Werte zu analysieren.
So kann man sich irren.

In Realzeit wo nur eine Zeile ausgelesen und dann direkt gezeichnet wird ist das kein Problem
aber alles in einem Zug geht ganz schön auf die Geschwindigkeit beim einlesen.
Na ja wer hatte das gedacht. ;)

Bin wohl zu blöd dafür.
Sollte mich erst noch etwas mehr mit der eigentlichen Materie auseinandersetzen (ScanLIne) ;)

EDIT:
Mit dem umgedrehten Bitmap hab ich jetzt behoben.
Durch das Move jeder einzelnen Zeile dauert das aber nun ewig :)

gruss

[Zacherl]

Zitat:

Zitat von EWeiss (Beitrag 1335262)

Mit dem umgedrehten Bitmap hab ich jetzt behoben.
Durch das Move jeder einzelnen Zeile dauert das aber nun ewig :)

Kannst du die aktuelle Version des Projekts nochmal anhängen?

[himitsu]

Also intern lässt du dein Bild einfach im Hochformat.
Da kannst du auch ganz einfach verschieben, da dort ja komplette Scanlines kopiert/verschoben werden können.

Beim vertikal Scrollen wird in jeder Scanline der Inhalt um ein/paar Pixel nach links kopiert.

Und dann nur für die Ausgabe entweder per PlgBlt das Bild drehen und anzeigen,
oder über SetWorldTransform die Anzeige (das DC/TCanvas) drehen und dein Bild da im Hochformat rein malen.

Und "Anzeigen" auch immer nur den sichtbaren Bereich des internen Bildes.

[EWeiss]

Zitat:

Zitat von Zacherl (Beitrag 1335314)

Zitat:

Zitat von EWeiss (Beitrag 1335262)

Mit dem umgedrehten Bitmap hab ich jetzt behoben.
Durch das Move jeder einzelnen Zeile dauert das aber nun ewig :)

Kannst du die aktuelle Version des Projekts nochmal anhängen?

Ja gerne doch denn ich bekomme das nicht hin.. :oops:
Kann machen was ich will die Paletten funktionieren einfach nicht!

So sollte Scope aussehen (Realtime kein Problem) und schnell genug.
Aber als Komplettansicht schlägt das fehl.

http://home.arcor.de/weiss.em/Spectr...e_12_04_16.rar

gruss

[EWeiss]

Ich versuche immer noch den kram zu beschleunigen.

Delphi-Quellcode:

    for i := 0 to BuffBMP.Height - 1 do
    begin
      Value := round(Sqrt(Sqrt(Buffer[i + 1]) * 4 * BuffBMP.Width));

      if bScanLines then
      begin
        QueryPerformanceCounter(timeDraw0);

//        X := BuffBMP.ScanLine[BuffBMP.Height - i - 1];
//        Move(X[OffsetX], X[0], (BuffBMP.Width - OffsetX));

        for m := 0 to pred(OffsetX) do
          X[BuffBMP.Width - OffsetX + m] := Value;

        QueryPerformanceCounter(timeDraw1);
        timeDraw := timeDraw + (timeDraw1 - timeDraw0);
      end
      else
      begin
        QueryPerformanceCounter(timeDraw0);

        BuffBMP.Canvas.Pixels[ColumnCounter, BuffBMP.Height - i] := Value; //RGB(R, G, B);
        QueryPerformanceCounter(timeDraw1);
        timeDraw := timeDraw + (timeDraw1-timeDraw0);
      end;

    end;

Ich habe jetzt den Auskommentierten Teil in eine eigene Schleife gebunden.
Um beim zuweisen der Farben das ganze zu beschleunigen.

Delphi-Quellcode:

  for i := 0 to BuffBMP.Height - 1 do
  begin
    X := BuffBMP.ScanLine[BuffBMP.Height - i - 1];
    Move(X[OffsetX], X[0], (BuffBMP.Width - OffsetX));
  end;

Das geht relativ schnell, das Problem ist nur das bei der Übergabe der Value das Bitmap nicht gefüllt wird.
Eigentlich müsste es doch egal sein ob ich den Pointer vorher verschiebe anstatt in der Schleife zum ermitteln der Farben.

Wo ist mein Denkfehler?
In X müssten doch die richtigen Pointer liegen.

Delphi-Quellcode:

X: PByteArray;

gruss

[Medium]

Da sind dir irgendwo auf dem Weg die gepufferten Scanlines abhanden gekommen, und statt dessen in das PByteArray verwurschtelt, dass ein ganz anderes Ziel verfolgt.
Ich hätte da jetzt eher sowas in der Art gesehen:

Delphi-Quellcode:

var
  x: array of PByteArray;
begin
...
    SetLength(x, BuffBMP.Height);
    for i := 0 to BuffBMP.Height - 1 do
      x[i] := BuffBMP.Scanline[BuffBMP.Height-i-1];

    for i := 0 to BuffBMP.Height - 1 do
    begin
      Value := round(Sqrt(Sqrt(Buffer[i + 1]) * 4 * BuffBMP.Width));
      if bScanLines then
      begin
        QueryPerformanceCounter(timeDraw0);
        X[i][ColumnCounter] := Value;
        QueryPerformanceCounter(timeDraw1);
        timeDraw := timeDraw + (timeDraw1 - timeDraw0);
      end
      else
      begin
        QueryPerformanceCounter(timeDraw0);
        BuffBMP.Canvas.Pixels[ColumnCounter, BuffBMP.Height - i] := Value; //RGB(R, G, B);
        QueryPerformanceCounter(timeDraw1);
        timeDraw := timeDraw + (timeDraw1-timeDraw0);
      end;
    end;

Woher das xOffset und die Schleife mit "m" herkommen, ist mir ehrlich gesagt etwas schleierhaft gerade. Meiner Meinung nach braucht es die nicht, oder der Codeschnipsel war nicht ausreichend um die Notwendigkeit bzw. den Nutzen zu demonstrieren.

[EWeiss]

Zitat:

Woher das xOffset und die Schleife mit "m" herkommen, ist mir ehrlich gesagt etwas schleierhaft gerade.

Ich habe versucht meine frühere Routine (Realzeit) hier zu verwenden.
Der XOffset diente dazu Das Bitmap von verschiedenen Seiten zu zeichnen.

Zitat:

Da sind dir irgendwo auf dem Weg die gepufferten Scanlines abhanden gekommen, und statt dessen in das PByteArray verwurschtelt, dass ein ganz anderes Ziel verfolgt.
Ich hätte da jetzt eher sowas in der Art gesehen:

Vollkommen richtig und Danke dafür.
Durch das vorherige füllen des PByteArray ist die Geschwindigkeit nun genauso wie gewünscht.
Palette stimmt auch. War aber ein anderes Problem) ;)


gruss

[Blup]

Delphi-Quellcode:

BuffBMP.Canvas.Pixels[ColumnCounter, BuffBMP.Height - 1 - i] := Value; //RGB(R, G, B);

[EWeiss]

Zitat:

Zitat von Blup (Beitrag 1335838)

Delphi-Quellcode:

BuffBMP.Canvas.Pixels[ColumnCounter, BuffBMP.Height - 1 - i] := Value; //RGB(R, G, B);

Danke ist mir auch gestern noch aufgefallen..
Mein Fehler!

gruss