ztvdeflate.pas

ziptv为delphi控件

   While (n <= 255) Do
   Begin
      static_ltree[n].dl.Len := 9;
      inc(n);
      inc(bl_count[9]);
   End;

   While (n <= 279) Do
   Begin
      static_ltree[n].dl.Len := 7;
      inc(n);
      inc(bl_count[7]);
   End;

//{$IFDEF DEFLATE64}
//   While (n <= 287) Do
//{$ELSE}
   While (n <= 284) Do
//{$ENDIF}
   Begin
      static_ltree[n].dl.Len := 8;
      inc(n);
      inc(bl_count[8]);
   End;

{$IFDEF DEFLATE64}
  	//if FUseDeflate64 then
      static_ltree[285].dl.len := 8 + 16;
      //static_ltree[285].dl.len := 8;
{$ELSE}
  	//else
   	static_ltree[285].dl.len := 8;
{$ENDIF}

   gen_codes(tree_ptr(@static_ltree), L_CODES + 1, bl_count);

{$IFDEF DEFLATE64}
   For n := 0 To D_CODES_DEF64 - 1 Do
{$ELSE}
   For n := 0 To D_CODES - 1 Do
{$ENDIF}
   Begin
      static_dtree[n].dl.Len := 5;
      static_dtree[n].fc.code := bi_reverse(n, 5);
   End;
   static_init_done := True;

   //gen_trees_header;
{$ELSE}
Begin
{$ENDIF}
End;
//-------------------------------------------------------------

Procedure init_block(Var s: deflate_state);
Var
   n: _int;                             { iterates over tree elements }
Begin
   For n := 0 To L_CODES - 1 Do
      s.dyn_ltree[n].fc.freq := 0;

{$IFDEF DEFLATE64}
   For n := 0 To D_CODES_DEF64 - 1 Do
{$ELSE}
   For n := 0 To D_CODES - 1 Do
{$ENDIF}
      s.dyn_dtree[n].fc.freq := 0;

   For n := 0 To BL_CODES - 1 Do
      s.bl_tree[n].fc.freq := 0;

   s.dyn_ltree[END_BLOCK].fc.freq := 1;
   s.static_len := longint(0);
   s.opt_len := longint(0);
   s.matches := 0;
   s.last_lit := 0;
End;
//-------------------------------------------------------------

Procedure _tr_init(Var s: deflate_state);
Begin
   tr_static_init();

   s.compressed_len := longint(0);
   s.l_desc.dyn_tree := tree_ptr(@s.dyn_ltree);
   s.l_desc.stat_desc := @static_l_desc;
   s.d_desc.dyn_tree := tree_ptr(@s.dyn_dtree);
   s.d_desc.stat_desc := @static_d_desc;
   s.bl_desc.dyn_tree := tree_ptr(@s.bl_tree);
   s.bl_desc.stat_desc := @static_bl_desc;
   s.bi_buf := 0;
   s.bi_valid := 0;
   s.last_eob_len := 8;                 { enough lookahead for inflate }

   init_block(s);
End;
//-------------------------------------------------------------

Procedure TRY_FREE(Var strm: ztv_stream; ptr: voidpf);
Begin
   strm.ZFREE(strm.opaque, ptr);
End;
//-------------------------------------------------------------

Function _deflateEnd(Var strm: ztv_stream): _int;
Var
   Status: _int;
   s: deflate_state_ptr;
Begin
   If (strm.state = Z_NULL) Then
   Begin
      Result := Z_STREAM_ERROR;
      Exit;
   End;

   s := deflate_state_ptr(strm.state);
   Status := s^.Status;
   If (Status <> INIT_STATE) And (Status <> BUSY_STATE) And
      (Status <> FINISH_STATE) Then
   Begin
      Result := Z_STREAM_ERROR;
      Exit;
   End;

   { Deallocate in reverse order of allocations: }
   TRY_FREE(strm, s^.pending_buf);
   TRY_FREE(strm, s^.head);
   TRY_FREE(strm, s^.prev);
   TRY_FREE(strm, s^.window);

   ZFREE(strm, s);
   strm.state := Z_NULL;

   If Status = BUSY_STATE Then
      Result := Z_DATA_ERROR
   Else
      Result := Z_OK;
