207 lines
4.3 KiB
Go
207 lines
4.3 KiB
Go
package sound
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
|
|
"github.com/BeatGlow/audio"
|
|
|
|
"github.com/BeatGlow/beatglow/config"
|
|
)
|
|
|
|
func init() {
|
|
Register("fifo", newReader)
|
|
Register("file", newReader)
|
|
}
|
|
|
|
type Source interface {
|
|
String() string
|
|
|
|
// ReadBuffer reads samples.
|
|
ReadBuffer(audio.Buffer[float64]) (int, error)
|
|
|
|
// Channels is the number of channels.
|
|
Channels() int
|
|
|
|
// BitDepth is the number of bits per sample.
|
|
BitDepth() int
|
|
|
|
// SampleRate is the sample rate in samples per second.
|
|
SampleRate() int
|
|
}
|
|
|
|
type Reader struct {
|
|
io.ReadCloser
|
|
|
|
// Name of the reader (path).
|
|
Name string
|
|
|
|
// Ch is the number of channels.
|
|
Ch int
|
|
|
|
// Bits is the bit depth.
|
|
Bits int
|
|
|
|
// Rate is the sample rate.
|
|
Rate int
|
|
|
|
// Order is the byte order.
|
|
Order binary.ByteOrder
|
|
|
|
// Opener is a function that can be called if the reader is closed.
|
|
Opener func() (io.ReadCloser, error)
|
|
|
|
// buffers are allocated on the fly
|
|
buffer []byte
|
|
bufferFloat audio.Samples[float64]
|
|
bufferInt8 audio.Samples[int8]
|
|
bufferInt16 audio.Samples[int16]
|
|
}
|
|
|
|
func newReader(config *config.Audio) (Source, error) {
|
|
var (
|
|
ch = config.Channels
|
|
bits = config.Bits
|
|
rate = config.Rate
|
|
order binary.ByteOrder = binary.LittleEndian
|
|
)
|
|
if ch == 0 {
|
|
ch = 2
|
|
}
|
|
if bits == 0 {
|
|
bits = 16
|
|
}
|
|
if rate == 0 {
|
|
rate = 44100
|
|
}
|
|
if config.BigEndian {
|
|
order = binary.BigEndian
|
|
}
|
|
return &Reader{
|
|
Name: config.Path,
|
|
Ch: ch,
|
|
Bits: bits,
|
|
Rate: rate,
|
|
Order: order,
|
|
Opener: func() (io.ReadCloser, error) { return os.Open(config.Path) },
|
|
buffer: make([]byte, 1024*ch*(bits>>4)),
|
|
bufferFloat: make(audio.Samples[float64], 1024*ch),
|
|
bufferInt8: make(audio.Samples[int8], 1024*ch*(bits>>4)),
|
|
bufferInt16: make(audio.Samples[int16], 1024*ch*(bits>>4)),
|
|
}, nil
|
|
}
|
|
|
|
func (s Reader) String() string {
|
|
return "reader " + s.Name
|
|
}
|
|
|
|
func (s Reader) Channels() int {
|
|
return s.Ch
|
|
}
|
|
|
|
func (s Reader) BitDepth() int {
|
|
return s.Bits
|
|
}
|
|
|
|
func (s Reader) SampleRate() int {
|
|
return s.Rate
|
|
}
|
|
|
|
func (s *Reader) ReadBuffer(buffer audio.Buffer[float64]) (n int, err error) {
|
|
// Ensure we have an open reader.
|
|
if s.ReadCloser == nil {
|
|
var err error
|
|
if s.ReadCloser, err = s.Opener(); err != nil {
|
|
s.ReadCloser = nil
|
|
return 0, err
|
|
}
|
|
}
|
|
|
|
switch s.Bits {
|
|
case 8:
|
|
n, err = s.readBufferInt8(buffer)
|
|
case 16:
|
|
n, err = s.readBufferInt16(buffer)
|
|
default:
|
|
return 0, fmt.Errorf("sound: unsupported bit depth %d for Reader", s.Bits)
|
|
}
|
|
|
|
if err != nil {
|
|
_ = s.ReadCloser.Close()
|
|
s.ReadCloser = nil
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func (s *Reader) readBufferInt8(buffer audio.Buffer[float64]) (int, error) {
|
|
var (
|
|
samples = buffer.Samples()
|
|
channels = buffer.Channels()
|
|
length = samples * channels
|
|
)
|
|
|
|
// Dynamically resize, if needed.
|
|
if l := len(s.bufferFloat); l != length {
|
|
s.buffer = make([]byte, length)
|
|
s.bufferFloat = make(audio.Samples[float64], length)
|
|
s.bufferInt8 = make(audio.Samples[int8], length)
|
|
}
|
|
|
|
// Read bytes
|
|
if n, err := io.ReadFull(s.ReadCloser, s.buffer); err != nil {
|
|
return n, err
|
|
}
|
|
|
|
// Convert
|
|
s.bufferInt8.Decode(s.buffer, s.Order) // bytes -> int8
|
|
s.bufferInt8.ToFloat(s.bufferFloat) // int8 -> float64
|
|
|
|
if channels == 1 {
|
|
// Straight conversion into the target buffer.
|
|
return copy(buffer[0], s.bufferFloat), nil
|
|
}
|
|
|
|
// Deinterleave.
|
|
audio.Deinterleave(buffer, s.bufferFloat, channels)
|
|
|
|
return samples, nil
|
|
}
|
|
|
|
func (s *Reader) readBufferInt16(buffer audio.Buffer[float64]) (int, error) {
|
|
var (
|
|
samples = buffer.Samples()
|
|
channels = buffer.Channels()
|
|
length = samples * channels
|
|
)
|
|
|
|
// Dynamically resize, if needed.
|
|
//if l := len(s.bufferFloat); l != length {
|
|
s.buffer = make([]byte, length*2)
|
|
s.bufferFloat = make(audio.Samples[float64], length)
|
|
s.bufferInt16 = make(audio.Samples[int16], length)
|
|
//}
|
|
|
|
// Read bytes
|
|
if n, err := io.ReadFull(s.ReadCloser, s.buffer); err != nil {
|
|
return n, err
|
|
}
|
|
//logrus.Printf("read %d bytes: %#02x", len(s.buffer), s.buffer)
|
|
|
|
// Convert
|
|
s.bufferInt16.Decode(s.buffer, s.Order) // bytes -> int16
|
|
s.bufferInt16.ToFloat(s.bufferFloat) // int16 -> float64
|
|
|
|
if channels == 1 {
|
|
// Straight conversion into the target buffer.
|
|
return copy(buffer[0], s.bufferFloat), nil
|
|
}
|
|
|
|
// Deinterleave.
|
|
audio.Deinterleave(buffer, s.bufferFloat, channels)
|
|
|
|
return samples, nil
|
|
}
|