Byteweises Auslesen einer Unicode-codierten Datei

[amigage]

Hallo,

ich bin mal wieder mit einem Problem unterwegs :roll:

Ich bin dabei, eine Binärdatei zu entschlüsseln.
Ich lese an einer bestimmten Stelle ein Byte aus, um die Länge der nachfolgenden Information zu erhalten und weiter zu verarbeiten. Ich habe jetzt aber das Problem mit dem Unicode.

zB. hat Byte 29 den Hexwert 00 und Byte 30 den Hexwert 14.
Die Umwandlung des Bytes 30 ergibt somit einen Dezimalwert von 20, also die Länge meines nachfolgenden Datensatzes.

Wie rechne ich aber die beiden Bytes zusammen um auch einen Wert höher 256 zu erhalten?

Delphi-Quellcode:

var
  fsIN    : TFileStream;
  wHeader : Word;
begin  
  fsIN := TFileStream.Create('D:\temp\meineBinärdatei.xyz', fmOpenRead);
  try
    fsIN.Seek(28, soFromBeginning);
    fsIN.Read(wHeader, SizeOf(wHeader));

    ShowMessage(IntToHex(wheader, SizeOf(wHeader)));
    showmessage(IntToStr(wheader));
  finally
    FreeAndNil(fsIN);
  end;
end;

Kann mir einer sagen, was ich tun muss, um den Unicode-Wert aus den Bytes 29 und 30 als String zu erhalten, den ich dann in einer weiteren Funktion (z.B. die hier im Forum erwähnte "function UnicodeToAnsi(SubUnicode: string):string;" ) umwandeln kann?

Besten Danke für jeden Hinweis.
Amigage

[Klaus01]

Sollte so gehen:

Byte 29 * 256 + byte 30

Grüße
Klaus

[Gausi]

Wobei man darauf achten muss, wie die Bytes geordnet sind. Häufig findet man am Anfang einer Unicode-Datei einen Byte-Order-Marker. Auch im ID3Tag bei Mp3-Dateien findet man diesen Marker. Dieser ist entweder $FEFF oder $FFFE, sodass die Berechnung entweder "Byte 29 * 256 + byte 30" oder "Byte 29 + byte 30 * 256" ablaufen muss.

[shmia]

Delphi-Quellcode:

var 
  fsIN    : TFileStream; 
  wHeader : Word; 
  Daten : WideString;   // <====
begin  
  SetLength(Daten, 30);
  fsIN := TFileStream.Create('D:\temp\meineBinärdatei.xyz', fmOpenRead); 
  try 
    fsIN.Seek(28, soFromBeginning); 
    fsIN.Read(@Daten[1], Length(Daten) * sizeof(Widechar)); 

    ShowMessage(Daten); 
  finally 
    FreeAndNil(fsIN); 
  end; 
end;

Gausi hat natürlich recht; man muss Byte-Reihenfolge beachten.
Sollte diese Reihenfolge nicht zum Intel-Format passen, dann verwendet man einfach folgende
Procedure:

Delphi-Quellcode:

// Hilfsfunktion zum vertauschen der Byteorder in einem WideString
procedure SwapWideString(var ws:WideString);
var
   i : Integer;
begin
   for i := 1 to length(ws) do
      ws[i] := WideChar(Swap(Ord(ws[i])));
end;

[amigage]

Danke für Eure schnellen Antworten und vor allem mit dem Hinweis auf das Byte Order Mark und den notwendigen Bytewechsel. Den hatte ich nämlich auch schon bemerkt und wusste nicht warum :-D

Danke, ich werde es mal probieren.

[Muetze1]

Dein erster Code zeigte zu kurze Codes an: SizeOf() liefert Bytes zurück und IntToHex() will die Anzahl der Ziffern haben. Eine Ziffer bei IntToHex ist ein Nibble und somit müsstest du den SizeOf() Wert mal 2 nehmen für IntToHex().

Ausserdem weiss ich nicht, warum du einzelne Bytewerte multiplizieren willst, wo du diese doch schon kombiniert liest als ein Word. Hättest du zwei einzelne nachfolgende Bytes aus dem Stream gelesen, hätte ich den Grund verstanden, aber so :gruebel: