tifccitt.pas

·ImageEn 2.3.0 ImageEn一组用于图像处理、查看和分析的Delphi控件。能够保存几种图像格式

    (dim: 12; code: $D2; rl: 34), // 0000 1101 0010
    (dim: 12; code: $D3; rl: 35), // 0000 1101 0011
    (dim: 12; code: $D4; rl: 36), // 0000 1101 0100
    (dim: 12; code: $D5; rl: 37), // 0000 1101 0101
    (dim: 12; code: $D6; rl: 38), // 0000 1101 0110
    (dim: 12; code: $D7; rl: 39), // 0000 1101 0111
    (dim: 12; code: $6C; rl: 40), // 0000 0110 1100
    (dim: 12; code: $6D; rl: 41), // 0000 0110 1101
    (dim: 12; code: $DA; rl: 42), // 0000 1101 1010
    (dim: 12; code: $DB; rl: 43), // 0000 1101 1011
    (dim: 12; code: $54; rl: 44), // 0000 0101 0100
    (dim: 12; code: $55; rl: 45), // 0000 0101 0101
    (dim: 12; code: $56; rl: 46), // 0000 0101 0110
    (dim: 12; code: $57; rl: 47), // 0000 0101 0111
    (dim: 12; code: $64; rl: 48), // 0000 0110 0100
    (dim: 12; code: $65; rl: 49), // 0000 0110 0101
    (dim: 12; code: $52; rl: 50), // 0000 0101 0010
    (dim: 12; code: $53; rl: 51), // 0000 0101 0011
    (dim: 12; code: $24; rl: 52), // 0000 0010 0100
    (dim: 12; code: $37; rl: 53), // 0000 0011 0111
    (dim: 12; code: $38; rl: 54), // 0000 0011 1000
    (dim: 12; code: $27; rl: 55), // 0000 0010 0111
    (dim: 12; code: $28; rl: 56), // 0000 0010 1000
    (dim: 12; code: $58; rl: 57), // 0000 0101 1000
    (dim: 12; code: $59; rl: 58), // 0000 0101 1001
    (dim: 12; code: $2B; rl: 59), // 0000 0010 1011
    (dim: 12; code: $2C; rl: 60), // 0000 0010 1100
    (dim: 12; code: $5A; rl: 61), // 0000 0101 1010
    (dim: 12; code: $66; rl: 62), // 0000 0110 0110
    (dim: 12; code: $67; rl: 63), // 0000 0110 0111
    (dim: 10; code: $F; rl: 64), // 0000 0011 11
    (dim: 12; code: $C8; rl: 128), // 0000 1100 1000
    (dim: 12; code: $C9; rl: 192), // 0000 1100 1001
    (dim: 12; code: $5B; rl: 256), // 0000 0101 1011
    (dim: 12; code: $33; rl: 320), // 0000 0011 0011
    (dim: 12; code: $34; rl: 384), // 0000 0011 0100
    (dim: 12; code: $35; rl: 448), // 0000 0011 0101
    (dim: 13; code: $6C; rl: 512), // 0000 0011 0110 0
    (dim: 13; code: $6D; rl: 576), // 0000 0011 0110 1
    (dim: 13; code: $4A; rl: 640), // 0000 0010 0101 0
    (dim: 13; code: $4B; rl: 704), // 0000 0010 0101 1
    (dim: 13; code: $4C; rl: 768), // 0000 0010 0110 0
    (dim: 13; code: $4D; rl: 832), // 0000 0010 0110 1
    (dim: 13; code: $72; rl: 896), // 0000 0011 1001 0
    (dim: 13; code: $73; rl: 960), // 0000 0011 1001 1
    (dim: 13; code: $74; rl: 1024), // 0000 0011 1010 0
    (dim: 13; code: $75; rl: 1088), // 0000 0011 1010 1
    (dim: 13; code: $76; rl: 1152), // 0000 0011 1011 0
    (dim: 13; code: $77; rl: 1216), // 0000 0011 1011 1
    (dim: 13; code: $52; rl: 1280), // 0000 0010 1001 0
    (dim: 13; code: $53; rl: 1344), // 0000 0010 1001 1
    (dim: 13; code: $54; rl: 1408), // 0000 0010 1010 0
    (dim: 13; code: $55; rl: 1472), // 0000 0010 1010 1
    (dim: 13; code: $5A; rl: 1536), // 0000 0010 1101 0
    (dim: 13; code: $5B; rl: 1600), // 0000 0010 1101 1
    (dim: 13; code: $64; rl: 1664), // 0000 0011 0010 0
    (dim: 13; code: $65; rl: 1728), // 0000 0011 0010 1
    (dim: 11; code: $8; rl: 1792), // 0000 0001 000
    (dim: 11; code: $C; rl: 1856), // 0000 0001 100
    (dim: 11; code: $D; rl: 1920), // 0000 0001 101
    (dim: 12; code: $12; rl: 1984), // 0000 0001 0010
    (dim: 12; code: $13; rl: 2048), // 0000 0001 0011
    (dim: 12; code: $14; rl: 2112), // 0000 0001 0100
    (dim: 12; code: $15; rl: 2176), // 0000 0001 0101
    (dim: 12; code: $16; rl: 2240), // 0000 0001 0110
    (dim: 12; code: $17; rl: 2304), // 0000 0001 0111
    (dim: 12; code: $1C; rl: 2368), // 0000 0001 1100
    (dim: 12; code: $1D; rl: 2432), // 0000 0001 1101
    (dim: 12; code: $1E; rl: 2496), // 0000 0001 1110
    (dim: 12; code: $1F; rl: 2560), // 0000 0001 1111
    (dim: 12; code: $1; rl: G3CODE_EOL), // 0000 0000 0001
    (dim: 9; code: $1; rl: G3CODE_INVALID), // 0000 0000 1
    (dim: 10; code: $1; rl: G3CODE_INVALID), // 0000 0000 01
    (dim: 11; code: $1; rl: G3CODE_INVALID), // 0000 0000 001
    (dim: 13; code: $1; rl: G3CODE_EOL), // 0000000000001
    (dim: 14; code: $1; rl: G3CODE_EOL), // 00000000000001
    (dim: 15; code: $1; rl: G3CODE_EOL), // 000000000000001
    (dim: 16; code: $1; rl: G3CODE_EOL), // 0000000000000001
    (dim: 17; code: $1; rl: G3CODE_EOL), // 00000000000000001
    (dim: 18; code: $1; rl: G3CODE_EOL), // 000000000000000001
    (dim: 19; code: $1; rl: G3CODE_EOL), // 0000000000000000001
    (dim: 20; code: $1; rl: G3CODE_EOL), // 00000000000000000001
    //
    (dim: 21; code: $1; rl: G3CODE_EOL), // 000000000000000000001
    (dim: 22; code: $1; rl: G3CODE_EOL), // 0000000000000000000001
    (dim: 23; code: $1; rl: G3CODE_EOL), // 00000000000000000000001
    (dim: 24; code: $1; rl: G3CODE_EOL), // 000000000000000000000001
    (dim: 25; code: $1; rl: G3CODE_EOL), // 0000000000000000000000001
    (dim: 26; code: $1; rl: G3CODE_EOL), // 00000000000000000000000001
    (dim: 27; code: $1; rl: G3CODE_EOL), // 000000000000000000000000001
    (dim: 28; code: $1; rl: G3CODE_EOL), // 0000000000000000000000000001
    (dim: 29; code: $1; rl: G3CODE_EOL), // 00000000000000000000000000001
    (dim: 30; code: $1; rl: G3CODE_EOL), // 000000000000000000000000000001
    (dim: 31; code: $1; rl: G3CODE_EOL), // 0000000000000000000000000000001
    (dim: 32; code: $1; rl: G3CODE_EOL) // 00000000000000000000000000000001
    ));

