Datei von Datei exportieren?

[Newbie44]

Hallihallo,

ja, ich habe mal ein kleines problem, und zwar habe ich eine 250 mb große datei in der wave-daten drinnen sind, nur ich habe keine ahnung iwe ich daran kommen soll. nun habe ich festgestellt, das bei wavdateien immer RIFF davor steht, wäre es möglich, in der datei nach riff zu suchen und wenn eines gefunden wurde bis zum nächsten weitergesucht wird, und dann die einzelne wav-datei irgendwie exportiert wird?

bitte helft mir weiter

gruß

sebby :pale:

[fiasko]

Kommt doch darauf an wie die Daten abgelegt sind. Wo kommt den die 250mb Datei her?

Wenn du weißt was drinne sein sollte, hilft auch einfach mal mit einem Hex-Editor anzuschauen wie die abgelegt werden. Evtl. sind ja gleich noch Dateinamen und Dateigrößen enthalten.

[Newbie44]

Hallo,

die 250 MB datei habe ich von meinen bruder erhalten, er sagte ich solle gucken wie ich an die audiodateien komme (es ist nich von nen Spiel). Er sagte er habe die datei vor 10 jahren erstellt und vergessen wie man rankommt. Nun hat er mir noch die indexdatei dazu geschickt, vielleicht steht ja da drinnen, wo die dateien anfangen, hier mal ein ausschnitt in hex davon:

Code:

4D7573696B30322E776176000000000000000000B8F04B07

Vielleicht sind das ja irgendwelche adressen oder so?

gruß

sebby :gruebel: :pale:

[Luckie]

LOL. Damit wird hier wohl niemand was anfangen können. Ohne nähere Beschreibung was was zu bedeuten hat ist das nur Zahlenmüll und die Index-Datei völlig wertlos.

[MiniKeks]

Ich glaube es ist UNMÖGLICH das wiederherzustellen! Sonst könnte man ja einfach den Hex code einer exe anschauen und so den quellcode hervorzaubern :-D

PS: Waren es wichtige Sounds?

Gruss MiniKeks

[fiasko]

Zitat:

Zitat von Newbie44

Code:

4D7573696B30322E776176000000000000000000B8F04B07

Vielleicht sind das ja irgendwelche adressen oder so?

Vorschlag: du schaust in die 250MB Datei mit einem Hex-Editor nach wo denn eine wav Datei anfängt (anhand von RIFF oder wie die immer Anfangen). Die Adresse suchst du dann in der Index Datei (must gucken ob MSB oder LSB zuerst kommen) und kannst so vielelicht etwas rekonstruieren wenn du das für 2-3 Dateien durchspielst.

[gmarts]

Was für eine Dateierweiterung hat denn deine Datei. Vielleicht hilft ein altes Packprogramm?!...

[dizzy]

Schon mal auf die Idee gekommen die Indexdatei nicht mit einem Hex-Viewer anzuschauen? Sondern z.B. mal mit'm Editor? Als String heist die von dir gepostete Zeichenkette:

Code:

Musik02.wav {hier ein paar chr(0)} ¸ðK

:D

[Brüggendiek]

Hallo Sebastian!

Zitat:

Zitat von dizzy

Als String heist die von dir gepostete Zeichenkette:

Code:

Musik02.wav {hier ein paar chr(0)} ¸ðK

:D

und die letzen 4 Bytes könnten einen LongInt-Wert ergeben.

Bei den wenigen vorliegenden Daten kann man wirklich nur noch rumraten.

Nebenbei: aus einer uralten CD-ROM mit Fotos (und einem Viewer dazu, läuft auch unter Win3.11) fand ich neben Reklame für ein Bildschirmtext-Chatsystem (soo alt ist das Teil) auch die Bilddateien. Das scheinen BMPs mit ein paar Bytes davor zu sein. Habe ich aber aus Zeitmangel bisher nicht überprüft.

Nur so als Tipp gedacht - Vorspannbytes könnten auch irgendwo sein.

