Move changes from exp2 to main

This is largely a move to simplify a lot of the readers
Also further breaks out functions.

internal/data/fullreader.go

@@ -0,0 +1,115 @@
+package data
+
+import (
+	"io"
+
+	"github.com/CalebQ42/squashfs/internal/decompress"
+	"github.com/CalebQ42/squashfs/internal/toreader"
+)
+
+type FullReader struct {
+	r         io.ReaderAt
+	d         decompress.Decompressor
+	fragRdr   io.Reader
+	sizes     []uint32
+	blockSize uint32
+	start     uint64
+}
+
+func NewFullReader(r io.ReaderAt, start uint64, d decompress.Decompressor, blockSizes []uint32, blockSize uint32) *FullReader {
+	return &FullReader{
+		r:         r,
+		start:     start,
+		blockSize: blockSize,
+		sizes:     blockSizes,
+		d:         d,
+	}
+}
+
+func (r *FullReader) AddFragment(rdr io.Reader) {
+	r.fragRdr = rdr
+}
+
+type outDat struct {
+	err  error
+	data []byte
+	i    int
+}
+
+func (r FullReader) process(index int, offset int64, out chan outDat) {
+	var err error
+	var dat []byte
+	size := realSize(r.sizes[index])
+	rdr := io.LimitReader(toreader.NewReader(r.r, offset), int64(size))
+	if size == r.sizes[index] {
+		rdr, err = r.d.Reader(rdr)
+	}
+	if err == nil {
+		dat, err = io.ReadAll(rdr)
+	}
+	out <- outDat{
+		i:    index,
+		err:  err,
+		data: dat,
+	}
+	if clr, ok := rdr.(io.Closer); ok {
+		clr.Close()
+	}
+}
+
+func (r FullReader) WriteTo(w io.Writer) (n int64, err error) {
+	out := make(chan outDat, len(r.sizes))
+	offset := r.start
+	num := len(r.sizes)
+	for i := 0; i < num; i++ {
+		if i == num-1 && r.fragRdr != nil {
+			go func() {
+				dat, e := io.ReadAll(r.fragRdr)
+				out <- outDat{
+					i:    num,
+					err:  e,
+					data: dat,
+				}
+				if clr, ok := r.fragRdr.(io.Closer); ok {
+					clr.Close()
+				}
+			}()
+			continue
+		}
+		go r.process(i, int64(offset), out)
+		offset += uint64(realSize(r.sizes[i]))
+	}
+	cache := make(map[int]outDat)
+	var tmpN int
+	for cur := 0; cur < num; {
+		dat := <-out
+		if dat.err != nil {
+			err = dat.err
+			return
+		}
+		if dat.i != cur {
+			cache[dat.i] = dat
+			continue
+		}
+		tmpN, err = w.Write(dat.data)
+		n += int64(tmpN)
+		if err != nil {
+			return
+		}
+		cur++
+		var ok bool
+		for {
+			dat, ok = cache[cur]
+			if !ok {
+				break
+			}
+			tmpN, err = w.Write(dat.data)
+			n += int64(tmpN)
+			if err != nil {
+				return
+			}
+			cur++
+		}
+	}
+	return
+}

internal/data/reader.go

@@ -0,0 +1,77 @@
+package data
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/CalebQ42/squashfs/internal/decompress"
+)
+
+type Reader struct {
+	master     io.Reader
+	cur        io.Reader
+	fragRdr    io.Reader
+	d          decompress.Decompressor
+	blockSizes []uint32
+	blockSize  uint32
+}
+
+func NewReader(r io.Reader, d decompress.Decompressor, blockSizes []uint32, blockSize uint32) (*Reader, error) {
+	var out Reader
+	out.d = d
+	out.master = r
+	out.blockSizes = blockSizes
+	out.blockSize = blockSize
+	err := out.advance()
+	return &out, err
+}
+
+func (r *Reader) AddFragment(rdr io.Reader) {
+	r.fragRdr = rdr
+}
+
+func realSize(siz uint32) uint32 {
+	return siz &^ (1 << 24)
+}
+
+func (r *Reader) advance() (err error) {
+	if clr, ok := r.cur.(io.Closer); ok {
+		clr.Close()
+	}
+	if len(r.blockSizes) == 0 {
+		return io.EOF
+	}
+	if len(r.blockSizes) == 1 && r.fragRdr != nil {
+		r.cur = r.fragRdr
+	} else {
+		size := realSize(r.blockSizes[0])
+		if size == 0 {
+			r.cur = bytes.NewReader(make([]byte, r.blockSize))
+		} else {
+			r.cur = io.LimitReader(r.master, int64(size))
+			if size == r.blockSizes[0] {
+				r.cur, err = r.d.Reader(r.cur)
+			}
+		}
+	}
+	r.blockSizes = r.blockSizes[1:]
+	return
+}
+
+func (r *Reader) Read(p []byte) (n int, err error) {
+	n, err = r.cur.Read(p)
+	if err == io.EOF {
+		err = r.advance()
+		if err != nil {
+			return
+		}
+		var tmpN int
+		tmp := make([]byte, len(p)-n)
+		tmpN, err = r.Read(tmp)
+		for i := range tmp {
+			p[n+i] = tmp[i]
+		}
+		n += tmpN
+	}
+	return
+}