Bitmaps archivieren und laden?

[Rastaman]

Hallo.

Ich hatte vor für ein Spiel alle Bitmaps binär hintereinanderweg in eine Datei zu schreiben
und dann eben zur Laufzeit zu laden, damit nicht hunderte Bitmaps in Ordnern rumfliegen und auch leicht verändert werden können.
Das Problem ist allerdings, dass die Funktion, die zum Bitmapladen verwendet wird, nur einen Dateinamen als Parameter erwartet. Wie soll das gehen ohne temporäres Speichern?
Ich hab auch schon überlegt, alles in eine DLL zu verpacken als Resource und dann mit MAKEINTRESOURCE(???) als Dateinamen zu übergeben, allerdings geht das Programm dann
sofort und ohne Fehlermeldung aus :| Naja, das "Bitmaparchiv" wär mir sowieso lieber.

Jemand ne Idee?
Danke schonma :!:

[boserPascal]

Die WinApi bietet die Möglichkeit aus einem Bild, einen Bereich in eine Bitmap zu laden.

Die Funktion dafür ist unter anderen BitBlt!

[Rastaman]

Hi. Danke, aber danach suche ich nicht.
Ich habe ja ganz viele EINZELNE Bitmaps binär hintereinander in einer einzigen Datei gespeichert
und möchte diese gezielt auslesen. Hinzu kommt ja noch, dass ich als Parameter einen String und kein HDC oder HBITMAP angeben kann.

[Blackheart]

Erzählen kannst Du ja, zeig etwas Code !

[Pfoto]

Hallo Rastaman,

ich kann zwar direkt keine Lösung zu Deinem Problem
angeben, möchte dich aber auf eine Komponente hinweisen:
www.torry.net > SingleFileDataStorage

Damit können beliebige Dateien in einer Datei gespeichert
und bequem wieder ausgelesen werden.


Gruß
Pfoto

[Rastaman]

Hä was soll ich zeigen, wenn ich nix habe.
Ich habe noch gar kein Programm erstellt um bequem solche Dateien mit zig Bitmaps zu erstellen,
denn wieso auch, wenn ich nichtmal weiß, wie ich sie später laden soll?
Die Funktion zum Laden der Bitmap lautet übringens

Code:

SDL_Surface *SDL_LoadBMP(const char *file);

oder grob übersetzt

Delphi-Quellcode:

function SDL_LoadBMP(file: String): PSDL_Surface;

Is ja eigentlich auch egal, denn ich muss wissen wie ich diese Bitmap, die sich irgendwo in einer
großen Datei befindet, die voll ist mit Bitmaps, so präpariere, dass ich sie mit dieser Funktion laden kann.

[Blackheart]

Zitat:

Zitat von Rastaman

Hi. Danke, aber danach suche ich nicht.
Ich habe ja ganz viele EINZELNE Bitmaps binär hintereinander in einer einzigen Datei gespeichert
und möchte diese gezielt auslesen. Hinzu kommt ja noch, dass ich als Parameter einen String und kein HDC oder HBITMAP angeben kann.

Das hab Ich damit gemeint... zwecklos

[Luckie]

Lad das große Bitmap in ein TBitmap und kopier dir dann den Teil, den brauchst, aus dem Canvas des gro0en Bitmaps raus.

[Rastaman]

Zitat:

Zitat von Blackheart

Zitat:

Zitat von Rastaman

Hi. Danke, aber danach suche ich nicht.
Ich habe ja ganz viele EINZELNE Bitmaps binär hintereinander in einer einzigen Datei gespeichert
und möchte diese gezielt auslesen. Hinzu kommt ja noch, dass ich als Parameter einen String und kein HDC oder HBITMAP angeben kann.

Das hab Ich damit gemeint... zwecklos

Brauchst ja nich gleich frech werden. Wenn du nicht verstehst was das bedeutet
kannst du mir sowieso nicht helfen. Aber bitte ...

Code:

---Bilderarchiv1.ba
  - BMP_Gehweg.bmp
  - BMP_Gras.bmp
  - BMP_Wand.bmp
