ztvinflate.pas

ziptv为delphi控件

                  Begin
                     {FLUSH}
                     s.Write := q;
                     R := inflate_flush(s, z, R);
                     q := s.Write;
                     If ptr2int(q) < ptr2int(s.Read) Then
                        m := _uInt(ptr2int(s.Read) - ptr2int(q) - 1)
                     Else
                        m := _uInt(ptr2int(s.zend) - ptr2int(q));

                     If (q = s.zend) And (s.Read <> s.window) Then
                     Begin
                        q := s.window;
                        If ptr2int(q) < ptr2int(s.Read) Then
                           m := _uInt(ptr2int(s.Read) - ptr2int(q) - 1)
                        Else
                           m := _uInt(ptr2int(s.zend) - ptr2int(q));
                     End;

                     If (m = 0) Then
                     Begin
                        s.bitb := b;
                        s.bitk := k;
                        z.avail_in := n;
                        inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
                        z.next_in := p;
                        s.Write := q;
                        Result := inflate_flush(s, z, R);
                        Exit;
                     End;
                  End;
               End;
               R := Z_OK;

               q^ := C^.sub.lit;
               inc(q);
               Dec(m);

               C^.mode := START;
            End;
         WASH:                          { o: got eob, possibly more output }
            Begin
{$IFDEF patch112}
               If (k > 7) Then          { return unused byte, if any }
               Begin
                  Dec(k, 8);
                  inc(n);
                  Dec(p);               { can always return one }
               End;
{$ENDIF}
               {FLUSH}
               s.Write := q;
               R := inflate_flush(s, z, R);
               q := s.Write;
               If ptr2int(q) < ptr2int(s.Read) Then
                  m := _uInt(ptr2int(s.Read) - ptr2int(q) - 1)
               Else
                  m := _uInt(ptr2int(s.zend) - ptr2int(q));

               If (s.Read <> s.Write) Then
               Begin
                  s.bitb := b;
                  s.bitk := k;
                  z.avail_in := n;
                  inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
                  z.next_in := p;
                  s.Write := q;
                  Result := inflate_flush(s, z, R);
                  Exit;
               End;
               C^.mode := zend;
            End;

         zend:
            Begin
               R := Z_STREAM_END;
               s.bitb := b;
               s.bitk := k;
               z.avail_in := n;
               inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
               z.next_in := p;
               s.Write := q;
               Result := inflate_flush(s, z, R);
               Exit;
            End;
         BADCODE:                       { x: got error }
            Begin
               R := Z_DATA_ERROR;
               s.bitb := b;
               s.bitk := k;
               z.avail_in := n;
               inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
               z.next_in := p;
               s.Write := q;
               Result := inflate_flush(s, z, R);
               Exit;
            End;
      Else
         Begin
            R := Z_STREAM_ERROR;
            s.bitb := b;
            s.bitk := k;
            z.avail_in := n;
            inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
            z.next_in := p;
            s.Write := q;
            Result := inflate_flush(s, z, R);
            Exit;
         End;
      End;

   Result := Z_STREAM_ERROR;
End;
//-------------------------------------------------------------

Function inflate_blocks(Var s: inflate_blocks_state; Var z: ztv_stream;
   R: _int): _int;
Label
   start_btree, start_dtree,
      start_blkdone, start_dry,
      start_codes;

