zlib/examples/gznorm.c

84 // input. The pad bits after stored block headers and after the final deflate
106     unsigned long buf = 0;          // deflate stream bit buffer of num bits
107     int num = 0;                    // number of bits in buf (at bottom)
119         int prev;                   // number of bits from previous block in
200                     // block. If prev is not -1, then the bits in the bit
201                     // buffer, possibly combined with the bits in *put, contain
203                     // case, prev is the number of bits from the previous block
205                     // of bits in the bit buffer, we have that num - prev is
206                     // the number of bits from the new block currently in the
210                     // the available compressed data includes the last bits of
212                     // also has strm.data_type & 0x1f bits of the next deflate
216                     // 0x1f pad bits, also in the range 0..7.
218                     // Set bits to the number of bits not yet consumed from the
219                     // last byte. If we are at the end of the block, bits is
220                     // either the number of bits in the last byte belonging to
221                     // the next block, or the number of pad bits after the
222                     // final block. In either of those cases, bits is in the
225                     int bits = strm.data_type & 0x1f;
234                         // Some or all of the three header bits for this block
236                         // header bits into the bit buffer.
248                             // bits from this block, including the header, into
264                                 buf &= last - 1;    // zero the pad bits
271                             buf &= last - 1;        // zero the pad bits
285                         // consumed the byte that had bits from the next block.
287                             bits = 0;
293                     // end if it contains bits from the next deflate block or
294                     // pad bits at the end of a deflate block.
297                     // some of the bits in the last byte follow this block. mix
301                     int mix = (strm.data_type & 0x80) && bits;
304                     // except for the last byte if it contains bits from the
305                     // next deflate block or pad bits at the end of the deflate
306                     // stream. Copy the data after shifting in num bits from
307                     // buf in front of it, leaving num bits from the end of the
312                             // Insert num bits from buf before the data being
334                             // there are bits pad bits. Discard the pad bits
336                             // Leave the num bits left over in buf to prepend
338                             num -= bits;
345                             // Force the pad bits in the bit buffer to zeros.
353                             // the next entry to BLOCK, when more bits from the
355                             prev = num - bits;      // number of bits in buffer
365                         // bits are in the bit buffer.
374                         // pad bits were discarded, and any remaining bits from
428     // Write the remaining deflate stream bits, followed by a terminating