func (z *Writer) init(w io.Writer, level int) { digest := z.digest if digest != nil { digest.Reset() } else { digest = crc32.NewIEEE() } *z = Writer{ Header: Header{ OS: 255, // unknown }, w: w, level: level, digest: digest, pushedErr: make(chan error, 1), results: make(chan result, z.blocks), blockSize: z.blockSize, blocks: z.blocks, } z.dictFlatePool = &sync.Pool{ New: func() interface{} { f, _ := flate.NewWriterDict(w, level, nil) return f }, } z.dstPool = &sync.Pool{New: func() interface{} { return make([]byte, 0, z.blockSize) }} }
func (z *Writer) init(w io.Writer, level int) { z.wg.Wait() digest := z.digest if digest != nil { digest.Reset() } else { digest = crc32.NewIEEE() } z.Header = Header{OS: 255} z.w = w z.level = level z.digest = digest z.pushedErr = make(chan struct{}, 0) z.results = make(chan result, z.blocks) z.err = nil z.closed = false z.Comment = "" z.Extra = nil z.ModTime = time.Time{} z.wroteHeader = false z.currentBuffer = nil z.buf = [10]byte{} z.prevTail = nil z.size = 0 if z.dictFlatePool.New == nil { z.dictFlatePool.New = func() interface{} { f, _ := flate.NewWriterDict(w, level, nil) return f } } }
// Step 1: compresses buffer to buffer // Step 2: send writer to channel // Step 3: Close result channel to indicate we are done func compressBlock(p, prevTail []byte, z Writer, r result) { defer close(r.result) buf := make([]byte, 0, len(p)) dest := bytes.NewBuffer(buf) var compressor *flate.Writer var err error if len(prevTail) > 0 { compressor, err = flate.NewWriterDict(dest, z.level, prevTail) } else { compressor, err = flate.NewWriter(dest, z.level) } if err != nil { z.pushError(err) return } compressor.Write(p) err = compressor.Flush() if err != nil { z.pushError(err) return } if z.closed { err = compressor.Close() if err != nil { z.pushError(err) return } } // Read back buffer buf = dest.Bytes() r.result <- buf }
// writeHeader writes the ZLIB header. func (z *Writer) writeHeader() (err error) { z.wroteHeader = true // ZLIB has a two-byte header (as documented in RFC 1950). // The first four bits is the CINFO (compression info), which is 7 for the default deflate window size. // The next four bits is the CM (compression method), which is 8 for deflate. z.scratch[0] = 0x78 // The next two bits is the FLEVEL (compression level). The four values are: // 0=fastest, 1=fast, 2=default, 3=best. // The next bit, FDICT, is set if a dictionary is given. // The final five FCHECK bits form a mod-31 checksum. switch z.level { case -2, 0, 1: z.scratch[1] = 0 << 6 case 2, 3, 4, 5: z.scratch[1] = 1 << 6 case 6, -1: z.scratch[1] = 2 << 6 case 7, 8, 9: z.scratch[1] = 3 << 6 default: panic("unreachable") } if z.dict != nil { z.scratch[1] |= 1 << 5 } z.scratch[1] += uint8(31 - (uint16(z.scratch[0])<<8+uint16(z.scratch[1]))%31) if _, err = z.w.Write(z.scratch[0:2]); err != nil { return err } if z.dict != nil { // The next four bytes are the Adler-32 checksum of the dictionary. checksum := adler32.Checksum(z.dict) z.scratch[0] = uint8(checksum >> 24) z.scratch[1] = uint8(checksum >> 16) z.scratch[2] = uint8(checksum >> 8) z.scratch[3] = uint8(checksum >> 0) if _, err = z.w.Write(z.scratch[0:4]); err != nil { return err } } if z.compressor == nil { // Initialize deflater unless the Writer is being reused // after a Reset call. z.compressor, err = flate.NewWriterDict(z.w, z.level, z.dict) if err != nil { return err } z.digest = adler32.New() } return nil }