Checkpoint
This commit is contained in:
54 files changed
+6855
-526
No files matched your search
+263
-42
@@ -2,55 +2,276 @@ package audio
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"io"
|
||||
"math"
|
||||
|
||||
"go.maze.io/harmon/internal/calc"
|
||||
)
|
||||
|
||||
type Buffer struct {
|
||||
Buf []byte
|
||||
// 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
|
||||
Format Format
|
||||
floats *Float32Buffer
|
||||
}
|
||||
|
||||
// NewBuffer returns a buffer of n samples and ch channels.
|
||||
func NewBuffer(n, ch int, f Format) *Buffer {
|
||||
if ch < 1 {
|
||||
ch = 1
|
||||
}
|
||||
return &Buffer{
|
||||
Buf: make([]byte, n*ch*f.BytesPerSample()),
|
||||
Ch: ch,
|
||||
Format: f,
|
||||
func NewInt8Buffer(size, channels int) *Int8Buffer {
|
||||
samples := size * channels
|
||||
return &Int8Buffer{
|
||||
Buf: make([]int8, samples),
|
||||
Ch: channels,
|
||||
floats: NewFloat32Buffer(size, channels, nil),
|
||||
}
|
||||
}
|
||||
|
||||
func (b *Buffer) Decode(data any, order binary.ByteOrder) (n int, err error) {
|
||||
switch data := data.(type) {
|
||||
case []int8:
|
||||
var x byte
|
||||
for n, x = range b.Buf {
|
||||
data[n] = int8(x)
|
||||
}
|
||||
case []uint8:
|
||||
n = copy(data, b.Buf)
|
||||
case []int16:
|
||||
for n = range data {
|
||||
data[n] = int16(order.Uint16(b.Buf[n<<1:]))
|
||||
}
|
||||
case []int32:
|
||||
for n = range data {
|
||||
data[n] = int32(order.Uint32(b.Buf[n<<2:]))
|
||||
}
|
||||
case []float32:
|
||||
for n = range data {
|
||||
data[n] = math.Float32frombits(order.Uint32(b.Buf[n<<2:]))
|
||||
}
|
||||
case []float64:
|
||||
for n = range data {
|
||||
data[n] = math.Float64frombits(order.Uint64(b.Buf[n<<3:]))
|
||||
}
|
||||
default:
|
||||
return 0, fmt.Errorf("can't decode to %T", data)
|
||||
}
|
||||
return
|
||||
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)
|
||||
)
|
||||
+105
-4
@@ -3,6 +3,9 @@ package audio
|
||||
import (
|
||||
"encoding/binary"
|
||||
"errors"
|
||||
"math"
|
||||
|
||||
"go.maze.io/harmon/internal/calc"
|
||||
)
|
||||
|
||||
var ErrFormat = errors.New("invalid audio format")
|
||||
@@ -17,17 +20,19 @@ const (
|
||||
Int16BEFormat
|
||||
Int32LEFormat
|
||||
Int32BEFormat
|
||||
Float32LEFormat
|
||||
Float32BEFormat
|
||||
invalidFormat
|
||||
)
|
||||
|
||||
func (f Format) Order() binary.ByteOrder {
|
||||
switch f {
|
||||
case Int16LEFormat, Int32LEFormat:
|
||||
case Int16LEFormat, Int32LEFormat, Float32LEFormat:
|
||||
return binary.LittleEndian
|
||||
case Int16BEFormat, Int32BEFormat:
|
||||
case Int16BEFormat, Int32BEFormat, Float32BEFormat:
|
||||
return binary.BigEndian
|
||||
default:
|
||||
return binary.NativeEndian
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
@@ -37,9 +42,105 @@ func (f Format) BytesPerSample() int {
|
||||
return 8
|
||||
case Int16LEFormat, Int16BEFormat:
|
||||
return 16
|
||||
case Int32LEFormat, Int32BEFormat:
|
||||
case Int32LEFormat, Int32BEFormat, Float32LEFormat, Float32BEFormat:
|
||||
return 32
|
||||
default:
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
func (f Format) NewBuffer(size, channels int) Buffer {
|
||||
switch f {
|
||||
case Int8Format:
|
||||
return NewInt8Buffer(size, channels)
|
||||
case Int16LEFormat, Int16BEFormat:
|
||||
return NewInt16Buffer(size, channels, f.Order())
|
||||
case Int32LEFormat, Int32BEFormat:
|
||||
return NewInt32Buffer(size, channels, f.Order())
|
||||
case Float32LEFormat, Float32BEFormat:
|
||||
return NewFloat32Buffer(size, channels, f.Order())
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
func Min(samples []float32) (min float32) {
|
||||
if len(samples) == 0 {
|
||||
return 0
|
||||
}
|
||||
|
||||
min = math.MaxFloat32
|
||||
for _, sample := range samples {
|
||||
if sample < min {
|
||||
min = sample
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func abs(v float32) float32 {
|
||||
if v < 0 {
|
||||
return -v
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
func Max(samples []float32) (max float32) {
|
||||
if len(samples) == 0 {
|
||||
return 0
|
||||
}
|
||||
|
||||
max = -math.MaxFloat32
|
||||
for _, sample := range samples {
|
||||
if sample > max {
|
||||
max = sample
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func Abs(samples []float32) {
|
||||
if len(samples) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
for i, sample := range samples {
|
||||
samples[i] = abs(sample)
|
||||
}
|
||||
}
|
||||
|
||||
func Normalize(samples []float32) {
|
||||
if len(samples) == 0 {
|
||||
return
|
||||
}
|
||||
|
||||
var max float32
|
||||
for _, sample := range samples {
|
||||
if abs := abs(sample); abs > max {
|
||||
max = abs
|
||||
}
|
||||
}
|
||||
|
||||
if max != 0 {
|
||||
for i := range samples {
|
||||
samples[i] /= max
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func Clamp(sample float32) float32 {
|
||||
if sample < -1 {
|
||||
return -1
|
||||
}
|
||||
if sample > +1 {
|
||||
return +1
|
||||
}
|
||||
return sample
|
||||
}
|
||||
|
||||
func RMS(samples []float32, channel, channels int) float64 {
|
||||
if channels == 1 {
|
||||
return calc.RMS(samples)
|
||||
}
|
||||
return calc.RMSOffset(samples, channel, channels)
|
||||
}
|
||||
+147
-32
@@ -5,6 +5,7 @@ import (
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"time"
|
||||
|
||||
"github.com/sirupsen/logrus"
|
||||
"go.maze.io/harmon/config"
|
||||
@@ -12,6 +13,8 @@ import (
|
||||
"periph.io/x/conn/v3/physic"
|
||||
)
|
||||
|
||||
const streamBuffers = 16
|
||||
|
||||
type Stream interface {
|
||||
hardware.Driver
|
||||
|
||||
@@ -22,9 +25,115 @@ type Stream interface {
|
||||
SampleRate() physic.Frequency
|
||||
|
||||
// Samples is a channel of interleaved audio samples.
|
||||
Samples() <-chan []int16
|
||||
Samples(size int) <-chan Buffer
|
||||
}
|
||||
|
||||
type Processor interface {
|
||||
Process(Buffer)
|
||||
}
|
||||
|
||||
type StreamReader struct {
|
||||
Opener func() (io.Reader, error)
|
||||
|
||||
// Format is the audio sample format.
|
||||
Format Format
|
||||
|
||||
// Ch is the number of channels.
|
||||
Ch int
|
||||
|
||||
// Rate is the sampling rate.
|
||||
Rate physic.Frequency
|
||||
|
||||
// quit signal channel.
|
||||
quit chan struct{}
|
||||
}
|
||||
|
||||
func NewStreamReader(open func() (io.Reader, error), f Format, ch int, rate physic.Frequency) Stream {
|
||||
return &StreamReader{
|
||||
Opener: open,
|
||||
Format: f,
|
||||
Ch: ch,
|
||||
Rate: rate,
|
||||
quit: make(chan struct{}),
|
||||
}
|
||||
}
|
||||
|
||||
func (r *StreamReader) Halt() error {
|
||||
if r.quit != nil {
|
||||
close(r.quit)
|
||||
r.quit = nil
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *StreamReader) Type() string {
|
||||
return "stream"
|
||||
}
|
||||
|
||||
func (r *StreamReader) Channels() int {
|
||||
return r.Ch
|
||||
}
|
||||
|
||||
func (r *StreamReader) SampleRate() physic.Frequency {
|
||||
return r.Rate
|
||||
}
|
||||
|
||||
func (r *StreamReader) Samples(size int) <-chan Buffer {
|
||||
samples := make(chan Buffer, streamBuffers)
|
||||
go r.stream(samples, size)
|
||||
return samples
|
||||
}
|
||||
|
||||
func (r *StreamReader) stream(samples chan<- Buffer, size int) {
|
||||
defer close(samples)
|
||||
|
||||
var (
|
||||
log = logrus.WithField("audio", "stream")
|
||||
ring [streamBuffers]Buffer
|
||||
curr int
|
||||
)
|
||||
for i := 0; i < streamBuffers; i++ {
|
||||
ring[i] = r.Format.NewBuffer(size*r.Ch, r.Ch)
|
||||
}
|
||||
|
||||
log.Debug("starting with %d buffers", streamBuffers)
|
||||
for {
|
||||
log.Debug("opening stream")
|
||||
f, err := r.Opener()
|
||||
if err != nil {
|
||||
log.WithError(err).Warn("opening stream failed, retrying...")
|
||||
time.Sleep(time.Second)
|
||||
continue
|
||||
}
|
||||
|
||||
for {
|
||||
n, err := ring[curr].ReadFrom(f)
|
||||
if err != nil {
|
||||
log.WithError(err).Warn("stream closed, retrying...")
|
||||
break
|
||||
}
|
||||
|
||||
log.WithField("samples", n).Trace("stream samples")
|
||||
select {
|
||||
case <-r.quit:
|
||||
if c, ok := f.(io.Closer); ok {
|
||||
if err = c.Close(); err != nil {
|
||||
log.WithError(err).Warn("closing stream failed")
|
||||
}
|
||||
}
|
||||
return
|
||||
case samples <- ring[curr]:
|
||||
default:
|
||||
log.Warn("dropped samples, buffer overrun")
|
||||
}
|
||||
|
||||
curr = (curr + 1) % streamBuffers
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
type Reader struct {
|
||||
io.Reader
|
||||
|
||||
@@ -66,60 +175,66 @@ func (r Reader) SampleRate() physic.Frequency {
|
||||
return r.Rate
|
||||
}
|
||||
|
||||
func (r *Reader) Read(b *Buffer) (n int, err error) {
|
||||
if b == nil {
|
||||
return
|
||||
}
|
||||
|
||||
l := len(b.Buf)
|
||||
l -= l % (b.Ch * b.Format.BytesPerSample()) // align to samples
|
||||
n, err = r.Reader.Read(b.Buf[:l]) // read
|
||||
n /= (b.Ch * b.Format.BytesPerSample()) // return sample count
|
||||
return
|
||||
func (r *Reader) Read(b Buffer) (n int, err error) {
|
||||
return b.ReadFrom(r.Reader)
|
||||
}
|
||||
|
||||
func (r *Reader) read(send chan []int16) {
|
||||
const numBuf = 16
|
||||
const numBuf = 16
|
||||
|
||||
func (r *Reader) stream(send chan Buffer, rate physic.Frequency) {
|
||||
var (
|
||||
b = NewBuffer(int(r.Rate/physic.Hertz), r.Ch, r.Format)
|
||||
order = r.Format.Order()
|
||||
buf [numBuf][]int16
|
||||
n int
|
||||
b = r.Format.NewBuffer(int(rate/physic.Hertz), r.Ch) //NewBuffer(int(rate/physic.Hertz), r.Ch, r.Format)
|
||||
buf [numBuf]Buffer
|
||||
n int
|
||||
)
|
||||
for i := range buf {
|
||||
buf[i] = make([]int16, int(r.Rate/physic.Hertz)*r.Ch)
|
||||
}
|
||||
|
||||
logrus.WithFields(logrus.Fields{
|
||||
"buffers": numBuf,
|
||||
"rate_in": r.Rate,
|
||||
"rate_out": rate,
|
||||
}).Info("audio stream starting")
|
||||
for {
|
||||
if _, err := r.Read(b); err != nil {
|
||||
logrus.WithError(err).Warn("audio stream interrupted")
|
||||
close(send)
|
||||
return
|
||||
}
|
||||
|
||||
samples, _ := b.Decode(buf[n], order)
|
||||
//samples, err := b.Decode(buf[n], order)
|
||||
samples, err := b.ReadFrom(r.Reader)
|
||||
if err != nil {
|
||||
logrus.WithError(err).Warn("samples decode failed")
|
||||
continue
|
||||
}
|
||||
select {
|
||||
case send <- buf[n][:samples]:
|
||||
case send <- buf[n]:
|
||||
default:
|
||||
logrus.WithField("samples", samples).Warn("samples dropped, buffer overrun")
|
||||
}
|
||||
|
||||
n = (n + 1) % numBuf
|
||||
}
|
||||
}
|
||||
|
||||
func (r *Reader) Samples() <-chan []int16 {
|
||||
samples := make(chan []int16)
|
||||
go r.read(samples)
|
||||
func (r *Reader) Samples(rate physic.Frequency) <-chan Buffer {
|
||||
samples := make(chan Buffer, numBuf)
|
||||
go r.stream(samples, rate)
|
||||
return samples
|
||||
}
|
||||
*/
|
||||
|
||||
// Open a stream backed by a file (or a FIFO).
|
||||
func Open(name string, f Format, ch int, rate physic.Frequency) (Stream, error) {
|
||||
r, err := os.OpenFile(name, os.O_RDONLY, 0)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return NewReader(r, f, ch, rate), nil
|
||||
func Open(name string, f Format, ch int, rate physic.Frequency) Stream {
|
||||
/*
|
||||
r, err := os.OpenFile(name, os.O_RDONLY, 0)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return NewReader(r, f, ch, rate), nil
|
||||
*/
|
||||
return NewStreamReader(func() (io.Reader, error) {
|
||||
return os.OpenFile(name, os.O_RDONLY, 0)
|
||||
}, f, ch, rate)
|
||||
}
|
||||
|
||||
func openFile(config config.Audio) (Stream, error) {
|
||||
@@ -154,7 +269,7 @@ func openFile(config config.Audio) (Stream, error) {
|
||||
"channels": config.Channels,
|
||||
"rate": rate,
|
||||
}).Debug("open audio driver")
|
||||
return Open(config.Path, f, config.Channels, rate)
|
||||
return Open(config.Path, f, config.Channels, rate), nil
|
||||
}
|
||||
|
||||
func init() {
|
||||
|
||||
Reference in new issue
Block a user