wie art der daten in blob erkennen?

[schorsch666]

Moin @ALL,
ich baue hier gerade einen data-editor und komme jetzt zu den blobs. und da das dann so eine art "blob-editor" wird, weiss ich also vorher nicht, um welche art von daten es sich bei einem jeweiligen blob-inhalt handelt. da ich aber eine art vorschau realisieren will, muesste ich das eben wissen...

ich habe gelesen, dass man das in den ersten bytes erkennen koennte, aber da muesste ich ja ne dicke liste fuehren. auch habe ich ueberlegt, ob ich den krempel in die zwischenablage kopiere und mittels TClipboard checke - finde ich aber unelegant.

und weil ich auch hier im forum leider nix gefunden habe, werfe ich das mal in die runde...

hat jemand ne idee von euch?? ware super...

...de Schorsch

[generic]

Ja, die dicke Liste ist hier:
https://opensource.apple.com/source/...gic/magic.mime

Ist vermutlich nicht die neuste Datei, aber suche auch gerne mal nach libmagic.

oder vielleicht auch https://mark0.net/soft-trid-e.html

[mytbo]

Zitat von schorsch666:

ich habe gelesen, dass man das in den ersten bytes erkennen koennte, aber da muesste ich ja ne dicke liste fuehren.

List of file signatures. Bist du Herr über die Daten, speichere das Format besser gleich mit ab.

Bis bald...
Thomas

[Blup]

Blobs werden auch gern für komprimierten Daten genutzt (z.B. mit ZLib).
Dadurch spart man erheblich an der Größe der Datenbank.

[anse]

Unter Linux könntest du das BLOB auf der Festplatte zwischenspeichern und per "file" Kommando den Mime-Type herausbekommen:

Code:

file --mime-type -b Downloads/logo.jpg
# image/jpeg

Unter Windows gibt es ein paar Pendants zu "file", wobei TrID ein gutes/bekanntes zu sein scheint.

[himitsu]

FILE ist opensource ... könnte/kann man auch für Windows bereitstellen.
Da werden nicht nur diese MagicBytes (die ersten 1-4 Bytes) beachtet.

Wenn es um Bilder geht, dann kann TPicture.LoadFromStream das inszwischen auch, für bei ihm registrierte Formate.
Ganz früher hatte nur LoadFromFile auf die Dateiendung geachtet, aber seit 'ner Weile macht das LoadFromStream, über einige MagicBytes. (die Funktion kann man hoffentlich auch selber aufrufen, außer Emba ist mal wieder doof)

[dummzeuch]

Es gibt keine generelle Lösung dafür, schließlich müssen Blobs ja nicht notwendigerweise bekannten Dateiformate enthalten. Jeder Anwender und/oder Programmierer kann dort beliebige binäre Daten ablegen. Wenn Du sicher bist, dass es Dateien sind, helfen die bereits genannten Links wahrscheinlich weiter, aber Du solltest sicherstellen, dass dein Tool auch Zugriff auf generische Binärdaten erlaubt, z.B. wie bei einem Hex-Editor/Viewer. Genaugenommen ist das das sogar erste, was Du einbauen solltest.

[KodeZwerg]

Zitat von mytbo:

Zitat von schorsch666:

ich habe gelesen, dass man das in den ersten bytes erkennen koennte, aber da muesste ich ja ne dicke liste fuehren.

List of file signatures. Bist du Herr über die Daten, speichere das Format besser gleich mit ab.

Bis bald...
Thomas

Jupp, basierend auf dieser Liste hatte ich mir mal was gebastelt was mir die Hauptgraphikformate zurück gibt:

Delphi-Quellcode:

function GetBytesFormat(const AData: TBytes): Integer;
var
  signature: TBytes;