Als Ansatz würde ich jetzt so vorgehen, daß ich die Indexdatei in Häppchen der von Dir geposteten Länge zerlege und dabei nachsehe, was vor den Nullbytes steht (ist offensichtlich der Dateiname) und den Rest dann als Zahl ausgeben lasse. Dabei ruhig auch mal in Betracht ziehen, daß die Bytes vertauscht sein könnten.
Auch möglich: es sind 2 Werte mit je 2 Bytes Länge.
Möglich, daß die Zahl an irgendeiner Stelle die Länge der archivierten Datei enthält.
Vielleicht ergibt sich ja eine Systematik.
Das läuft auf eine langwierige Probiererei hinaus, aber ohne Fleiß kein Preis!

Gruß

Dietmar Brüggendiek

[Luckie]

In der Indexdatei scheinen Records zu stehen:

Delphi-Quellcode:

type
  TMyRecord = record
    Dateiname: String[55];  // Länge muss man durch probieren etc. rausfinden
    Dateilänge: Cardinal;
end;

[dizzy]

Klingt ziemlich plausibel!

[Brüggendiek]

Hallo!

Zitat:

Zitat von Luckie

Delphi-Quellcode:

type
  TMyRecord = record
    Dateiname: String[55];  // Länge muss man durch probieren etc. rausfinden
    Dateilänge: Cardinal;
end;

Möööp - Fehler!

Für ShortString fehlt doch wohl das Längenbyte - sollte also sein:

Delphi-Quellcode:

type
  TMyRecord = record
    Dateiname: Array [1..55] of Char;  // Länge muss man durch probieren etc. rausfinden
    Dateilänge: Cardinal;
end;

Allerdings gebe ich zu bedenken, daß bei so alten Dateien noch keine langen Dateinamen erwartet werden können. Die Dateinamen waren damals 8-3, also mit dem Punkt 12 Zeichen lang. Für lange Dateinamen (oder auch vollständige Pfadangaben) sind das eindeutig zu wenig Zeichen. Der Rest könnte irgendeine (möglicherweise unbenutzte oder hier unwichtige) Bedeutung haben.


Gruß

Dietmar Brüggendiek

[Luckie]

Ich wollte auch nur das Prinzip darlegen. Für einen genauren Aufbau des Records müsste man die Datei vorliegen haben und analysieren.

[dizzy]

Allerdings ergibt sich aus den letzen Bytes in (glaub ich) keiner Anordnung ein plausibler Wert für die Größe einer Wavedatei. Entweder sinds Gigabytes oder Kilobytes, und normal-lange Waves mit normal-langen Liedern sind idR so 30-60 MB groß - bei 44.1kHz Stereo 16Bit. (50MB ~5 Minuten (ein bisschen weniger))

[Luckie]

Evnetuell sind es ja nur kurze Sounds. Und bei minderer Qualität könnten es auch Lider sein.

[Newbie44]

Guten Morgen :hello: ,

gut, vom praktikum aus habe ich zwar keinen zugriff auf meine dateien zuahaus, doch ihr könntet rechthaben, es könnte echt die länge sein, mein bruder sagte es wären auch kurze sounds drinen (8 bit stereo 30 sek.) Aber wenn das die länge wäre, dann wäre es ja eigentlich einfach, man könnte doch teoretisch alle längen zusammenzählen um zum beispiel an die letzte datei zu kommen, 1. Dateilänge > 2. Dateilänge > 1. Dateilänge + 2. Dateilänge > 2. Dateilänge + 3. Dateilänge > usw.

Das wäre wirklich ne möglichkeit, gut, wenn ich heute abend wieder daheim bin und heute ist freitag :witch: , dann werde ich nochmal in die datei gucken ob es wirklich die größe ist.

Ich werde euch dann versuchen über meine nachforschunen zu informieren, aber gut :dancer2: .

Vielen dank schon jetzt, ihr habt mir schon sehr geholfen :thumb:

gruß


sebby :coder:

EDIT: Die normale datei hat die erweiterung *.bin und die indexdatei die erweiterung *.ind

[DelphiFreund]

