Objekte einer TObjectList direkt aus dem Speicher lesen / in ihn schreiben

[Benmik]

Ich habe eine generische TObjectList, in der u.a. auch Vorschaubilder als TBitmap gespeichert sind. Ich möchte diese Vorschaubilder gern auf der Platte speichern, damit sie nicht jedes Mal unnötiger Weise erstellt werden müssen.

Ich habe jetzt eine funktionierende Lösung, die mit Streams arbeitet. Nachteil nur, dass nach dem Wiedereinlesen in die TObjectList bestimmte Bilder auf dem Kopf stehen. Das hängt meiner Vermutung nach damit zusammen, dass bei Bitmaps gern bei der untersten Scanline angefangen wird und nicht bei der obersten. Ich weiß, dass ich den Bitmap-Header auslesen könnte, um die Leserichtung zu ermitteln.

Meine Idee wäre jetzt aber: Die Bitmap liegt doch im Speicher exakt so vor, wie sie richtig ist. Kann ich sie nicht einfach als einfache Bytes unter Umgehung aller Bitmap-Routinen in einen Stream schreiben und - das vor allem - aus dem (File-)Stream wieder in die Objektliste?

[Sir Rufo]

Wie speicherst du die Bitmaps denn jetzt?

[Benmik]

Delphi-Quellcode:

  procedure SchreibeBilderListeInDB;
  var BildNr:integer; Writer: TWriter; Stream : TFileStream; 
  begin
    Try
      Stream := TFileStream.Create(Dateiname,fmCreate);
    Except
      exit;
    End;
    Writer := TWriter.Create(Stream,4096);
    Try
      Writer.WriteListBegin;
      // Anzahl Datensätze
      Writer.WriteInteger(Bilderliste.Count);
      For BildNr := 1 to BilderListe.Count do 
        WriteBitmapToWriter(Bilderliste[BildNr - 1].VSB,Writer);
      Writer.WriteListEnd;
      Writer.FlushBuffer;
    Finally
      Stream.Free;
      Writer.Free;
    End;
  end;

procedure WriteBitmapToWriter(Bmp: TBitmap; Writer: TWriter);
var Stream: TMemoryStream;
//-----------------------------------------------------------------------------------------------------------------------------
  procedure WriteStreamToWriter(Stream: TMemoryStream; Writer: TWriter);
  const
    BufBytes = 1024*16; // 16 Kb
  var
    ReadBytes: Integer;
    Buf: array [0..BufBytes-1] of Byte;
  begin
    Stream.Position := 0;
    Writer.WriteInteger(Int64(Stream.Size));
    while Stream.Position < Stream.Size do
    begin
      ReadBytes := Stream.Read(Buf, BufBytes);
      Writer.Write(Buf, ReadBytes);
    end;
  end;
//-----------------------------------------------------------------------------------------------------------------------------
begin
  Stream := TMemoryStream.Create;
  try
    Bmp.SaveToStream(Stream);
    WriteStreamToWriter(Stream, Writer);
  finally
    Stream.Free;
  end;
end;

Die exakte Größe der Bitmap im Speicher müsste nach GetDIBSizes(Bmp.Handle, InfoHeaderSize, ImageSize); InfoHeaderSize + ImageSize sein. Ich stelle mir also vor, diese Anzahl Bytes ab Addr(Bilderliste[BildNr - 1].VSB) auszulesen und in eine Datei zu schreiben. Lesen kann auch kein Problem sein. Aber wie schreibe ich die Bytes in den Speicher? Speicher reservieren, Bytes reinschreiben, und dann den Pointer von Bilderliste[BildNr - 1].VSB auf diese Adresse setzen oder wie?

[Sir Rufo]

Also wenn ich Bitmaps aus einer Liste in einen Stream speichern wollte, dann würde ich das so machen:

Delphi-Quellcode:

procedure TBitmapList.SaveToStream( AStream: TStream );
var
  idx: Integer;
begin
  AStream.WriteData( Count );
  for idx := 0 to Count - 1 do
    Self[ idx ].SaveToStream( AStream );
end;

Das Lesen ist etwas aufwändiger (aber nicht wirklich)

Delphi-Quellcode:

procedure TBitmapList.LoadFromStream( AStream: TStream );
var
  idx, lCount: Integer;
  lBitmap    : TBitmap;
begin
  Clear;
  AStream.ReadData( lCount );
  for idx := 0 to lCount - 1 do
    begin
      lBitmap := TBitmap.Create;
      try
        lBitmap.LoadFromStream( AStream );
        Add( lBitmap );
        lBitmap := nil;
      finally
        lBitmap.Free;
      end;
    end;
end;

und zur Vollständigkeit

Delphi-Quellcode:

type
  TBitmapList = class( TObjectList<TBitmap> )
  public
    procedure SaveToStream( AStream: TStream );
    procedure LoadFromStream( AStream: TStream );
  end;

[Benmik]

Eine sehr schöne, kurze und elegante Lösung - aber die Bilder stehen nach dem Einlesen aus der Datei auf dem Kopf.
Das muss mit den Bitmap-Routinen zu tun haben, die ich aus diesem Grund ja vermeiden wollte.

Ich habe mir mittlerweile einen Weg gebastelt, die Bytes direkt in einen Stream zu schreiben und sie dann auch wieder auszulesen.
Das Schreiben funktioniert auch, aber - obwohl die Anzahl der Bytes genau stimmt - meldet Delphi beim Einlesen "Ungültiges Bitmap".
Ich werde morgen die Routinen mal nach deinem Vorbild anpassen und dann sehen, ob es funktioniert.
Vielen Dank einstweilen.

[Uwe Raabe]

Zitat von Benmik:

Eine sehr schöne, kurze und elegante Lösung - aber die Bilder stehen nach dem Einlesen aus der Datei auf dem Kopf.
Das muss mit den Bitmap-Routinen zu tun haben, die ich aus diesem Grund ja vermeiden wollte.

Es ist aber auch nicht auszuschließen, daß das gar nichts mit dem Speichern und Laden zu tun hat. Nach einem TBitmap.SaveToStream und TBitmap.LoadFromStream hat die Bitmap exakt denselben Inhalt wie zuvor. Ich vermute also einen anderen Grund für das auf-den-Kopf-stellen.

[Blup]

Zitat von Benmik:

Die Bitmap liegt doch im Speicher exakt so vor, wie sie richtig ist. Kann ich sie nicht einfach als einfache Bytes unter Umgehung aller Bitmap-Routinen in einen Stream schreiben und - das vor allem - aus dem (File-)Stream wieder in die Objektliste?

Das Delphi-TBitmap-Object kapselt eigentlich nur ein Handle eines Windows-GDI-Bitmaps.
Die eigentlichen Daten verwaltet das GDI (BitmapInfoHeader, Palette, Buffer der Pixeldaten), die liegen also nicht alle zusammen schön geordnet in einem Speicherbereich.

Wenn man die Pixeldaten per Scanline einlesen möchte, vorher also mindestens diese Schritte:
- Erzeugen der TBitmap-Instance
- Setzen von Pixelformat, Breite, Höhe

[uligerhardt]

Zitat von Sir Rufo:

Delphi-Quellcode:

      lBitmap := TBitmap.Create;
      try
        // ...
        lBitmap := nil;
      finally
        lBitmap.Free;
      end;

Das gibt ein Memory leak, wenn ich mich nicht sehr irre.

[Uwe Raabe]

Zitat von uligerhardt:

Zitat von Sir Rufo:

Delphi-Quellcode:

      lBitmap := TBitmap.Create;
      try
        // ...
        lBitmap := nil;
      finally
        lBitmap.Free;
      end;

Das gibt ein Memory leak, wenn ich mich nicht sehr irre.

Nur, wenn die ObjectList, der direkt vor der nil-Zuweisung die Bitmap-Instanz zugefügt wird, diese nicht frei gibt.

[Sir Rufo]

Zitat von uligerhardt:

Zitat von Sir Rufo:

Delphi-Quellcode:

      lBitmap := TBitmap.Create;
      try
        // ...
        lBitmap := nil;
      finally
        lBitmap.Free;
      end;

Das gibt ein Memory leak, wenn ich mich nicht sehr irre.

Nein, so sieht das Standard-Muster aus, wenn man das Lifetime-Management der Instanz delegiert.

Delphi-Quellcode:

      lBitmap := TBitmap.Create;
      try
        // Übergabe des Lifetime-Managements
        ...
        // Jetzt bin ich nicht mehr verantwortlich
        lBitmap := nil;
      finally
        lBitmap.Free;
      end;