End;
//-------------------------------------------------------------

Function deflateReset(Var strm: ztv_stream): _int;
Var
   s: deflate_state_ptr;
Begin
   If                                   {(@strm = Z_NULL) or}
      (strm.state = Z_NULL)
      Or (Not Assigned(strm.ZALLOC)) Or (Not Assigned(strm.ZFREE)) Then
   Begin
      Result := Z_STREAM_ERROR;
      Exit;
   End;

   strm.total_out := 0;
   strm.total_in := 0;
   //strm.msg := '';
   strm.data_type := Z_UNKNOWN;

   s := deflate_state_ptr(strm.state);
   s^.pending := 0;
   s^.pending_out := _pBytef(s^.pending_buf);

   If (s^.noheader < 0) Then
      s^.noheader := 0;

   If s^.noheader <> 0 Then
      s^.Status := BUSY_STATE
   Else
      s^.Status := INIT_STATE;

   strm.adler := 1;
   s^.last_flush := Z_NO_FLUSH;

   _tr_init(s^);
   lm_init(s^);

   Result := Z_OK;
End;
//-------------------------------------------------------------

Function deflateInit2_(Var strm: ztv_stream;
   level: _int;
   method: _int;
   windowBits: _int;
   memLevel: _int;
   strategy: _int;
   stream_size: _int): _int;
Var
   s: deflate_state_ptr;
   noheader: _int;
   overlay: pushfArray;
Begin
   noheader := 0;
   If (stream_size <> SizeOf(ztv_stream)) Then
   Begin
      Result := Z_VERSION_ERROR;
      Exit;
   End;

   //strm.msg := '';
   If Not Assigned(strm.ZALLOC) Then
   Begin
      strm.ZALLOC := @ztvAllocMem;
      strm.opaque := voidpf(0);
   End;
   If Not Assigned(strm.ZFREE) Then
      strm.ZFREE := @ztvFreeMem;

   If (level = Z_DEFAULT_COMPRESSION) Then
      level := ztvDeflateN;
{$IFDEF FASTEST}
   level := 1;
{$ENDIF}

   If (windowBits < 0) Then
   Begin
      noheader := 1;
      windowBits := -windowBits;
   End;

{$IFDEF DEFLATE64}
   If (memLevel < 1) Or (memLevel > MAX_MEM_LEVEL) Or (method <> Z_DEFLATE64)
{$ELSE}
   If (memLevel < 1) Or (memLevel > MAX_MEM_LEVEL) Or (method <> Z_DEFLATED)
{$ENDIF}
      Or (windowBits < 8) Or (windowBits > 15) Or (level < 0)
      Or (level > 9) Or (strategy < 0) Or (strategy > Z_HUFFMAN_ONLY) Then
   Begin
      Result := Z_STREAM_ERROR;
      Exit;
   End;

   s := deflate_state_ptr(ZALLOC(strm, 1, SizeOf(deflate_state)));
   If (s = Z_NULL) Then
   Begin
      Result := Z_MEM_ERROR;
      Exit;
   End;

   strm.state := pInternal_state(s);
   s^.strm := @strm;
   s^.noheader := noheader;
   s^.w_bits := windowBits;

