ghostiam / binstruct Goto Github PK

type ChunkHeader struct {
	Size uint8
}
type Entry struct {
	Count   uint8
	Headers []ChunkHeader `bin:"len:Count"`
	Chunks  [][]byte      `bin:"ReadChunks"`
	// desired ("_currentIndex" or maybe "$", not sure)
	// Chunks [][]byte `bin:"len:Count,[len:Headers[_currentIndex].Size]"`
}

func (entry *Entry) ReadChunks(r binstruct.Reader) error {
	entry.Chunks = make([][]byte, len(entry.Headers))
	for i, header := range entry.Headers {
		buf := make([]byte, header.Size)
		read, err := r.Read(buf)
		if err != nil {
			return errors.Join(
				fmt.Errorf("failed to read chunk %d", i),
				err,
			)
		}
		if read != int(header.Size) {
			return fmt.Errorf("not enough data to read chunk %d", i)
		}
		entry.Chunks[i] = buf
	}
	return nil
}

func main() {
	data := []byte{
		0x02, // count of headers
		0x01, // header 1 size=1
		0x02, // header 2 size=2
		0x10, // chunk 1 data byte 1
		0x20, // chunk 2 data byte 1
		0x21, // chunk 2 data byte 2
	}
	reader := binstruct.NewReaderFromBytes(data, binary.LittleEndian, false)
	var entry Entry
	err := reader.Unmarshal(&entry)
	if err != nil {
		fmt.Printf("failed to parse: %s\n", err)
	}
	fmt.Println("data", entry)
}

type Bin struct {
	...
	Pin           struct {
		Pin1         []byte `bin:"len:4"` // LE
		Pin1Unknown  []byte `bin:"len:4"`
		Pin1Checksum uint16 `bin:"Uint16l,len:2"`
		Pin2         []byte `bin:"len:4"` // LE
		Pin2Unknown  []byte `bin:"len:4"`
		Pin2Checksum uint16 `bin:"Uint16l,len:2"`
	} // 20 bytes
        ...
}

// Uint16l returns a uint16 read as little endian
func (*Bin) Uint16l(r binstruct.Reader) (uint16, error) {
	var out uint16
	if err := binary.Read(r, binary.LittleEndian, &out); err != nil {
		return 0, err
	}
	return out, nil
}

type File struct {
	Offset uint64
	Size uint32
	
	InlineBuffer []byte `bin:"FileReadInlineBuffer"`
	// desired
	// InlineBuffer []byte `bin:"offsetStart:Offset, len:Size, restoreOffsetOrSomeBetterNameForThisFlag:true"`
}

func (file *File) FileReadInlineBuffer(r binstruct.Reader) error {
	oldPos, err := r.Seek(0, io.SeekCurrent)
	if err != nil {
		return err
	}

	_, err = r.Seek(int64(file.Offset), io.SeekStart)
	if err != nil {
		return err
	}

	size := int(file.Size)
	file.InlineBuffer = make([]byte, size)
	n, err := r.Read(file.InlineBuffer)
	if err != nil {
		return err
	}
	if n != size {
		return fmt.Errorf("failed to read inline buffer: expected %d bytes, got: %d", size, n)
	}

	_, err = r.Seek(oldPos, io.SeekStart)
	if err != nil {
		return err
	}
	return nil
}