Erste Bytes einer Datei vergleichen?

[Benmik]

Wird ja immer kürzer.

Delphi-Quellcode:

function  IstRAWFormat(const Dateiname:string):Boolean;
var Datei:File; Buf:array [0..19] of Byte;
    BufCRW,BufARW,BufCR2,BufRW2,BufNEF,BufORF,BufPEF,BufRAF,BufRWL,BufSRW,BufX3F,
    BufERF,BufFFF,BufMEF,BufMRW,BufNRW,BufDCR,BufSRF:TBytes;
begin
  Result := False;
  If FileExists(Dateiname) then begin
    AssignFile(Datei,Dateiname);
    {$I-}
    Reset(Datei, 1);
    BlockRead(Datei, Buf[0], 20);
    {$I+}
    If IOResult <> 0
      then exit;
    BufCRW := [$49,$49,$1A,$00,$00,$00,$48,$45,$41,$50,$43,$43,$44,$52,$02,$00]; // Canon, veraltet
    BufCR2 := [$49,$49,$2A,$00,$10,$00,$00,$00,$43,$52];                         // Canon
    BufARW := [$49,$49,$2A,$00];                                                 // Sony, auch SR2 (Sony), 3FR (Hasselblad), IIQ (PhaseOne)
    BufRW2 := [$49,$49,$55,$00,$18,$00,$00,$00,$88,$E7,$74,$D8,$F8,$25,$1D,$4D]; // Panasonic
    BufNEF := [$4D,$4D,$00,$2A,$00,$00,$00,$08,$00];                             // Nikon
    BufORF := [$49,$49,$52];                                                     // Olympus
    BufPEF := [$4D,$4D,$00,$2A,$00];                                             // Pentax
    BufRAF := [$46,$55,$4A,$49,$46,$49,$4C,$4D,$43,$43,$44,$2D,$52,$41,$57,$20]; // Fujifilm
    BufRWL := [$49,$49,$55,$00];                                                 // Leica
    BufSRW := [$4D,$4D,$00,$2A,$00,$00,$00,$08,$00,$06,$01,$0F,$00,$02,$00,$00]; // Samsung
    BufX3F := [$46,$4F,$56,$62];                                                 // Sigma
    // veraltet
    BufDCR := [$44,$53,$43,$2D,$49,$6D,$61,$67,$65];                             // Kodak, veraltet
    BufERF := [$43,$6F,$6D,$70,$75,$63,$6F,$6E,$20,$45,$4F,$53,$20,$44,$65,$73]; // Epson, veraltet
    BufFFF := [$4D,$4D,$00,$2A];                                                 // Hasselblad, veraltet
    BufMEF := [$4D,$52,$00,$00,$00,$00,$00,$00,$00,$00,$1C,$0E];                 // Mamiya, veraltet
    BufMRW := [$00,$4D,$52,$4D];                                                 // Minolta, veraltet
    BufNRW := [$4E,$4F,$4B,$49,$41,$52,$41,$57];                                 // Nokia, veraltet
    BufSRF := [$4C,$53];                                                         // Sony, veraltet, DSC-F828 von 2004
    Result := CompareMem(@BufCRW[0],@Buf[0],Length(BufCRW))
           or CompareMem(@BufCR2[0],@Buf[0],Length(BufCR2))
           or CompareMem(@BufARW[0],@Buf[0],Length(BufARW))
           or CompareMem(@BufRW2[0],@Buf[0],Length(BufRW2))
           or CompareMem(@BufNEF[0],@Buf[0],Length(BufNEF))
           or CompareMem(@BufORF[0],@Buf[0],Length(BufORF))
           or CompareMem(@BufPEF[0],@Buf[0],Length(BufPEF))
           or CompareMem(@BufRAF[0],@Buf[0],Length(BufRAF))
           or CompareMem(@BufRWL[0],@Buf[0],Length(BufRWL))
           or CompareMem(@BufSRW[0],@Buf[0],Length(BufSRW))
           or CompareMem(@BufX3F[0],@Buf[0],Length(BufX3F))
           // veraltet
           or CompareMem(@BufDCR[0],@Buf[0],Length(BufDCR))
           or CompareMem(@BufERF[0],@Buf[0],Length(BufERF))
           or CompareMem(@BufFFF[0],@Buf[0],Length(BufFFF))
           or CompareMem(@BufMEF[0],@Buf[0],Length(BufMEF))
           or CompareMem(@BufMRW[0],@Buf[0],Length(BufMRW))
           or CompareMem(@BufNRW[0],@Buf[0],Length(BufNRW))
           or CompareMem(@BufSRF[0],@Buf[0],Length(BufSRF));
    CloseFile(Datei);
  end;
end;