const
  horizcode: TT4Entry = (dim: 3; code: $1); // 001
const
  passcode: TT4Entry = (dim: 4; code: $1); // 0001
const
  vcodes: array[0..6] of TT4Entry = ((dim: 7; code: $3), // 0000 011
    (dim: 6; code: $3), // 0000 11
    (dim: 3; code: $3), // 011
    (dim: 1; code: $1), // 1
    (dim: 3; code: $2), // 010
    (dim: 6; code: $2), // 0000 10
    (dim: 7; code: $2)); // 0000 010

  ///////////////////////////////////////////////////////////////////////////////////////////
  // converte 0 in 1 e 1 in 0
  (*
  function LNot(v:integer):integer;
  begin
   //if v=0 then result:=1 else result:=0;
     result:= (not v) and $1;
  end;
  *)

function AdjustWithFillOrder(dwo: dword; posb: integer; FillOrder: integer): dword;
begin
  if FillOrder = 1 then
  begin
    // inverte byte della dword dwo
    asm
	   	mov EAX,dwo
	   	bswap EAX
	      mov dwo,EAX

    end;
    dwo := (dwo shl (posb and 7));
  end
  else
  begin
    // FillOrder=2
    dwo := (dwo shr (posb and 7));
    ReverseBits(dwo);
  end;
  result := dwo;
end;

// trova il codice corrispondente a quello puntato da posb
// srcbuf: puntatore di inizio bits
// posb: bit all'interno di srcbuf da leggere (inizio codice)
// WB: 0=usa white code     1=usa black code

