source: trunk/UDecode.pas

unit UDecode;

{$mode delphi}

interface

uses
  Classes, SysUtils, Types;

function Format80(Source: TByteDynArray): TByteDynArray;
function Format40(Source: TByteDynArray): TByteDynArray;
function Format20(Source: TByteDynArray): TByteDynArray;


implementation

// LCW decoder
function Format80(Source: TByteDynArray): TByteDynArray;
var
  Flag: Byte;
  Size: Word;
  Offset: Word;
  SourceIndex: Integer;
  DestIndex: Integer;
begin
  SourceIndex := 0;
  DestIndex := 0;
  SetLength(Result, Length(Source));
  while SourceIndex < Length(Source) do begin
    Flag := Source[SourceIndex];
    Inc(SourceIndex);

    // Short move, relative
    if ((Flag and $80) = 0) then begin
      Size := (Flag shr 4) + 3;
      Offset := ((Flag and $f) shl 8) or Source[SourceIndex];
      Inc(SourceIndex);

      // This decoder assumes memcpy. As some platforms implement memcpy as memmove, this is much safer
      if (DestIndex + Size) >= Length(Result) then
        SetLength(Result, DestIndex + Size + 1);
      while Size > 0 do begin
        Result[DestIndex] := Result[DestIndex - Offset];
        Inc(DestIndex);
        Dec(Size);
      end;
      Continue;
    end;

    // Exit
    if (Flag = $80) then Break;

    // Long set
    if (Flag = $fe) then begin
      Size := Source[SourceIndex] or (Source[SourceIndex + 1] shl 8);
      Inc(SourceIndex, 2);

      if (DestIndex + Size) >= Length(Result) then
        SetLength(Result, DestIndex + Size + 1);
      FillChar(Result[DestIndex], Size, Source[SourceIndex]);
      Inc(SourceIndex);
      Inc(DestIndex, Size);
      Continue;
    end;

    // Long move, absolute
    if (Flag = $ff) then begin
      Size := Source[SourceIndex] or (Source[SourceIndex + 1] shl 8);
      Inc(SourceIndex, 2);
      Offset := Source[SourceIndex] or(Source[SourceIndex + 1] shl 8);
      Inc(SourceIndex, 2);

      if (DestIndex + Size) >= Length(Result) then
        SetLength(Result, DestIndex + Size + 1);
      // This decoder assumes memcpy. As some platforms implement memcpy as memmove, this is much safer
      while Size > 0 do begin
        Result[DestIndex] := Result[Offset];
        Inc(DestIndex);
        Inc(Offset);
        Dec(Size);
      end;
      Continue;
    end;

    // Short move, absolute
    if ((Flag and $40) <> 0) then begin
      Size := (Flag and $3f) + 3;
      Offset := Source[SourceIndex] or (Source[SourceIndex + 1] shl 8);
      Inc(SourceIndex, 2);

      // This decoder assumes memcpy. As some platforms implement memcpy as memmove, this is much safer
      if (DestIndex + Size) >= Length(Result) then
        SetLength(Result, DestIndex + Size + 1);
      while Size > 0 do begin
        Result[DestIndex] := Result[Offset];
        Inc(DestIndex);
        Inc(Offset);
        Dec(Size);
      end;
      Continue;
    end;

    // Short copy
    begin
      Size := Flag and $3f;

      // This decoder assumes memcpy. As some platforms implement memcpy as memmove, this is much safer
      if (DestIndex + Size) >= Length(Result) then
        SetLength(Result, DestIndex + Size + 1);
      while Size > 0 do begin
        Result[DestIndex] := Source[SourceIndex];
        Inc(DestIndex);
        Inc(SourceIndex);
        Dec(Size);
      end;
      Continue;
    end;
  end;
end;

// XORDelta decoder
function Format40(Source: TByteDynArray): TByteDynArray;
var
  Flag: Word;
  SourceIndex: Integer;
  DestIndex: Integer;
begin
  SourceIndex := 0;
  DestIndex := 0;
  SetLength(Result, Length(Source));
  while True do begin
    Flag := Source[SourceIndex];
    Inc(SourceIndex);

    if Flag = 0 then begin
      Flag := Source[SourceIndex];
      if (DestIndex + Flag) >= Length(Result) then
        SetLength(Result, DestIndex + Flag + 1);
      while Flag > 0 do begin
        Result[DestIndex] := Result[DestIndex] xor Source[SourceIndex];
        Inc(DestIndex);
        Dec(Flag);
      end;
      Inc(SourceIndex);
      Continue;
    end;

    if (Flag and $80) = 0 then begin
      if (DestIndex + Flag) >= Length(Result) then
        SetLength(Result, DestIndex + Flag + 1);
      while Flag > 0 do begin
        Result[DestIndex] := Result[DestIndex] xor Source[SourceIndex];
        Inc(DestIndex);
        Inc(SourceIndex);
        Dec(Flag);
      end;
      Continue;
    end;

    if Flag <> $80 then begin
      DestIndex := DestIndex + (Flag and $7F);
      Continue;
    end;

    Flag := Source[SourceIndex] or (Source[SourceIndex] shl 8);
    Inc(SourceIndex, 2);

    if Flag = 0 then Break;

    if (Flag and $8000) = 0 then begin
      Inc(DestIndex, Flag);
      Continue;
    end;

    if (Flag and $4000) = 0 then begin
      Flag := Flag and $3FFF;
      if (DestIndex + Flag) >= Length(Result) then
        SetLength(Result, DestIndex + Flag + 1);
      while Flag > 0 do begin
        Result[DestIndex] := Result[DestIndex] xor Source[SourceIndex];
        Inc(DestIndex);
        Inc(SourceIndex);
        Dec(Flag);
      end;
      Continue;
    end;

    Flag := Flag and $3FFF;
    if (DestIndex + Flag) >= Length(Result) then
      SetLength(Result, DestIndex + Flag + 1);
    while Flag > 0 do begin
      Result[DestIndex] := Result[DestIndex] xor Source[SourceIndex];
      Inc(DestIndex);
      Dec(Flag);
    end;
    Inc(SourceIndex);
    Continue;
  end;
end;

function Format20(Source: TByteDynArray): TByteDynArray;
var
  D: Byte;
  Count: Integer;
  SourceIndex: Integer;
  DestIndex: Integer;
begin
  SourceIndex := 0;
  DestIndex := 0;
  SetLength(Result, Length(Source));
  while SourceIndex < Length(Source) do begin
    D := Source[SourceIndex];
    Inc(SourceIndex);
    if D = 0 then begin
      if SourceIndex >= Length(Source) then
        Break;
      Count := Source[SourceIndex];
      if Count = 0 then Break;
      Inc(SourceIndex);
      if (DestIndex + Count) >= Length(Result) then
        SetLength(Result, DestIndex + Count + 1);
      FillChar(Result[DestIndex], Count, 0);
      Inc(DestIndex, Count);
    end else begin
      if DestIndex >= Length(Result) then
        SetLength(Result, DestIndex + 1);
      Result[DestIndex] := D;
      Inc(DestIndex);
    end;
  end;
end;


end.