---

So sind meine Bitmaps gespeichert. Einfach binär hintereinander weg.
Dann kommt die Funktion zum Laden der Bitmaps, die als Parameter einen DATEINAMEN, nichts weiter, erwartet.
Wie kann ich jetz z.B BMP_Gras.bmp Laden, ohne eine temporäre Bitmap auf der Festplatte zu erstellen.
Sprich ...

Code:

Erstelle neue Bitmap BMP_Gras.bmp.tmp
Schreibe Datei voll mit den Daten aus Bilderarchiv1.ba
Lade Datei mit SDL_LoadBMP(BMP_Gras.bmp.tmp)
Lösche BMP_Gras.bmp.tmp

Ist wahrscheinlich nicht nur uneffizient sondern auch unschön.

[Rastaman]

Zitat:

Zitat von Luckie

Lad das große Bitmap in ein TBitmap und kopier dir dann den Teil, den brauchst, aus dem Canvas des gro0en Bitmaps raus.

Roter Kasten :roll:

Nene so gehts ja nicht. Ist wie bei deinem SFX-Archiven. Die Dateien sind einfach hintereinander weg
gespeichert. Es ist ja nicht ein Bild, also eine große Bitmap. Und selbst dann, wenn ich es nach deiner Methode machen
würde, müsste ich die Datei zwischenspeichern auf Festplatte, weil eben ein Dateiname erwartet wird. Das ist ja das Problem :stupid: Ich hab das blöde Gefühl es geht gar nicht ohne Zwischenspeichern :(

[Sunlight7]

Moin!

Kannst Du wirklich nicht direkt auf das Zielbitmap zugreifen?

Also ich hatte eine ähnliche Situation beim Programmieren eines großen Spieles.
Dazu hab ich "einfach" ein Dateiformat entwickelt, so das die Bitmaps auch gleich komprimiert in eine Datei gespeichert werden.
Dazu wurden gleichen nach dem Dateikopf eine Liste mit den Namen und eine Liste mit den Addresen und Größen in die Datei gespeichert.
Um die Datei aber net immer gleich machen zu müssen guckt der Loader nach, ob eine Datei mit dem gleichen Namen in einem Unterordner gleichen Namens wie die das Archiv heißt existiert und lädt diese falls vorhanden.

Wenn Du tatsächlich nur von Dateien laden kannst, könntest Du ja noch immer die Daten in eine temporäre Datei schreiben und Dir FILE_ATTRIBUTE_TEMPORARY von CreateFile ansehen.

Grüße, Sunlight7

[Rastaman]

Hi Sunlight. Das hört sich ja schonmal echt gut an :thumb:
Allerdings scheint das nicht zu klappen :(
Ich hab mal versucht das anzuwenden am Beispiel einer einzigen Bitmap die einfach im Ordner liegt und 3128 Bytes groß ist. Allerdings geht das Programm einfach wieder ohne Meldung aus.
Hier mal nach Delphi übersetzt was ich probiert hab.

Delphi-Quellcode:

var
  hTmp, hBitmap: THandle;
  Buf: Array [0..3127] of Byte;
  Dummy: DWORD;
begin
  // Die Bitmap öffnen
  hBitmap := CreateFile("bitmap2.bmp", FILE_READ_DATA, 0, nil, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nil);
  // Temporäre Datei erstellen
  hTmp := CreateFile("bitmap_tmp.bmp", FILE_READ_DATA or FILE_WRITE_DATA, 0, nil, CREATE_ALWAYS, FILE_ATTRIBUTE_TEMPORARY or FILE_FLAG_DELETE_ON_CLOSE, nil);

  ReadFile(hBitmap, Buf, SizeOf(buf), @Dummy, nil);
  WriteFile(hTmp, Buf, Dummy, @Dummy, nil);

  Player (* SDL_Surface *) := SDL_LoadBMP('bitmap_tmp.bmp');
  CloseHandle(hTmp);
  CloseHandle(hBitmap);

Bei dem @ vor den "Dummys" bin ich mir jetzt nicht so sicher.
Was mach ich falsch?

Edit:
Wenn ich anstatt FILE_ATTRIBUTE_TEMPORARY or FILE_FLAG_DELETE_ON_CLOSE einfach FILE_ATTRIBUTE_NORMAL nehme wird die Bitmap im Projektverzeichnis erstellt
und sieht einwandfrei aus :gruebel:

Edit2 und 3: Übersetzungsfehler beseitigt.

[guidok]

Hast du schon mal über einen Filestream nachgedacht?

Da könntest du deine Daten hintereinander rein schreiben und auch wieder lesen.

Nachteil ist, da du ja kein "Inhaltsverzeichnis" hast, musst du alle Bitmaps durchgehen bis du das gefunden hast, welches du möchtest.

Also beim Speichern:

1. zuerst einen String mit dem Namen des Bitmap speichern
2. danach das Bitmap selbst abspeichern
3. wieder einen Namen, usw.

Ich habe sowas mal gemacht, weil ich gemischte Daten (u.a. auch Bitmaps) in einer Datei halten wollte. Im Unterschied zu deiner Anforderung lade ich allerdings die gesamte Datei wieder zurück.

Delphi-Quellcode:

procedure TCardset.ReadFromFile(Filename: string);
var
  lFs: TFileStream;
  lMs: TMemoryStream;
  lLen: Longint;
  lI: Integer;
begin
  Free;
  lFs:=TFileStream.Create(Filename,fmOpenRead);
  lMs:=TMemoryStream.Create;
  try
    //Länge des Cardset
    lFS.Read(lLen,SizeOf(lLen));
    SetLength(Cards,lLen);
    //Die Daten des Cardset speichern
    for lI := 0 to Length(Cards) - 1 do begin
      //Bitmap
      lMs.Clear;
      lFs.Read(lLen,SizeOf(lLen));
      lMs.CopyFrom(lFs,lLen);
      Cards[lI].Bitmap:=TBitmap.Create;
      lMs.Position:=0;
      Cards[lI].Bitmap.LoadFromStream(lMs);
      //Strings
      lFs.Read(lLen,SizeOf(lLen));
      SetLength(Cards[lI].Name,lLen);
      lFs.Read(PChar(Cards[lI].Name)^,lLen);
      lFs.Read(lLen,SizeOf(lLen));
      SetLength(Cards[lI].Kind,lLen);
      lFs.Read(PChar(Cards[lI].Kind)^,lLen);
      lFs.Read(lLen,SizeOf(lLen));
      SetLength(Cards[lI].Description,lLen);
      lFs.Read(PChar(Cards[lI].Description)^,lLen);
      lFs.Read(lLen,SizeOf(lLen));
      SetLength(Cards[lI].Action,lLen);
      lFs.Read(PChar(Cards[lI].Action)^,lLen);
    end;
  finally
    lFS.Free;
    lMs.Free;
  end;
end;

procedure TCardset.SaveToFile(Filename: string);
var
  lFs: TFileStream;
  lMs: TMemoryStream;
  lLen: Longint;
  lI: Integer;
begin
  lFs:=TFileStream.Create(Filename,fmCreate);
  lMs:=TMemoryStream.Create;
  try
    //Länge des Cardset
    lLen:=Length(Cards);
    lFs.Write(lLen,SizeOf(lLen));
    //Die Daten des Cardset speichern
    for lI := 0 to Length(Cards) - 1 do begin
      //Bitmap
      lMs.Clear;
      Cards[lI].Bitmap.SaveToStream(lMs);
      lMs.Position:=0;
      lLen:=lMs.Size;
      lFs.Write(lLen,SizeOf(lLen));
      lFs.CopyFrom(lMs,lLen);
      //Strings
      lLen:=Length(Cards[lI].Name);
      lFs.Write(lLen,SizeOf(lLen));
      lFs.Write(PChar(Cards[lI].Name)^,lLen);
      lLen:=Length(Cards[lI].Kind);
      lFs.Write(lLen,SizeOf(lLen));
      lFs.Write(PChar(Cards[lI].Kind)^,lLen);
      lLen:=Length(Cards[lI].Description);
      lFs.Write(lLen,SizeOf(lLen));
      lFs.Write(PChar(Cards[lI].Description)^,lLen);
      lLen:=Length(Cards[lI].Action);
      lFs.Write(lLen,SizeOf(lLen));
      lFs.Write(PChar(Cards[lI].Action)^,lLen);
    end;
  finally
    lFs.Free;
    lMs.Free;
  end;
end;

[DP-Maintenance]

Dieses Thema wurde von "Matze" von "Programmieren allgemein" nach "Multimedia" verschoben.
Laut Profil nutzt du zwar Turbo C++, doch da hier Delphi-Codes gezeigt werden, verschiebe ich das Thema in eine Delphi-Sparte.

[Luckie]

Zitat:

Zitat von Rastaman

Zitat:

Zitat von Luckie

Lad das große Bitmap in ein TBitmap und kopier dir dann den Teil, den brauchst, aus dem Canvas des gro0en Bitmaps raus.

Roter Kasten :roll:

Nene so gehts ja nicht. Ist wie bei deinem SFX-Archiven. Die Dateien sind einfach hintereinander weg
gespeichert.

Dann benutz doch mein SFX Archiv, nur eben mit dem Unterschied, dass du die Daten an keine Exe anhängst eben. Meine Klassen solltest du so ohne großartige Änderungen verwenden können.

[Rastaman]

Hallo guidok.
Ich steig jetz so auf die Schnelle nicht da durch, aber es scheint auch so als würdest du die Datei auf der Platte speichern.
Genau das will ich ja nicht.
Ich habe übringts auch grad rausgefunden, dass FILE_ATTRIBUTE_TEMPORARY genau das Gleiche bewirkt wie FILE_ATTRIBUTE_NORMAL :gruebel:
Ich dachte TEMPORARY legt das irgendwie im Speicher an oder was weiß ich, aber so bringt es mich ja wieder nicht weiter.
Es scheint wirklich keine Möglichkeit zu geben ausser mit temporären Dateien auf der HD :?

[Luckie]

Zitat:

Zitat von Rastaman

ausser mit temporären Dateien auf der HD :?

Lad das ganze doch in einen Stream, dann kannst du damit machen was du willst.

[guidok]

Äh, wie? Wo willst du denn deine Datei speichern, wenn nicht auf der Platten?

Ich beschreib mal kurz was ich mache:

In der Datei sollen die Daten für Spielkarten (war mal ne Spielidee) gespeichert werden. Die bestehen aus einem Bitmap und aus diversen Strings. Mein Wunsch war dabei, dass ALLE Karten in EINER Datei gespeichert sind.

Also zum Speichern:

1. Zuerst die Anzahl der Karten abspeichern
2. Die Datenlänge des ersten Bitmap abspeichern (notwendig zum Lesen)
3. Die Daten des Bitmap speichern
4. Die Datenlänge des ersten String abspeichern
5. Die Daten des ersten String abspeichern
6. Alle weiteren Daten einer Karte nach dem gleichen Verfahren abspeichern
7. Bei 2. beginnen, bis alle Karten gespeichert sind

Beim Lesen:

1. Die Anzahl der Karten lesen
2. Die Datenlänge der ersten Bitmap lesen
3. Die Daten des ersten Bitmap mit Hilfe der Datenlänge lesen
4. Die Datenlänge des ersten Strings lesen
5. Die Daten des ersten Strings lesen
6. Alle weiteren Daten einer Karten nach dem gleichen Verfahren lesen
7. Bei 2. beginnen, bis alle Karten gelesen sind

Zum Speichern verwende ich einen FileStream (Datei auf der Platte)
Intern verwende ich einen Memorystream als Puffer für EIN Bitmap, damit ich auf einfach Weise die Länge des Bitmap rauskriege. Das Bitmap bringt nämlich eine Methode "SaveToStream" schon mit. Danach schreibe ich die Daten aus dem Memorystream in den Filestream.

Wenn ich deine Intention richtig verstanden habe, dann möchtest du viele Bitmap in einer Datei speichern, also:

1. Anzahl der Bitmaps in den Stream schreiben
2. Länge des ersten Bitmapnamens schreiben
3. Daten des Bitmapnamens schreiben
4. Länge des ersten Bitmaps schreiben
5. Daten des Bitmaps schreiben
6. Bei 2. beginnen bis alle Bitmaps geschrieben sind

Zum Lesen:

1. Anzahl der Bitmaps im Stream lesen
2. Länge der ersten Namens lesen
3. Namen des ersten Bitmap lesen
4. Vergleichen, ob es der Name des gesuchten Bitmap ist, falls nein:
5. Länge des ersten Bitmap lesen
6. Zeiger des Stream um diese Länge auf den Namen des nächsten Bitmap setzen.
7. usw. usw.

[Rastaman]

Zitat:

Zitat von Luckie

Zitat:

Zitat von Rastaman

ausser mit temporären Dateien auf der HD :?

Lad das ganze doch in einen Stream, dann kannst du damit machen was du willst.

Ja gut, ich benutz C++ und da geht das schonmal nicht, aber es würd eh nicht klappen,
denn die Funktion SDL_LoadBMP erwartet einen Dateinamen und keinen Stream oder Ähnliches.
Da lag ja meine Hoffnung in CreateFile mit FILE_ATTRIBUTE_TEMPORARY, weil es sich so anhörte als würde
die Datei wie eine normale behandelt, aber existiert in Wahrheit nur im Speicher.

[Luckie]

Ich würde da mit einem Inhaltsverzeichnis arbeiten, wie ich es bei meinem SFX-Builder gemacht habe.

Auch in C++ gibt es Streams. Und wenn du die Funktion SDL_LoadBMP nuicht nutzen kannst, musst du mal gucken, ob es nicht eine gibt, der du einen Stream übergeben kannst. Ansonsten ginge noch CreateFile mit dem Attribut FILE_ATTRIBUTE_TEMPORARY:

Zitat:

A file is being used for temporary storage. File systems avoid writing data back to mass storage if sufficient cache memory is available, because an application deletes a temporary file after a handle is closed. In that case, the system can entirely avoid writing the data. Otherwise, the data is written after the handle is closed.

[Rastaman]

Zitat:

Zitat von Luckie

Ich würde da mit einem Inhaltsverzeichnis arbeiten, wie ich es bei meinem SFX-Builder gemacht habe.

Hatte ich auch vor.

Zitat:

Zitat von Luckie

Auch in C++ gibt es Streams. Und wenn du die Funktion SDL_LoadBMP nuicht nutzen kannst, musst du mal gucken, ob es nicht eine gibt, der du einen Stream übergeben kannst.

Nein. Selber schreiben wird schwierig, denn die Funktion füllt diese Struktur

Code:

typedef struct SDL_Surface {
   Uint32 flags;            /* Read-only */
   SDL_PixelFormat *format;      /* Read-only */
   int w, h;            /* Read-only */
   Uint16 pitch;            /* Read-only */
   void *pixels;            /* Read-write */
   int offset;            /* Private */

   /* Hardware-specific surface info */
   struct private_hwdata *hwdata;

   /* clipping information */
   SDL_Rect clip_rect;         /* Read-only */
   Uint32 unused1;            /* for binary compatibility */

   /* Allow recursive locks */
   Uint32 locked;            /* Private */

   /* info for fast blit mapping to other surfaces */
   struct SDL_BlitMap *map;      /* Private */

   /* format version, bumped at every change to invalidate blit maps */
   unsigned int format_version;      /* Private */

   /* Reference count -- used when freeing surface */
   int refcount;            /* Read-mostly */
} SDL_Surface;

:wink:

Zitat:

Zitat von Luckie

Ansonsten ginge noch CreateFile mit dem Attribut FILE_ATTRIBUTE_TEMPORARY:

Wurde ja schon vorgeschlagen und ich habs auch schon ausprobiert (s.o) aber irgendwie scheint das das Gleiche zu bewirken,
als wenn ich die Datei ganz normal erstelle mit FILE_ATTRIBUTE_NORMAL, denn sie wird einfach in den Ordner der .exe geschrieben (also auf HD, was ich ja eigentlich durch FILE_ATTRIBUTE_TEMPORARY vermeiden möchte (Oder habe ich den Zweck dieses Flags falsch verstanden?)). Oder mach ich was falsch in meinem Versuch oben?

MFG
Rasta

[shmia]

Du hast zwei grundsätzliche Probleme:
1.) Wenn alle Bitmapdateien ohne Klebstoff zu einer grossen Datei verkettet werden,
dann geht jegliche Information verloren, wo BitmapA aufhört und BitmapB beginnt
(bei strukturierten Bildformaten wie z.B. TIFF könnte man die Grenzen finden)

2.) Natürlich gehen auch alle Informationen über den Namen der Bitmaps verloren
=> du brauchst eine Art FileStruktur in einer einzigen Datei
Es gibt flache Strukturen (z.B. TAR) oder hierarchische Strukturen.
Du kannst dir selbst eine Struktur ausdenken (würde ich nicht empfehlen) oder einen Standard verwenden.

