Optimierung von Pixel

[EWeiss]

Zitat:

Reine Schätzung, aber Canvas.ScanLine ist locker um den Faktor 1000 schneller (eher mehr).

Ist es möglich das ScanLine etwas oder sehr überschätzt wird.
Kann nicht wirklich eine verbesserte Geschwindigkeit feststellen.

Das analysieren einer MP3 "Pink Floyd - Echoes"

1. Zeit: 00:16:30
2. Größe: 37 MB
3. Frequenz: 44k1
4. Bitrate: 320k

ScanLine: 109138 ticks
Pixel: 109404 ticks

Also um beim Faktor 1000 mal schneller zu bleiben
sollte ScanLine eigentlich 109.138 Ticks betragen

Also irgendwie :(

gruss

[Valle]

Welche der genannten Methoden hast du denn für deine Messung verwendet?

Ich bin mir sicher dass man das noch verbessern kann, aber dafür müssten wir hier wohl mehr Details kennen.

Auch wundere ich mich etwas, ob die Methode von Medium wirklich funktioniert. Damit hat man ja einen ScanLine-Aufruf pro Pixel. Ich weiß nicht genau was ScanLine im Hintergrund macht, aber ich wäre davon ausgegangen, dass genau der Wegfall dieser vielen Aufrufe einen Großteil des Performancegewinn ausmacht. :gruebel:

[Zacherl]

Mediums Funktion ist sogar LANGSAMER als

Delphi-Quellcode:

Canvas.Pixels

:lol: Mein Testcode

Delphi-Quellcode:

var
  B: TBitmap;
  X, Y: Integer;
  P: PRGBTriple;
  C: Cardinal;
begin
  B := TBitmap.Create;
  try
    B.PixelFormat := pf24Bit;
    B.Width := 2000;
    B.Height := 2000;
    // Canvas.Pixels
    C := GetTickCount;
    for Y := 0 to B.Height - 1 do
    begin
      for X := 0 to B.Width - 1 do
      begin
        B.Canvas.Pixels[X, Y] := clRed;
      end;
    end;
    ShowMessage(IntToStr(GetTickCount - C));   // 1141ms
    // Custom SetPixel method by Medium
    C := GetTickCount;
    for Y := 0 to B.Height - 1 do
    begin
      for X := 0 to B.Width - 1 do
      begin
        SetPixel(B, X, Y, clRed);
      end;
    end;
    ShowMessage(IntToStr(GetTickCount - C));   // 1391ms
    // Bitmap.ScanLine
    C := GetTickCount;
    for Y := 0 to B.Height - 1 do
    begin
      P := B.ScanLine[Y];
      for X := 0 to B.Width - 1 do
      begin
        P^.rgbtRed   := 255;
        P^.rgbtGreen := 0;
        P^.rgbtBlue  := 0;
        Inc(P);
      end;
    end;
    ShowMessage(IntToStr(GetTickCount - C));  //    15ms
  finally
    B.Free;
  end;
end;

produziert folgendes Ergebnis:

Code:

1141ms - Canvas.Pixels
1391ms - SetPixel by Medium
  15ms - ScanLine

[stahli]

@Emil

Bei Performanceproblemen hat mit AQTime Pro schon gut geholfen.
Da kann man sogar einzelne Zeilen messen lassen.

Nur man sollte es nicht in die Delphi-IDE Einbinden, sondern extern nutzen.

[EWeiss]

Zitat:

Zitat von stahli (Beitrag 1335033)

@Emil

Bei Performanceproblemen hat mit AQTime Pro schon gut geholfen.
Da kann man sogar einzelne Zeilen messen lassen.

Nur man sollte es nicht in die Delphi-IDE Einbinden, sondern extern nutzen.

Danke für die Info :)
Aber eigentlich sollte doch GetTickCount ausreichend sein

Zitat:

Mein Testcode

Danke werde deine Variante mal testen.

gruss

[Medium]

Canvas.Pixels[] ruft intern die WinAPI Funktion SetPixel auf. Scanline macht zwar auch einen API Call (GDIFlush), aber dennoch ist es erheblich schneller als SetPixel. Klar, der "saubere" Weg wäre es mit nur einem Mal Scanline abrufen und ab dann nur noch den Pointer inkrementieren. Aber dennoch sollte der Unterschied sehr deutlich ausfallen.

Misst du eventuell das Berechnen der FFT mit? Weil das dürfte bei so einem langen Stück selbst mit den diversen optimierten FFTs recht lange dauern.

