ace/lib/audiodriver/wavfifo.go

package audiodriver

import (
	"context"
	"encoding/binary"
	"errors"
	"io"
	"os"
	"time"

	"github.com/pion/mediadevices/pkg/io/audio"
	"github.com/pion/mediadevices/pkg/prop"
	"github.com/pion/mediadevices/pkg/wave"
	"github.com/sirupsen/logrus"
)

const (
	DataChunkIDSize   = 4
	DataChunkSizeSize = 4
)

// BufferSize for pcm bytes
const BufferSize = 512
const BitsPerByte = 8

type WavFIFODriver struct {
	FIFOFile   string
	f          *os.File
	waveHeader *WavHeader
	closed     <-chan struct{}
	cancel     func()
}

func New(fifoname string) *WavFIFODriver {
	return &WavFIFODriver{
		FIFOFile: fifoname,
	}
}

func (w *WavFIFODriver) Open() error {
	ctx, cancel := context.WithCancel(context.Background())
	w.closed = ctx.Done()
	w.cancel = cancel

	f, err := os.Open(w.FIFOFile)
	if err != nil {
		return err
	}

	w.f = f
	w.waveHeader = &WavHeader{}
	return w.waveHeader.Parse(f)
}

func (w *WavFIFODriver) Close() error {
	defer w.cancel()
	return w.f.Close()
}

func (w *WavFIFODriver) Properties() []prop.Media {
	return []prop.Media{
		{
			Audio: prop.Audio{
				SampleRate:    int(w.waveHeader.SampleRate),
				ChannelCount:  int(w.waveHeader.NumChannels),
				Latency:       time.Millisecond * time.Duration(BufferSize) / time.Duration(w.waveHeader.SampleRate) / time.Duration(w.waveHeader.NumChannels),
				IsFloat:       false, // just 8bit or 16bit with qemu
				IsBigEndian:   false, // qemu should be little endian
				IsInterleaved: true,
			},
		},
	}
}

func (w *WavFIFODriver) AudioRecord(p prop.Media) (audio.Reader, error) {
	logrus.Debugf("wave header: %v", w.waveHeader)
	offset := FmtHeaderOffset + FmtHeaderIDSize + FmtHeaderChunkSizeSize + int64(w.waveHeader.Size) + DataChunkIDSize + DataChunkSizeSize
	if _, err := w.f.Seek(
		offset,
		io.SeekStart,
	); err != nil {
		return nil, err
	}

	var pcm <-chan [BufferSize]byte
	go func() {
		samples := make(chan [BufferSize]byte, BufferSize)
		defer close(samples)

		pcm = samples
		for {
			var b [BufferSize]byte
			if _, err := w.f.Read(b[:]); err != nil {
				if errors.Is(err, io.EOF) {
					return
				}
				logrus.Errorf("read audio stream error: %v", err)
				continue
			}
			samples <- b
		}
	}()

	reader := func() (wave.Audio, func(), error) {
		select {
		case <-w.closed:
			return nil, func() {}, io.EOF
		case pcmData, ok := <-pcm:
			logrus.Debug("got %d bytes pcm data", len(pcmData))
			if !ok {
				return nil, func() {}, io.ErrClosedPipe
			}

			a := wave.NewInt16Interleaved(wave.ChunkInfo{
				Len:          BufferSize / int(w.waveHeader.BitsPerSample/BitsPerByte),
				Channels:     p.ChannelCount,
				SamplingRate: p.SampleRate,
			})
			copy(a.Data, bytesTo16BitSamples(pcmData[:]))
			return a, func() {}, nil
		}
	}
	return audio.ReaderFunc(reader), nil
}

func bytesTo16BitSamples(b []byte) []int16 {
	samples := make([]int16, 0)
	for i := 0; i < len(b); i += 2 {
		sample := binary.LittleEndian.Uint16(b[i : i+1])
		samples = append(samples, int16(sample))
	}
	return samples
}