Dein nächstes Problem ist das Laden eines Bitmap aus dem Speicher; in Delphi geht das ganz einfach.
Die eigentliche Laderoutine procedure TBitmap.ReadDIB(Stream: TStream; ImageSize: LongWord) ist sehr komplex.
Wenn also TurboC++ keine vergleichbare Routine (spez. TBitmap.LoadFromStream()) anbietet, dann müsstest du die VCL Teile nach C++ portieren.

[Rastaman]

Irgendwie versteht keiner das eigentliche Problem :-D
Die Funktion die zum Laden der Bitmap verantwortlich ist erwartet einen Dateinamen.
Ich möchte aber die Bitmaps die ich aus dem Archiv hole NICHT auf Festplatte zwischenspeichern.
Aber mir wird langsam klar, dass ich wohl keine andere Wahl habe.

[Sunlight7]

Versteh ich wirklich net, ich habe mir mit C++ mal eine DirectX 3.0 Schnittstelle gebastelt, und die Bitmpas via CreateDIBSection aus den Daten der Datei geladen.

Was hindert Dich daran, das Bitmap erzeugen selber in die Hand zu nehmen?

Edit: Tags vergessen

[guidok]

Ich glaub ich habs verstanden, aber vielleicht auch nicht ganz...

Du hast eine fertige Funktion SDL_LoadBMP und genau die willst du verwenden und genau die erwartet einen Dateinamen einer Bitmap, den sie von der Platte laden möchte.