Hi,
du könntest ja mithilfe eines FileStreams den zugehörigen Hex-Wert suchen, und die Dateien in neue Files schreiben, somit brauchst du die Indexdatei nicht.

Gruß DelphiFreund

[Newbie44]

Danke für den Tipp,

doch ich habe die indexdatei nochmal genau angeguckt und festgestellt, das beim ersten Eintrag 0000000000000000000 steht, und die zahl gegen ende immer größer wird, ich tippe darauf, das es die position in der großen datei anzeigt

was meint ihr

gruß

sebby

[dizzy]

Sehr sehr gut möglich dass es direkt ein Offset angibt, japp!

[Newbie44]

Moin,

ja, du hast recht es ist ein offset, aber die zahlen sind vertauscht, wenn man die z. B. B5E86401 ---> 0164E8B5

Dann kommt man genau zum header der datei.

Jetzt seit ihr gefragt, wie formuliere ich das ganze in delphi?

gruß

sebby :pale: :thumb: :gruebel:

[Luckie]

Zitat:

Zitat von Newbie44

ja, du hast recht es ist ein offset, aber die zahlen sind vertauscht, wenn man die z. B. B5E86401 ---> 0164E8B5

Da ist nichts vertauscht. Es dürfte sich nur um, ja wie war das noch mal, Intel benutzt das Little Endian Format und MAC zum Beispiel das Big Endian oder war es umgekehrt? Jedenfalls unterscheiden sich beide Formate dahingehen, dass die Werte im Speicher anders abgelegt werden.

Zitat:

Jetzt seit ihr gefragt, wie formuliere ich das ganze in delphi?

Warum wir? Du willst doch ein Programm schreiben, welches die Dateien extrahiert, nicht wir. :roll:

[Newbie44]

:cry: :cry: :cry: :cry: :cry:

Schade, ich habe sowas noch nie gemacht. Aber wenn ich das ganze mit 2 Filestreams machen würde, könnte es klappen, nur ich sehe ein problem, mit dem länge der datei, und zwar, müsste die datei ja nur bis zum nächsten offset gehen, mal gucken, vielleicht ist die selbe distanz zum nächsten offset

sebby :roll:

[Newbie44]

Jo, es ist die selbe distanz, immer 21 Zeichen bis zum nächsten offset

sebby :thumb:

[Luckie]

So, voll funktionstüchtiges Demo im Anhang. Die relevanten Routinen sind wiederverwendbar und es wird nur demonstriert, wie man sie einsetzt. Erklärungen befinden sich im Quellcode, die hardgecodeten Stellen sind markiert.

Delphi-Quellcode:

{************************************************************

  Demoprogramm für die Funktionen zum Einlesen der
  Indexdatei und zum extrahieren einer Dstei aus der
  Quelldatei.

  Anmerkungen:
  ============

  Die Funktion ReadIndexFile liest die Indexdatei aus
  und gibt ein Array vom Typ TFileInfos zurück.
  TFileInfos ist ein dynamisches Array vom Typ TIdxFile.

  Die Prozedur ExtractFile extrahiert aus einer beliebigen
  Quelldatei eine Byte-Sequenz und schreibt sie in die
  angegebene Datei. Der Typ der Quelldatei ist beliebig.

  Die TODO's markieren die Stellen im Demoprogramm, die
  hardgecodet sind. Wie man sieht befinden sie sich nur
  in den Stellen im Quellcode, wo die Funktionsweise
  der relevanten Routinen demonstriert werden.
  Die relevanten Routinen sind also wiederverwendbar.

  Willst du nun alle Dateien extrahieren, liest du die
  Indexdatei ein, gehst sie in einer Schleife durch und
  rufst die Prozedur ExtravtFile mit den entsprechenden
  Parametern auf. Aufpassen musst du nur bei der letzten
  Datei, da es dort keinen Nachfolger gibt:

  IdxFile := FileInfoArray[IDX];
  IdxFileNext := FileInfoArray[IDX+1];  // <-- !!!

  Eine Lösung wäre einen zweiten Record zu definieren,
  der auch die Dateigröße behinhaltet und dessen Feld für
  die Dateigröße gleich so mit der Dateigröße zu füllen,
  wie es beim Anzeigen der Indexdatei im Listview gemacht
  wird:

  NewItem.SubItems.Add(IntToStr(FileInfoArray[i + 1].OffSet -
    FileInfoArray[i].OffSet));


  Schlussbemerkung:
  =================

  @Newbie44:
  Ich bin der Meinung dass es sauber programmiert ist. Du
  kannst dir ja mal im Quellcode ankucken, wie man Fehler
  behandelt und sauber abfängt. Wie du siehst, haben sie
  einen relativ hohen Anteil am Quellcode, aber das ist
  nötig, um eben alle auftretenden Fehler abfangen zu
  können. Es gibt nichts unschöneres, als einen Programm-
  absturz, weil eine Datei nicht geöffnet oder geschrieben
  werden konnte und damit muss man immer rechnen.

  Ich hoffe, du hast was gelernt, wenn du den Quellcode
  genauer studiert hast.

************************************************************}