begin
  Result := -1;
  signature := Copy(AData, 0, 8);

  if CompareMem(@signature[0], @[$FF, $D8, $FF, $DB], 4) then
    Result := 0 // JPEG
  else
  if CompareMem(@signature[0], @[$FF, $D8, $FF, $E0, $00, $10, $4A, $46], 8) then
    Result := 0 // JPEG
  else
  if CompareMem(@signature[0], @[$49, $46, $00, $01], 4) then
    Result := 0 // JPEG
  else
  if CompareMem(@signature[0], @[$FF, $D8, $FF, $EE], 4) then
    Result := 0 // JPEG
  else
  if CompareMem(@signature[0], @[$FF, $D8, $FF, $E1], 4) and CompareMem(@signature[6], @[$45, $78], 2) then
    Result := 0 // JPEG
  else
  if CompareMem(@signature[0], @[$69, $66, $00, $00], 4) then
    Result := 0 // JPEG
  else
  if CompareMem(@signature[0], @[$FF, $D8, $FF, $E0], 4) then
    Result := 0 // JPEG
  else
  if CompareMem(@signature[0], @[$89, $50, $4E, $47, $0D, $0A, $1A, $0A], 8) then
    Result := 1 // PNG
  else
  if CompareMem(@signature[0], @[$47, $49, $46, $38, $37, $61], 6) then
    Result := 2 // GIF87a
  else
  if CompareMem(@signature[0], @[$47, $49, $46, $38, $39, $61], 6) then
    Result := 2 // GIF89a
  else
  if CompareMem(@signature[0], @[$42, $4D], 2) then
    Result := 3 // BMP
  else
  if CompareMem(@signature[0], @[$00, $00, $01, $00], 4) then
    Result := 4 // ICO
  else
  if CompareMem(@signature[0], @[$49, $49, $2A, $00], 4) then
    Result := 5 // TIF
  else
  if CompareMem(@signature[0], @[$4D, $4D, $00, $2A], 4) then
    Result := 5 // TIFF
  ;
end;

Wobei es sich eher um ein Proof-of-Concept anstelle eines voll ausgereiften hoch optimierten quelltext handelt.

[himitsu]

Boar eh ... immer und immer wieder ... die sollem mal richtige Entwickler einstellen, die ihr eigenes Produckt selber benutzen.

Du kannst dich aber selber an jedes einzelne ImageFormat wenden und es fragen,
TGraphic.CanLoadFromStream

also TBitmap.CanLoadFromStream, TPngImage.CanLoadFromStream, TJPEGImage.CanLoadFromStream usw.

Ein GetFileFormats.FindFormat wäre natürlich einfacher, aber ..... mähhhhhhhhhh

Delphi-Quellcode:

unit Vcl.Graphics;

implementation  <-    was soll dieser perverse Scheiß immer?

var
  ClipboardFormats: TClipboardFormats = nil;
  FileFormats: TFileFormatsList = nil;

function GetFileFormats: TFileFormatsList;
begin
  if FileFormats = nil then FileFormats := TFileFormatsList.Create;
  Result := FileFormats;
end;

function GetClipboardFormats: TClipboardFormats;
begin
  if ClipboardFormats = nil then ClipboardFormats := TClipboardFormats.Create;
  Result := ClipboardFormats;
end;

Delphi-Quellcode:

procedure TPicture.LoadFromFile(const Filename: string);
var
  Ext: string;
  GraphicClass: TGraphicClass;
  Context: TFindGraphicClassContext;
begin
  Ext := ExtractFileExt(Filename).Remove(0, 1);
  GraphicClass := FileFormats.FindExt(Ext);

Delphi-Quellcode:

procedure TPicture.LoadFromStream(Stream: TStream);
var
  GraphicClass: TGraphicClass;
  Context: TFindGraphicClassContext;
begin
  if Stream.Size - Stream.Position = 0 then
    GraphicClass := TBitmap
  else
    GraphicClass := FileFormats.FindFormat(Stream);

Delphi-Quellcode:

procedure TPicture.LoadFromClipboardFormat(AFormat: Word; AData: THandle;
  APalette: HPALETTE);
var
  GraphicClass: TGraphicClass;
  Context: TFindGraphicClassContext;
begin
  GraphicClass := ClipboardFormats.FindFormat(AFormat);

das was öffentlich ist, ist hierfür nicht nutzbar.

Delphi-Quellcode:

function GraphicFilter(GraphicClass: TGraphicClass): string;
var
  Filters: string;
begin
  GetFileFormats.BuildFilterStrings(GraphicClass, Result, Filters);
end;

function GraphicExtension(GraphicClass: TGraphicClass): string;
var
  I: Integer;
begin
  for I := GetFileFormats.Count-1 downto 0 do
    if TFileFormatType(FileFormats[I]).GraphicClass.ClassName = GraphicClass.ClassName then
    begin
      Result := TFileFormatType(FileFormats[I]).Extension;
      Exit;
    end;
  Result := '';
end;

function GraphicFileMask(GraphicClass: TGraphicClass): string;
var
  Descriptions: string;
begin
  GetFileFormats.BuildFilterStrings(GraphicClass, Descriptions, Result);
end;

[KodeZwerg]

Mein schnippsel sollte lediglich als Hilfestellung dienen wie man Signaturen erkennen könnte, er stammt aus etwas was keine Graphics oder Vcl kennt.
Das ich Graphikformate erkennen wollte ist in diesem Zusammenhang irrelevant.