Kirika/audio/packetizer/flac.go

package packetizer

import (
	"bufio"
	flac_parser "github.com/mewkiz/flac"
	"io"
)

type FLACPacketizer struct {
	reader    io.Reader
	stream    *flac_parser.Stream
	offset    int64
	samples   int64
	bytesRead int64
	buffer    []byte
}

type FLACPacket struct {
	mode            KeepMode
	sampleNumber    int64
	endSampleNumber int64
	data            []byte
}

func (p *FLACPacket) KeepMode() KeepMode {
	return p.mode
}

func (p *FLACPacket) GetStartSampleNumber() int64 {
	return p.sampleNumber
}

func (p *FLACPacket) GetEndSampleNumber() int64 {
	return p.endSampleNumber
}

func (p *FLACPacket) GetData() []byte {
	return p.data
}

func (p *FLACPacket) Category() int64 {
	return 0
}

func NewFLACPacketizer(reader io.Reader) *FLACPacketizer {
	return &FLACPacketizer{reader: bufio.NewReader(reader)}
}

func (o *FLACPacketizer) Read(p []byte) (n int, err error) {
	n, err = o.reader.Read(p)
	if err == nil {
		o.buffer = append(o.buffer, p[:n]...)
	}
	o.bytesRead += int64(n)
	return
}

func (o *FLACPacketizer) Seek(offset int64, whence int) (int64, error) {
	if offset == 0 && whence == io.SeekCurrent {
		return o.bytesRead, nil
	}
	return 0, io.ErrNoProgress
}

func (o *FLACPacketizer) getBuffer() (buf []byte) {
	buf = make([]byte, len(o.buffer))
	copy(buf, o.buffer)
	o.buffer = o.buffer[:0]
	return
}

func (o *FLACPacketizer) GetPacket() (packet Packet) {
	var err error
	if o.stream == nil {
		o.stream, err = flac_parser.NewSeek(o)
		if err != nil {
			return nil
		}
		packet = &FLACPacket{
			mode:            Keep,
			sampleNumber:    0,
			endSampleNumber: 0,
			data:            o.getBuffer(),
		}
		return
	}

	frame, err := o.stream.ParseNext()

	if err != nil {
		return nil
	}

	sampleNumber := int64(frame.Num)
	if frame.HasFixedBlockSize {
		sampleNumber *= int64(frame.BlockSize)
	}
	packet = &FLACPacket{
		mode:            Discard,
		sampleNumber:    sampleNumber,
		endSampleNumber: sampleNumber + int64(frame.Subframes[0].NSamples),
		data:            o.getBuffer(),
	}

	return
}