Die interessaneten Routinen schon mal hier im Posting:

Delphi-Quellcode:

// vermuteter Aufbau der Indexdatei:
type
  TIdxFile = record
    Filename: array[0..19] of Char;
    OffSet: DWord;
  end;
  PIdxFile = ^TIdxFile;

  TFileInfos = array of TIdxFile;

// [..]

////////////////////////////////////////////////////////////////////////////////
//
//  ExtractFile
//
//    Extrahier eine Datei aus SrcFile nach DestFile
//    Wirft Exceptions EReadError bzw. EWriteError beim Lesen bzw. Schreiben
//

procedure ExtractFile(SrcFile, DestFile: string; Offset: Int64; FileSize:
  Integer);
var
  ms: TMemoryStream;
  fs: TFileStream;
  Buffer: PByteArray;
resourcestring
  rsEReadError = 'Fehler beim Lesen der Datei %s';
  rsEWriteError = 'Fehler beim Schreiben in die Datei %s';
begin
  ms := TMemoryStream.Create;
  fs := TFileStream.Create(DestFile, fmCreate);
  try
    // Datei laden und Dateizeiger positionieren
    ms.LoadFromFile(SrcFile);
    ms.Seek(OffSet, soFromBeginning);
    // Speicher für Buffer anfordern
    GetMem(Buffer, FileSize);
    try
      try
        // Bytes aus SrcFile nach DestFile kopieren
        ms.ReadBuffer(Buffer^, FileSize);
        fs.WriteBuffer(Buffer^, FileSize);
      except
        on E: EReadError do
          raise E.Create(rsEReadError);
        on E: EWriteError do
          raise E.Create(rsEWriteError);
      end;
    finally
      FreeMem(Buffer, FileSize);
    end;
  finally
    FreeAndNil(ms);
    FreeAndNil(fs);
  end;
end;

////////////////////////////////////////////////////////////////////////////////
//
//  ReadIndexFile
//
//    Indexdatei einlesen
//    Wirft eine Exception EReadError bei Lesefehler
//

function ReadIndexFile(Filename: string): TFileInfos;
var
  fs: TFileStream;
  i: Integer;
resourcestring
  rsEReadError = 'Fehler beim einlesen der Datei %s';
begin
  i := 0;
  fs := TFileStream.Create(Filename, fmOpenRead);
  try
    // 2 Bytes nach vorne springen, da steht noch was, aber ich weiß nicht was,
    // Eventuell eine Signatur oder so
    fs.Seek(2, soFromBeginning);
    // Größe des dynamisches Array setzten (Dateigröße / Recordgröße = Anzahl Datensätze)
    SetLength(result, fs.Size div sizeof(TIdxFile));
    // so lange lesen bis wir am Ende sind
    while fs.Position < fs.Size do
    begin
      try
        fs.ReadBuffer(result[i], sizeof(TIdxFile));
        Inc(i);
      except
        on E: EReadError do
          raise E.Create(Format(rsEReadError, [Filename]));
      end;
    end;
  finally
    FreeAndNil(fs);
  end;
end;