Gibt es sonst noch was? Vielleicht die Steinzeitroutine AssignFile ? Ich dachte, es ist ja nicht nötig, mit einem FileStream die ganze Datei einzulesen. Außerdem habe ich das Try..Except durch ein IOResult ersetzt.

[himitsu]

Du denkst doch nicht etwa, dass man mit dem FileStream nur ganze Dateien einlesen kann?
Das ganze noch in eine Konstante oder Variable (Array of Array) und dann das Vergleichen in eine Schleife.

TFileStream statt BlockRead nur ein Read und man braucht weder Try-Except noch IOResult.

PS: Das AssignFile gehörte vor das erste Try. Da in Finally auf die Variable zugegriffen wird, gehört die Initialisierung vor das Try, damit es auch "immer" richtig initialisiert wird.
Und durch das {$I-} war die Exceptionbehandluch sowieso falsch, da diese Dateifunktionen dort mit Fehlercodes (IOResult) und nicht mit Exceptions gearbeitet hatte.

[Uwe Raabe]

Ich weiß zwar nicht, ob das für diesen Anwendungsfall relevant ist, aber ich baue sowas gerne hierarchisch auf:

Delphi-Quellcode:

function IstRAWFormat(const Buf: TBytes):Boolean; overload;
const
  cRawHeader: TArray<TBytes>
     = [
        [$49,$49,$1A,$00,$00,$00,$48,$45,$41,$50,$43,$43,$44,$52,$02,$00], // Canon, veraltet
        [$49,$49,$2A,$00,$10,$00,$00,$00,$43,$52], // Canon
        [$49,$49,$2A,$00], // Sony, auch SR2 (Sony), 3FR (Hasselblad), IIQ (PhaseOne)
        [$49,$49,$55,$00,$18,$00,$00,$00,$88,$E7,$74,$D8,$F8,$25,$1D,$4D], // Panasonic
        [$4D,$4D,$00,$2A,$00,$00,$00,$08,$00], // Nikon
        [$49,$49,$52], // Olympus
        [$4D,$4D,$00,$2A,$00], // Pentax
        [$46,$55,$4A,$49,$46,$49,$4C,$4D,$43,$43,$44,$2D,$52,$41,$57,$20], // Fujifilm
        [$49,$49,$55,$00], // Leica
        [$4D,$4D,$00,$2A,$00,$00,$00,$08,$00,$06,$01,$0F,$00,$02,$00,$00], // Samsung
        [$46,$4F,$56,$62], // Sigma
        // veraltet
        [$44,$53,$43,$2D,$49,$6D,$61,$67,$65], // Kodak, veraltet
        [$43,$6F,$6D,$70,$75,$63,$6F,$6E,$20,$45,$4F,$53,$20,$44,$65,$73], // Epson, veraltet
        [$4D,$4D,$00,$2A], // Hasselblad, veraltet
        [$4D,$52,$00,$00,$00,$00,$00,$00,$00,$00,$1C,$0E], // Mamiya, veraltet
        [$00,$4D,$52,$4D], // Minolta, veraltet
        [$4E,$4F,$4B,$49,$41,$52,$41,$57], // Nokia, veraltet
        [$4C,$53] // Sony, veraltet, DSC-F828 von 2004
       ];
var
  rawHeader: TBytes;
begin
  for rawHeader in cRawHeader do begin
    if CompareMem(@rawHeader[0], @Buf[0], Length(rawHeader)) then Exit(true);
  end;
  Result := false;
end;

function IstRAWFormat(Stream: TStream):Boolean; overload;
var
  buf: TBytes;
  savePos: Int64;
begin
  SetLength(buf, 20);
  savePos := Stream.Position;
  try
    Stream.ReadData(buf, Length(buf));
  finally
    Stream.Position := savePos;
  end;
  Result := IstRAWFormat(buf);
end;

function IstRAWFormat(const Dateiname: string):Boolean; overload;
var
  stream: TFileStream;
begin
  stream := TFileStream.Create(Dateiname, fmOpenRead);
  try
    result := IstRAWFormat(stream);
  finally
    stream.Free;
  end;
end;

Sinnvollerweise packt man das noch als statische Methoden in einen passenden Namespace (Record oder Klasse). Statt des Boolschen Results würde sich auch ein Aufzählungstyp für die verschiedenen Formate anbieten, falls man abhängig vom Format unterschiedlich reagieren möchte.

[Benmik]

@Himitsu: Du hast natürlich Recht. Ich hatte den Code mal von irgendwoher übernommen und habe erst jetzt mal genauer geguckt: $I-} und Try ist natürlich Unsinn. Hab ich ja auch geändert. TFileStream und Read ist auch besser.

@Uwe Raabe: Wirklich toll. Was ich nicht verstehe: Warum das savePos? Aus Interesse: Wie sähe eine Enumeration denn aus?

[Uwe Raabe]

Zitat von Benmik:

Was ich nicht verstehe: Warum das savePos?

Damit der Stream nach dem Aufruf wieder an der richtigen Stelle steht und vom aufrufenden Teil weiterverarbeitet werden kann. Sonst würden ja die ersten 20 Bytes fehlen.

Zitat von Benmik:

Aus Interesse: Wie sähe eine Enumeration denn aus?

Etwa so:

Delphi-Quellcode:

type
  TRAWFormat = (rawUnknown, rawCanonOld, rawCanon, rawSony, rawPanasonic, rawNikon, rawOlympus, rawPentax, rawFuji,
                rawLeica, rawSamsung, rawSigma, rawKodak, rawEpson, rawHasselblad, rawMamiya, rawMinolta, rawNokia,
                rawSonyOld);

function GetRAWFormat(const Buf: TBytes): TRAWFormat; overload;
const
  cRawHeader: TArray<TBytes>
     = [
        [$49,$49,$1A,$00,$00,$00,$48,$45,$41,$50,$43,$43,$44,$52,$02,$00], // Canon, veraltet
        [$49,$49,$2A,$00,$10,$00,$00,$00,$43,$52], // Canon
        [$49,$49,$2A,$00], // Sony, auch SR2 (Sony), 3FR (Hasselblad), IIQ (PhaseOne)
        [$49,$49,$55,$00,$18,$00,$00,$00,$88,$E7,$74,$D8,$F8,$25,$1D,$4D], // Panasonic
        [$4D,$4D,$00,$2A,$00,$00,$00,$08,$00], // Nikon
        [$49,$49,$52], // Olympus
        [$4D,$4D,$00,$2A,$00], // Pentax
        [$46,$55,$4A,$49,$46,$49,$4C,$4D,$43,$43,$44,$2D,$52,$41,$57,$20], // Fujifilm
        [$49,$49,$55,$00], // Leica
        [$4D,$4D,$00,$2A,$00,$00,$00,$08,$00,$06,$01,$0F,$00,$02,$00,$00], // Samsung
        [$46,$4F,$56,$62], // Sigma
        // veraltet
        [$44,$53,$43,$2D,$49,$6D,$61,$67,$65], // Kodak, veraltet
        [$43,$6F,$6D,$70,$75,$63,$6F,$6E,$20,$45,$4F,$53,$20,$44,$65,$73], // Epson, veraltet
        [$4D,$4D,$00,$2A], // Hasselblad, veraltet
        [$4D,$52,$00,$00,$00,$00,$00,$00,$00,$00,$1C,$0E], // Mamiya, veraltet
        [$00,$4D,$52,$4D], // Minolta, veraltet
        [$4E,$4F,$4B,$49,$41,$52,$41,$57], // Nokia, veraltet
        [$4C,$53] // Sony, veraltet, DSC-F828 von 2004
       ];
var
  I: Integer;
  rawHeader: TBytes;
begin
  for I := Low(rawHeader) to High(rawHeader) do begin
    rawHeader := cRawHeader[I];
    if CompareMem(@rawHeader[0], @Buf[0], Length(rawHeader)) then Exit(TRawFormat(I));
  end;
  Result := rawUnknown;
end;

[himitsu]

Das SavePos ist, damit die Funktion univeral ist und den Stream nicht verändert, für nachfolgene Leseoperationen.

array[TRAWFormat] of TBytes und man kann erstens direkt Result als Schleifenvariable nutzen und hat eine Bereichsprüfung für das Array, damit die Anzahl mit dem Enum übereinstimmt.

[Uwe Raabe]

Zitat von himitsu:

array[TRAWFormat] of TBytes und man kann erstens direkt Result als Schleifenvariable nutzen und hat eine Bereichsprüfung für das Array, damit die Anzahl mit dem Enum übereinstimmt.

Hast du mal versucht, so ein Array als Konstante zu deklarieren?

[Benmik]

Vielen Dank euch beiden. TRawFormat(I) war der Punkt. Dass man an den (Integer-)Wert mittels Ord(RawFormat) rankommt, weiß ich mittlerweile; dass man auf ein Glied von TRawFormat so einfach zugreifen kann, weiß ich jetzt.
Das savePos war mir nicht klar, weil ich ja gerade eben von jeder JPG-Datei nur die ersten 20 Bytes auslesen will; aber klar, für einen universelleren Gebrauch ist das nützlich.

Ebenfalls aus (Fortbildungs-)Interesse: Ist es vielleicht eine Illusion zu glauben, man würde mit einer Beschränkung auf die ersten 20 Bytes Zeit sparen? Wäre es bei einer Festplatte schneller, einen Sektor auszulesen? Oder ist das egal, weil sowieso immer ein Sektor ausgelesen wird? Werden bei einer SSD hingegen tatsächlich nur die ersten 20 Bytes gelesen?