Ansonsten mal so probieren:

Delphi-Quellcode:

var
  b: TBitmap; // Pufferbitmap um horizontal zeichnen zu können
  p0, p: PRGBTriple;
  c: TColor;
  points: array[0..2] of TPoint;
begin
  b := TBitmap.Create;
  b.PixelFormat := pf24Bit;
  b.SetSize(BUFFER_SIZE, 1);
  p0 := b.Scanline[0];
...
    while BASS_ChannelIsActive(Channel) <> BASS_ACTIVE_STOPPED do begin
        BASS_ChannelGetData(Channel, Pointer(Buffer), BASS_DATA_FFT512);
        p := p0;
        for i := 0 to BUFFER_SIZE - 1 do begin
            Value := SQRT(SQRT(Buffer[i]));
            H := 0 + Value / 1.5;
            L := Value;
            c := HSLtoRGB(H, S, L);

            p^.rgbtRed := GetRValue(c);
            p^.rgbtGreen := GetGValue(c);
            p^.rgbtBlue := GetBValue(c);
            Inc(p);
        end;
        points[0] := Point(ColumnCounter+1, 0);
        points[1] := Point(ColumnCounter+1, BUFFER_SIZE-1);
        points[2] := Point(ColumnCounter, 0);
        PlgBlt(Image1.Picture.Bitmap.Canvas.Handle, points, b.Canvas.Handle, 0, 0, b.Width, b.Height, 0, 0, 0); // b gedreht an die richtige x-Position auf das Image malen
        Inc(ColumnCounter);
        Progress := Trunc(100 * (BASS_ChannelGetPosition(Channel, BASS_POS_BYTE) / BASS_ChannelGetLength(Channel, BASS_POS_BYTE)));
        Form2.ProgressBar1.Position := Progress;
        Application.ProcessMessages;
    end;
...
  b.Free;

Nicht ganz getestet, aber zumindest die Punkte sollten so passen. ich weiss jetzt nicht, ob die Nutzung von PlgBlt schneller ist, oder alternativ das immer wieder neue Abholen der Scanline, aber einen Versuch ist es wert. (Da du ja progressiv immer spaltenweise zeichnest, müsste man eh die Scanline immer neu holen (oder den Stride selber behandeln).)

[Medium]

Roter Kasten:

Zitat:

Zitat von Zacherl (Beitrag 1335025)

Mediums Funktion ist sogar LANGSAMER als

Delphi-Quellcode:

Canvas.Pixels

Das wundert mich ehrlich gesagt, aber da ich keine konkreten Tests gemacht habe, nehme ich das mal so hin :)

[Zacherl]

Zitat:

Zitat von Medium (Beitrag 1335041)

Roter Kasten:

Zitat:

Zitat von Zacherl (Beitrag 1335025)

Mediums Funktion ist sogar LANGSAMER als

Delphi-Quellcode:

Canvas.Pixels

Das wundert mich ehrlich gesagt, aber da ich keine konkreten Tests gemacht habe, nehme ich das mal so hin :)

Hat mich selbst stark gewundert, weil der erste Aufruf von

Delphi-Quellcode:

ScanLine

den Bitmap-Buffer eigentlich cached. Allerdings werden da neben dem Anfordern des Buffers noch 100 andere Sachen in der Funktion gemacht, die ich mir jetzt nicht genauer angeschaut habe. Diese Funktionen werden wohl der Grund für den Performanceverlust sein.

[Valle]

Man könnte ja mal spaßeshalber eine Art Zwischenspeicher für das Ergebnis von ScanLine einführen.

Code:

if aY != old_aY:
    old_aY = aY
    scanlineResult = ScanLine(..., aY)
// mit scanlineResult weiter verfahren

[EWeiss]

Ich habe jetzt alle Varianten durch und lade das Projekt mal hoch. (Anhang gelöscht neue auf der nächsten Seite)

Seltsamer weise tut die Funktion von Zacherl nicht was sie soll.. Oder ich war zu blöd diese einzubinden.
Die neue von Medium liefert auch nicht das richtige Zeichnungs Resultat.

wäre schön wenn ihr das mal testen würdet.
alte Version ohne Änderung.

wundert mich schon warum der Kram so lange dauert bei analysieren.
Was nicht geht ist das auf die nächste Seite gesprungen wird.

PS:
Nicht wundern!
00:00:00 = Min,Sec,Ms

gruss