Var
   t: _uInt;                             { temporary storage }
   b: u_long;                            { bit buffer }
   k: _uInt;                             { bits in bit buffer }
   p: _pBytef;                           { input data pointer }
   n: _uInt;                             { bytes available there }
   q: _pBytef;                           { output window write pointer }
   m: _uInt;                             { bytes to end of window or read pointer }

   bl, bd: {u_long; //}_uInt; //v6.1
   tl, td: phuft;
   H: phuft;
   i, j, C: _uInt;
   cs: pInflate_codes_state;

   { Tables for deflate from PKZIP's appnote.txt. }
Begin
   p := z.next_in;
   n := z.avail_in;
   b := s.bitb;
   k := s.bitk;
   q := s.Write;

   If ptr2int(q) < ptr2int(s.Read) Then
      m := _uInt(ptr2int(s.Read) - ptr2int(q) - 1)
   Else
      m := _uInt(ptr2int(s.zend) - ptr2int(q));

   While True Do
      Case s.mode Of
         ZTYPE:
            Begin                 
               While (k < 3) Do
               Begin
                  If (n <> 0) Then
                     R := Z_OK
                  Else
                  Begin
                     s.bitb := b;
                     s.bitk := k;
                     z.avail_in := n;
                     inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
                     z.next_in := p;
                     s.Write := q;
                     Result := inflate_flush(s, z, R);
                     Exit;
                  End;
                  Dec(n);
                  b := b Or (u_long(p^) Shl k);
                  inc(p);
                  inc(k, 8);
               End;

               t := _uInt(b) And 7; // v6.1
               //t := b And 7;

               s.last := Boolean(t And 1);
               Case (t Shr 1) Of
                  0:                    { stored }
                     Begin
                     	// DumpBits(3)
                        b := b Shr 3;
                        Dec(k, 3);

                        t := k And 7;   { go to byte boundary }

                        // DumpBits(t);
                        b := b Shr t;
                        Dec(k, t);

                        s.mode := LENS; { get length of stored block }
                     End;
                  1:                    { fixed }
                     Begin
                        Begin
                           inflate_trees_fixed(bl, bd, tl, td, z);
                           s.sub.decode.CODES := inflate_codes_new(bl, bd, tl, td, z);

                           If (s.sub.decode.CODES = Z_NULL) Then
                           Begin
                              R := Z_MEM_ERROR;
                              s.bitb := b;
                              s.bitk := k;
                              z.avail_in := n;
                              inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
                              z.next_in := p;
                              s.Write := q;
                              Result := inflate_flush(s, z, R);
                              Exit;
                           End;
                        End;

                        b := b Shr 3;
                        Dec(k, 3);

                        s.mode := CODES;
                     End;
                  2:                    { dynamic }
                     Begin
                        b := b Shr 3;
                        Dec(k, 3);

                        s.mode := TABLE;
                     End;
                  3:
                     Begin              { illegal }
                        b := b Shr 3;
                        Dec(k, 3);

                        s.mode := BLKBAD;
                        //invalid block type
                        R := Z_DATA_ERROR;
                        s.bitb := b;
                        s.bitk := k;
                        z.avail_in := n;
                        inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
                        z.next_in := p;
                        s.Write := q;
                        Result := inflate_flush(s, z, R);
                        Exit;
                     End;
               End;
            End;
         LENS:
            Begin
               While (k < 32) Do
               Begin
                  If (n <> 0) Then
                     R := Z_OK
                  Else
                  Begin
                     s.bitb := b;
                     s.bitk := k;
                     z.avail_in := n;
                     inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
                     z.next_in := p;
                     s.Write := q;
                     Result := inflate_flush(s, z, R);
                     Exit;
                  End;
                  Dec(n);
                  b := b Or (u_long(p^) Shl k);
                  inc(p);
                  inc(k, 8);
               End;

               If (((Not b) Shr 16) And $FFFF) <> (b And $FFFF) Then
               Begin
                  s.mode := BLKBAD;
                  //invalid stored block lengths
                  R := Z_DATA_ERROR;

                  // update pointers and return
                  s.bitb := b;
                  s.bitk := k;
                  z.avail_in := n;
                  inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
                  z.next_in := p;
                  s.Write := q;
                  Result := inflate_flush(s, z, R);
                  Exit;
               End;

               s.sub.left := _uInt(b) And $FFFF;
               k := 0;
               b := 0;                  { dump bits }

               If s.sub.left <> 0 Then
                  s.mode := STORED
               Else
                  If s.last Then
                     s.mode := DRY
                  Else
                     s.mode := ZTYPE;
            End;
         STORED:
            Begin
               If (n = 0) Then
               Begin
                  { update pointers and return }
                  s.bitb := b;
                  s.bitk := k;
                  z.avail_in := n;
                  inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
                  z.next_in := p;
                  s.Write := q;
                  Result := inflate_flush(s, z, R);
                  Exit;
               End;
               If (m = 0) Then
               Begin
                  If (q = s.zend) And (s.Read <> s.window) Then
                  Begin
                     q := s.window;
                     If ptr2int(q) < ptr2int(s.Read) Then
                        m := _uInt(ptr2int(s.Read) - ptr2int(q) - 1)
                     Else
                        m := _uInt(ptr2int(s.zend) - ptr2int(q));
                  End;

                  If (m = 0) Then
                  Begin
                     {FLUSH}
                     s.Write := q;
                     R := inflate_flush(s, z, R);
                     q := s.Write;
                     If ptr2int(q) < ptr2int(s.Read) Then
                        m := _uInt(ptr2int(s.Read) - ptr2int(q) - 1)
                     Else
                        m := _uInt(ptr2int(s.zend) - ptr2int(q));

                     If (q = s.zend) And (s.Read <> s.window) Then
                     Begin
                        q := s.window;
                        If ptr2int(q) < ptr2int(s.Read) Then
                           m := _uInt(ptr2int(s.Read) - ptr2int(q) - 1)
                        Else
                           m := _uInt(ptr2int(s.zend) - ptr2int(q));
                     End;

                     If (m = 0) Then
                     Begin
                        s.bitb := b;
                        s.bitk := k;
                        z.avail_in := n;
                        inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
                        z.next_in := p;
                        s.Write := q;
                        Result := inflate_flush(s, z, R);
                        Exit;
                     End;
                  End;
               End;
               R := Z_OK;

               t := s.sub.left;
               If (t > n) Then
                  t := n;
               If (t > m) Then
                  t := m;

               CopyMem(@p^, @q^, t);
               inc(p, t);
               Dec(n, t);
               inc(q, t);
               Dec(m, t);
               Dec(s.sub.left, t);
               If (s.sub.left = 0) Then
               Begin
                  If s.last Then
                     s.mode := DRY
                  Else
                     s.mode := ZTYPE;
               End;
            End;
         TABLE:
            Begin
               While (k < 14) Do
               Begin
                  If (n <> 0) Then
                     R := Z_OK
                  Else
                  Begin
                     s.bitb := b;
                     s.bitk := k;
                     z.avail_in := n;
                     inc(z.total_in, ptr2int(p) - ptr2int(z.next_in));
                     z.next_in := p;
                     s.Write := q;
                     Result := inflate_flush(s, z, R);
                     Exit;
                  End;
                  Dec(n);
                  b := b Or (u_long(p^) Shl k);
                  inc(p);
                  inc(k, 8);
               End;

               t := _uInt(b) And $3FFF; 
               //t := b And $3FFF;	//v6.1