function FindCode(srcbuf: pbyte; srcbufLen:integer; posb, WB: integer; FillOrder: integer): integer;
var
  ibi: integer;
  dwo: dword;
  q: integer;
  curtree: PT4Tree;
begin
  result := NUMCODES; // invalid code
  ibi := posb shr 3;  // divide by 8 (calculates related byte)
  if ibi<srcbufLen then
  begin
    dwo := pinteger(@pbytearray(srcbuf)^[ibi])^;
    dwo := AdjustWithFillOrder(dwo, posb, FillOrder);
    // find code
    curtree := @(T4Tree[WB]);
    q := 31;
    repeat
      if curtree^.code <> NUMCODES then
      begin
        result := curtree^.code;
        break;
      end;
      curtree := curtree^.childs[ord((dwo and (1 shl q)) <> 0)];
      dec(q);
    until q < 0;
  end
  else
    result:=NUMCODES-1; // wrong position, send EOL
end;

///////////////////////////////////////////////////////////////////////////////////////////
// trova il MODO corrispondente a quello puntato da posb
// srcbuf: puntatore di inizio bits
// posb: bit all'interno di srcbuf da leggere (inizio codice)

function FindMode(srcbuf: pbyte; posb: integer; FillOrder: integer): integer;
var
  ibi: integer;
  dwo, tdwo: dword;
  q: integer;
begin
  result := 0; // codice invalido
  ibi := posb shr 3; // divide per 8 (trova byte corrispondente)
  dwo := pinteger(@pbytearray(srcbuf)^[ibi])^;
  dwo := AdjustWithFillOrder(dwo, posb, FillOrder);
  // cerca modo
  for q := 0 to 12 do
  begin
    tdwo := dwo shr (32 - T4_2DC[q].dim);
    if tdwo = T4_2DC[q].code then
    begin
      result := q;
      break;
    end;
  end;
end;

///////////////////////////////////////////////////////////////////////////////////////////
// restituisce una parola formata dal numero di bit specificati (max 32)

function getpels(srcbuf: pbyte; posb: integer; nbit: integer; FillOrder: integer): integer;
var
  ibi: integer;
  dwo: dword;
begin
  ibi := posb shr 3; // divide per 8 (trova byte corrispondente)
  dwo := pinteger(@pbytearray(srcbuf)^[ibi])^;
  dwo := AdjustWithFillOrder(dwo, posb, FillOrder);
  //
  result := dwo shr (32 - nbit);
end;

///////////////////////////////////////////////////////////////////////////////////////////
// decodifica codice non compresso dal buffer srcbuf, posizione (in bit) posb
// la lunghezza del codice restituito corrisponde al valore stesso del codice

function decode_uncomp_code(srcbuf: pbyte; posb: integer; FillOrder: integer): integer;
var
  ibi: integer;
  dwo, tdwo: dword;
  q: integer;
begin
  result := 0; // codice invalido (i codici validi cominciano da 1..)
  ibi := posb shr 3; // divide per 8 (trova byte corrispondente)
  dwo := pinteger(@pbytearray(srcbuf)^[ibi])^;
  dwo := AdjustWithFillOrder(dwo, posb, FillOrder);
  //
  for q := 1 to 11 do
  begin
    tdwo := dwo shr (32 - q);
    if tdwo = 1 then
    begin
      result := q;
      break;
    end;
  end;
end;

///////////////////////////////////////////////////////////////////////////////////////////
// replica "1"(0) per "rl" volte
// destbuf = buffer di destinazione
// posw = bit all'interno di dstbuf (inizio scrittura)
// rl = numero di bit da replicare
// WB = bit da replicare invertito (0 o 1)
// Width = dimensione riga

procedure PutCode(dstbuf: pbyte; posw: integer; rl: integer; Width: integer);
var
  q: integer;
  ibi, abi: integer;
begin
  rl := imin(Width - posw, rl);
  q := 0;
  while q < rl do
  begin
    ibi := posw shr 3;
    abi := (rl - q) and $FFF8;
    if ((posw and $7) = 0) and (abi > 0) then
    begin
      fillchar(pbyte(integer(dstbuf) + ibi)^, (rl - q) shr 3, 0);
      inc(posw, abi);
      inc(q, abi);
    end
    else
    begin
      pbytearray(dstbuf)^[ibi] := pbytearray(dstbuf)^[ibi] and (not bitmask[posw and 7]);
      inc(posw);
      inc(q);
    end;
  end;
end;

///////////////////////////////////////////////////////////////////////////////////////////
// decomprime riga HUFFMAN
// dstbuf = buffer destinazione (deve essere gi