{$IFDEF DEFLATE64}
   s^.w_size := 2 Shl s^.w_bits;
{$ELSE}
   s^.w_size := 1 Shl s^.w_bits;
{$ENDIF}

   s^.w_mask := s^.w_size - 1;
   s^.hash_bits := memLevel + 7;
   s^.hash_size := 1 Shl s^.hash_bits;
   s^.hash_mask := s^.hash_size - 1;
   s^.hash_shift := ((s^.hash_bits + MIN_MATCH - 1) Div MIN_MATCH);
   s^.window := pzByteArray(ZALLOC(strm, s^.w_size, 2 * SizeOf(Byte)));
   s^.prev := pzPosfArray(ZALLOC(strm, s^.w_size, SizeOf(_Pos)));
   s^.head := pzPosfArray(ZALLOC(strm, s^.hash_size, SizeOf(_Pos)));
{$IFDEF DEFLATE64}
   s^.lit_bufsize := 1 Shl (memLevel + 7); { 32K elements by default }
   //deflate64
{$ELSE}
   s^.lit_bufsize := 1 Shl (memLevel + 6); { 16K elements by default }
{$ENDIF}

   overlay := pushfArray(ZALLOC(strm, s^.lit_bufsize, SizeOf(ush) + 2));
   s^.pending_buf := pzByteArray(overlay);
   s^.pending_buf_size := longint(s^.lit_bufsize) * (SizeOf(ush) + longint(2));

   If (s^.window = Z_NULL) Or (s^.prev = Z_NULL) Or (s^.head = Z_NULL)
      Or (s^.pending_buf = Z_NULL) Then
   Begin
      //strm.msg := z_errmsg[z_errbase - Z_MEM_ERROR];
      _deflateEnd(strm);
      Result := Z_MEM_ERROR;
      Exit;
   End;

   s^.d_buf := pushfArray(@overlay^[s^.lit_bufsize Div SizeOf(ush)]);
   s^.l_buf := puchfArray(@s^.pending_buf^[(1 + SizeOf(ush)) * s^.lit_bufsize]);
   s^.level := level;
   s^.strategy := strategy;
   s^.method := Byte(method);

   Result := deflateReset(strm);
End;
//-------------------------------------------------------------

Function deflateInit2(Var strm: ztv_stream; level: _int; method: _int;
   windowBits: _int; memLevel: _int; strategy: _int): _int;
Begin
   Result := deflateInit2_(strm, level, method, windowBits, memLevel,
      strategy, SizeOf(ztv_stream));
End;
//-------------------------------------------------------------

Function deflateInit_(strm: ztv_streamp; level: _int; MAX_WBITS: smallint;
   stream_size: _int): _int;
Begin
   If (strm = Z_NULL) Then
      Result := Z_STREAM_ERROR
   Else
      Result := deflateInit2_(strm^, level, Z_DEFLATED, MAX_WBITS,
         DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, stream_size);
End;
//-------------------------------------------------------------

{Function _deflateInit( Var strm: ztv_stream; level: _int; MAX_WBITS: SmallInt ): _int;
Begin
   Result := deflateInit2_( strm, level, Z_DEFLATED, MAX_WBITS,
      DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, SizeOf( ztv_stream ) );
End;}
//-------------------------------------------------------------

Function deflateSetDictionary(Var strm: ztv_stream; dictionary: _pBytef;
   dictLength: word): _int;
Var
   s: deflate_state_ptr;
   Length: word;
   n: word;
   hash_head: IPos;
Var
   MAX_DIST: word;
Begin
   Length := dictLength;
   hash_head := 0;

   If (strm.state = Z_NULL) Or (dictionary = Z_NULL)
      Or (deflate_state_ptr(strm.state)^.Status <> INIT_STATE) Then
   Begin
      Result := Z_STREAM_ERROR;
      Exit;
   End;

   s := deflate_state_ptr(strm.state);
   strm.adler := _adler(strm.adler, dictionary, dictLength);

   If (Length < MIN_MATCH) Then
   Begin
      Result := Z_OK;
      Exit;
   End;

{$IFDEF DEFLATE64}
   MAX_DIST := (s^.w_size - MIN_LOOKAHEAD_DEF64);
{$ELSE}
   MAX_DIST := (s^.w_size - MIN_LOOKAHEAD);
{$ENDIF}

   If (Length > MAX_DIST) Then
   Begin
      Length := MAX_DIST;
{$IFNDEF USE_DICT_HEAD}
      inc(dictionary, dictLength - Length); { use the tail of the dictionary }
{$ENDIF}
   End;

   CopyMem(@dictionary^, @s^.window^, Length);

   s^.strstart := Length;
   s^.block_start := longint(Length);
   s^.ins_h := s^.window^[0];
   s^.ins_h := ((s^.ins_h Shl s^.hash_shift) Xor (s^.window^[1]))