CRC32 DEC 5

[r4id3n]

Hallo zusammen, ich habe mir hier die neue Version des DEC gezogen (inofizielle Version5) bei der auch eine CRC-Funktion bei ist. (Gibts da eventuell auch eine "offizielle" Stelle zum Herrunterladen? )

Ich möchte gerne den CRC32 über ganze Dateien erstellen, kann aber der CRCCode nur einen Puffer übergeben! Reicht es also aus, wenn ich einen TFileStream erzeuge und diesen dann übergebe? Inwiefern ist dies dann auch noch "Leistungsoptimiert" ??

Danke für Eure Hilfe!

[marabu]

Hallo.

Zwar kenne ich den von dir angesprochenen Code nicht, aber da es sich beim CRC- Verfahren um eine Polynomdivision handelt, wirst du mit einem Initialwert arbeiten müssen, der nach Verarbeitung eines beliebig kleinen Puffers durch ein vorläufiges Ergebnis ersetzt wird. Dieses Zwischenergebnis ist dann der Initialwert für den nächsten Datenblock. Auf diese Weise solltest du die Verarbeitung einer Datei im streaming mode erledigen können.

Grüße vom marabu

[negaH]

schau mal

function CRCCalcEx(CRCType: TCRCType; ReadMethod: TReadMethod; Size: Cardinal{$IFDEF VER_D4H} = $FFFFFFFF{$ENDIF}): Cardinal; ist so definiert. TReadMethod ist eine Deklaration der VCL TStreams.

Delphi-Quellcode:

function CRC32File(const AFileName: String): Cardinal;
var
  S: TStream;
begin
  S := TFileStream.Create(AFileName, fmOpenRead or fmShareDenyNone);
  try
    Result := CRCCalcEx(CRC_32CCITT, S.ReadBuffer);
  finally
    S.Free;
  end;
end;

dies müsste funktionieren, ich habs eben eingetippt und somit nicht getestet. Beachte das die CRC Funktionen nur Daten bis 2^32 Bytes Länge verarbeiten können. Mehr macht auch nicht Sinn da es sich um 32Bit CRCs handelt.

Gruß Hagen

[negaH]

Zur Performance:

man kann immer eine Implementation machen die schneller ist, die weniger Resourcen benötigt oder die statt in Pascal-Assembler in C/Basic etc. gecodet ist.

Bei meiner CRC Unit habe ich einen Kompromiss aus Performance, Speicherverbrauch und Universalität gesetzt. Wobei die Performance nur drittrangig war. Allerdings sind meine CRC Implementierungen meistens schneller als die vielen anderen CRC Implementationen für PASCAL. Aber es geht definitiv noch schneller.

An Speicher/Code verbraucht sie zwischen 728 und max. 952 Bytes im Codesegment. Datensegement wird meistens garkeines benötigt. Man kann also diese CRC Funktionen für sehr kleine EXE-Packer-Stubs benutzen, eines meiner eigenen Anwendungsziele. Während der Laufzeit wird meistens nur Stack konsumiert, ca. SizeOf(TCRCDef) Bytes.


Gruß Hagen

[r4id3n]

Hi, leider habe ich einige Probleme ... Leider erhalte ich einen anderen CRC als meine Ursprungsversion, sicherlich für Dich nur eine kleinigkeit....

Implementiert habe ich das ganze jetzt so:

Delphi-Quellcode:

function GetCRC32(FileName:String):String;
var     F:TFileStream;
        CRC:Cardinal;
        OldCRC:string;
begin
        F:=TFileStream.Create(FileName,fmOpenRead);
        try
                CRC:=CRCCalcEx(CRC_32CCITT,F.Read);
        finally
                F.Free;
        end;
        result:='$' + IntToHex(CRC,2);
        OldCRC:=CRCOld.GetCRC32Old(FileName);
        if result = OldCRC then
                beep;
end;

Die CRCOld sieht so aus:

Delphi-Quellcode:

unit CRCOld;

interface

procedure BuildCRCTable;
function RecountCRC(b: byte; CrcOld: Longint): Longint;
function HextW(w: Word): string;
function HextL(l: Longint): string;
function GetCRC32Old(FileName: string): string;

implementation

type
  Long = record
    LoWord: Word;
    HiWord: Word;
  end;

const
  CRCPOLY = $EDB88320;

var
  CRCTable: array[0..512] Of Longint;

procedure BuildCRCTable;
var
  i, j: Word;
  r: Longint;
begin
  FillChar(CRCTable, SizeOf(CRCTable), 0);
  for i := 0 to 255 do
  begin
    r := i shl 1;
    for j := 8 downto 0 do
      if (r and 1) <> 0 then
        r := (r Shr 1) xor CRCPOLY
      else
        r := r shr 1;
    CRCTable[i] := r;
   end;
end;

function RecountCRC(b: byte; CrcOld: Longint): Longint;
begin
  RecountCRC := CRCTable[byte(CrcOld xor Longint(b))] xor ((CrcOld shr 8) and $00FFFFFF)
end;

function HextW(w: Word): string;
const
  h: array[0..15] Of char = '0123456789ABCDEF';
begin
  HextW := '';
  HextW := h[Hi(w) shr 4] + h[Hi(w) and $F] + h[Lo(w) shr 4]+h[Lo(w) and $F];
end;

function HextL(l: Longint): string;
begin
  with Long(l) do
    HextL := HextW(HiWord) + HextW(LoWord);
end;

function GetCRC32Old(FileName: string): string;
var
  Buffer: PChar;
  f: File of Byte;
  b: array[0..255] of Byte;
  CRC: Longint;
  e, i: Integer;
begin
  BuildCRCTable;
  CRC := $FFFFFFFF;
  AssignFile(F, FileName);
  FileMode := 0;
  Reset(F);
  GetMem(Buffer, SizeOf(B));
  repeat
    FillChar(b, SizeOf(b), 0);
    BlockRead(F, b, SizeOf(b), e);
    for i := 0 to (e-1) do
     CRC := RecountCRC(b[i], CRC);
  until (e < 255) or (IOresult <> 0);
  FreeMem(Buffer, SizeOf(B));
  CloseFile(F);
  CRC := Not CRC;
  Result := '$' + HextL(CRC);
end;
end.

Wo liegt der Fehler?
P.S: Den Type

Delphi-Quellcode:

type
  TReadMethod = function(var Buffer; Count: LongInt): LongInd of object;

musste ich auf

Delphi-Quellcode:

type
  TReadMethod = function(var Buffer; Count: Integer): Integer of object;

ändern, da sonst die Read-Funktion einen Type mismatch brachte!!

10000000000 fach dank für Deine Hilfe!!!