A better way to wrap go's zlib into a streaming decompressor

tools/utils/stream_decompressor.go

@@ -0,0 +1,101 @@
+// License: GPLv3 Copyright: 2023, Kovid Goyal, <kovid at kovidgoyal.net>
+
+package utils
+
+import (
+	"fmt"
+	"io"
+)
+
+var _ = fmt.Print
+
+// Decompress the data in chunk. output_callback() will be called zero or more times with decompressed data. Note that
+// it may be called in a different goroutine. The data provided to output_callback() is only valid for the lifetime of
+// output_callback(), so it should copy out the data.
+type StreamDecompressor = func(chunk []byte, is_last bool, output_callback func([]byte) error) error
+
+type output struct {
+	chunk []byte
+	err   error
+}
+
+type stream_decompressor struct {
+	impl     io.ReadCloser
+	pipe_r   *io.PipeReader
+	pipe_w   *io.PipeWriter
+	obuf     [8192]byte
+	err      error
+	callback func([]byte) error
+}
+
+func (self *stream_decompressor) process() {
+	for {
+		n, err := self.impl.Read(self.obuf[:])
+		if n > 0 {
+			if ocerr := self.callback(self.obuf[:n]); ocerr != nil {
+				self.pipe_r.CloseWithError(ocerr)
+				break
+			}
+		}
+		if err != nil {
+			self.pipe_r.CloseWithError(err)
+			break
+		}
+	}
+}
+
+func (self *stream_decompressor) next(chunk []byte, is_last bool, output_callback func([]byte) error) (err error) {
+	if self.err != nil {
+		return self.err
+	}
+	self.callback = output_callback
+	if _, err = self.pipe_w.Write(chunk); err != nil {
+		self.err = err
+		return err
+	}
+	if is_last {
+		defer func() {
+			self.pipe_r.Close()
+			self.pipe_w.Close()
+			if self.err == nil {
+				self.err = io.EOF
+			}
+		}()
+		self.err = self.impl.Close()
+		return self.err
+	}
+	return nil
+}
+
+// Wrap Go's awful decompressor routines to allow feeding them
+// data in chunks. For example:
+// sd, err := NewStreamDecompressor(zlib.NewReader)
+// sd(chunk, false, output_callback)
+// ...
+// sd(last_chunk, true, output_callback)
+// after this call calling sd() further will just return io.EOF
+func NewStreamDecompressor(constructor func(io.Reader) (io.ReadCloser, error)) (StreamDecompressor, error) {
+	if constructor == nil { // identity decompressor
+		var err error
+		return func(chunk []byte, is_last bool, cb func([]byte) error) error {
+			if err != nil {
+				return err
+			}
+			err = cb(chunk)
+			retval := err
+			if is_last && err != nil {
+				err = io.EOF
+			}
+			return retval
+		}, nil
+	}
+	s := stream_decompressor{}
+	s.pipe_r, s.pipe_w = io.Pipe()
+	rc, err := constructor(s.pipe_r)
+	if err != nil {
+		return nil, err
+	}
+	s.impl = rc
+	go s.process()
+	return s.next, nil
+}