278 lines
5.2 KiB
Go
278 lines
5.2 KiB
Go
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)
|
|
)
|