Naja, dann ist ja wohl klar, dass diese Funktion auch auf die Platte zugreift. Ich kenne diese Funktion nicht (hab eh übersehen, dass es sich um C++ handelt, da kann ich nicht weiterhelfen), aber anscheinend hast du die nicht selbst gebastelt und bist auch nicht gewillt, dir eine Funktion selbst zu basteln die das Bitmap eben aus einer großen Katalogdatei läd.

Gabs da nicht mal so eine Art RAM-Disk? Vielleicht kannst du dein Bitmap mit einer EIGENEN Funktion aus dem Katalog laden und temporär auf der "RAM-Disk" speichern. Bei SDL_LoadBMP musst du dann halt im Dateipfad (den wird sie ja wohl auch noch erwarten) als Laufwerk die RAM-Disk angeben.

Gruß,

Guido

[Lossy eX]

@Rastaman: SDL bietet auch eine Funktion namens SDL_LoadBMP_RW. Du kannst mit SDL_RWFromFile (geht auch von C++ FilePointer bzw Mem) ein RWops erstellen in diesem eine Position anwählen und dann problemlos das BMP ab dieser Stelle in deiner Datei laden. Da brauchst du keine temporären Dateien benutzen und verlässt SDL nicht wodurch es automatisch Platformunabhängig bleibt.

PS: Zusätzliche Strukturinfos lassen sich auch problemlos mit dem RWops laden, da du auch einzelne Bytes etc auslesen kannst.

[Rastaman]

Danke! Das isses :thumb: