package audio import ( "encoding/binary" "io" "math" "go.maze.io/harmon/internal/calc" ) // Buffer of audio samples. type Buffer interface { // Channels is the number of channels. Channels() int // Len is the number of samples per channel. Len() int // ReadFrom reads the buffer from r. ReadFrom(r io.Reader) (int, error) // Samples returns the buffer as float32s Samples() *Float32Buffer } type Int8Buffer struct { Buf []int8 Ch int floats *Float32Buffer } func NewInt8Buffer(size, channels int) *Int8Buffer { samples := size * channels return &Int8Buffer{ Buf: make([]int8, samples), Ch: channels, floats: NewFloat32Buffer(size, channels, nil), } } func (b *Int8Buffer) Channels() int { return b.Ch } func (b *Int8Buffer) Len() int { return len(b.Buf) / b.Ch } func (b *Int8Buffer) ReadFrom(r io.Reader) (int, error) { if err := binary.Read(r, nil, b.Buf); err != nil { return 0, err } for i, sample := range b.Buf { b.floats.Buf[i] = float32(sample) / math.MaxInt8 } return len(b.Buf), nil } func (b *Int8Buffer) Samples() *Float32Buffer { return b.floats } type Int16Buffer struct { Buf []int16 Ch int Order binary.ByteOrder floats *Float32Buffer } func NewInt16Buffer(size, channels int, order binary.ByteOrder) *Int16Buffer { if order == nil { order = binary.LittleEndian } samples := size * channels return &Int16Buffer{ Buf: make([]int16, samples), Ch: channels, Order: order, floats: NewFloat32Buffer(size, channels, nil), } } func (b *Int16Buffer) Channels() int { return b.Ch } func (b *Int16Buffer) Len() int { return len(b.Buf) / b.Ch } func (b *Int16Buffer) ReadFrom(r io.Reader) (int, error) { if err := binary.Read(r, b.Order, b.Buf); err != nil { return 0, err } for i, sample := range b.Buf { b.floats.Buf[i] = float32(sample) / math.MaxInt16 } return len(b.Buf), nil } func (b *Int16Buffer) Samples() *Float32Buffer { return b.floats } type Int32Buffer struct { Buf []int32 Ch int Order binary.ByteOrder floats *Float32Buffer } func NewInt32Buffer(size, channels int, order binary.ByteOrder) *Int32Buffer { if order == nil { order = binary.LittleEndian } samples := size * channels return &Int32Buffer{ Buf: make([]int32, samples), Ch: channels, Order: order, floats: NewFloat32Buffer(size, channels, nil), } } func (b *Int32Buffer) Channels() int { return b.Ch } func (b *Int32Buffer) Len() int { return len(b.Buf) / b.Ch } func (b *Int32Buffer) ReadFrom(r io.Reader) (int, error) { if err := binary.Read(r, b.Order, b.Buf); err != nil { return 0, err } for i, sample := range b.Buf { b.floats.Buf[i] = float32(sample) / math.MaxInt32 } return len(b.Buf), nil } func (b *Int32Buffer) Samples() *Float32Buffer { return b.floats } type Float32Buffer struct { Buf []float32 Ch int Order binary.ByteOrder } func NewFloat32Buffer(size, channels int, order binary.ByteOrder) *Float32Buffer { if order == nil { order = binary.BigEndian } samples := size * channels return &Float32Buffer{ Buf: make([]float32, samples), Ch: channels, Order: order, } } func (b *Float32Buffer) Channels() int { return b.Ch } func (b *Float32Buffer) Len() int { return len(b.Buf) / b.Ch } func (b *Float32Buffer) ReadFrom(r io.Reader) (int, error) { if err := binary.Read(r, b.Order, b.Buf); err != nil { return 0, err } return len(b.Buf), nil } func (b *Float32Buffer) CopyChannel(dst []float32, ch int) { if b.Ch == 1 { copy(dst, b.Buf) return } for i, l := ch, len(b.Buf); i < l; i += b.Ch { dst[i/b.Ch] = b.Buf[i] } } func (b *Float32Buffer) Samples() *Float32Buffer { return b } func (b *Float32Buffer) AsMono() *Float32Buffer { if b.Ch <= 1 { return b } o := NewFloat32Buffer(b.Len(), 1, b.Order) for i, l := 0, b.Len(); i < l; i++ { for c := 0; c < b.Ch; c++ { o.Buf[i] += b.Buf[i*b.Ch+c] } o.Buf[i] /= float32(b.Ch) } return o } func (b *Float32Buffer) AsStereo() *Float32Buffer { if b.Ch == 2 { return b } if b.Ch != 1 { return nil } var ( o = NewFloat32Buffer(b.Len(), 2, b.Order) j int ) for i, l := 0, b.Len(); i < l; i, j = i+1, j+2 { o.Buf[j+0] = b.Buf[i] o.Buf[j+1] = b.Buf[i] } return o } func (b *Float32Buffer) StereoPan(pan float32) { if b.Ch != 2 { return } if pan < 0 || pan > 1 { return } if almostEqualF32(pan, 0.5) { return } if pan < 0.5 { for i, l := 1, len(b.Buf); i < l; i += 2 { b.Buf[i] *= (pan * 2) } } else { for i, l := 0, len(b.Buf); i < l; i += 2 { b.Buf[i] *= ((1 - pan) * 2) } } } func (b *Float32Buffer) PeakRMS(channel int) float32 { if b.Ch == 1 { return float32(calc.RMS(b.Buf)) } return float32(calc.RMSOffset[float32](b.Buf, channel, b.Ch)) //return PeakRMS(b.Buf, channel, b.Ch) } func (b *Float32Buffer) Mean(channel int) float32 { //return Mean(b.Buf, channel, b.Ch) if b.Ch == 1 { return float32(calc.Mean(b.Buf)) } return float32(calc.MeanOffset[float32](b.Buf, channel, b.Ch)) } const float32EqualityThreshold = 1e-6 func almostEqualF32(a, b float32) bool { return abs(a-b) <= float32EqualityThreshold } var ( _ Buffer = (*Int8Buffer)(nil) _ Buffer = (*Int16Buffer)(nil) _ Buffer = (*Int32Buffer)(nil) _ Buffer = (*Float32Buffer)(nil) )