mirror of https://bitbucket.org/ausocean/av.git
147 lines
3.2 KiB
Go
147 lines
3.2 KiB
Go
/*
|
|
NAME
|
|
audio_test.go
|
|
|
|
AUTHOR
|
|
Trek Hopton <trek@ausocean.org>
|
|
|
|
LICENSE
|
|
This file is Copyright (C) 2019 the Australian Ocean Lab (AusOcean)
|
|
|
|
It is free software: you can redistribute it and/or modify them
|
|
under the terms of the GNU General Public License as published by the
|
|
Free Software Foundation, either version 3 of the License, or (at your
|
|
option) any later version.
|
|
|
|
It is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License in gpl.txt.
|
|
If not, see [GNU licenses](http://www.gnu.org/licenses).
|
|
*/
|
|
|
|
package audio
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"bitbucket.org/ausocean/av/codec/codecutil"
|
|
"bitbucket.org/ausocean/utils/logger"
|
|
"github.com/yobert/alsa"
|
|
)
|
|
|
|
// Check that a device exists with the given config parameters.
|
|
func checkDevice(ac *Config) error {
|
|
cards, err := alsa.OpenCards()
|
|
if err != nil {
|
|
return errors.New("no audio cards found")
|
|
}
|
|
defer alsa.CloseCards(cards)
|
|
var testDev *alsa.Device
|
|
for _, card := range cards {
|
|
devices, err := card.Devices()
|
|
if err != nil {
|
|
continue
|
|
}
|
|
for _, dev := range devices {
|
|
if dev.Type != alsa.PCM || !dev.Record {
|
|
continue
|
|
}
|
|
testDev = dev
|
|
break
|
|
}
|
|
}
|
|
if testDev == nil {
|
|
return errors.New("no suitable device found")
|
|
}
|
|
err = testDev.Open()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = testDev.NegotiateChannels(2)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
foundRate := false
|
|
for i := 0; i < len(Rates) && !foundRate; i++ {
|
|
if Rates[i] < ac.SampleRate {
|
|
continue
|
|
}
|
|
if Rates[i]%ac.SampleRate == 0 {
|
|
_, err = testDev.NegotiateRate(Rates[i])
|
|
if err == nil {
|
|
foundRate = true
|
|
}
|
|
}
|
|
}
|
|
if !foundRate {
|
|
_, err = testDev.NegotiateRate(defaultSampleRate)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
var aFmt alsa.FormatType
|
|
switch ac.BitDepth {
|
|
case 16:
|
|
aFmt = alsa.S16_LE
|
|
case 32:
|
|
aFmt = alsa.S32_LE
|
|
default:
|
|
return errors.New("unsupported bitdepth")
|
|
}
|
|
_, err = testDev.NegotiateFormat(aFmt)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = testDev.NegotiateBufferSize(8192, 16384)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err = testDev.Prepare(); err != nil {
|
|
return err
|
|
}
|
|
if testDev != nil {
|
|
testDev.Close()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func TestDevice(t *testing.T) {
|
|
// We want to open a device with a standard configuration.
|
|
ac := &Config{
|
|
SampleRate: 8000,
|
|
Channels: 1,
|
|
RecPeriod: 0.3,
|
|
BitDepth: 16,
|
|
Codec: codecutil.ADPCM,
|
|
}
|
|
n := 2 // Number of periods to wait while recording.
|
|
|
|
// Skip if there are no suitable devices to test with.
|
|
err := checkDevice(ac)
|
|
if err != nil {
|
|
t.Skip(err)
|
|
}
|
|
|
|
// Create a new audio Device, start, read/lex, and then stop it.
|
|
l := logger.New(logger.Debug, os.Stderr)
|
|
ai, err := NewDevice(ac, l)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
dst := bytes.NewBuffer(make([]byte, 0))
|
|
err = ai.Start()
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
go codecutil.LexBytes(dst, ai, time.Duration(ac.RecPeriod*float64(time.Second)), ai.ChunkSize())
|
|
time.Sleep(time.Duration(ac.RecPeriod*float64(time.Second)) * time.Duration(n))
|
|
ai.Stop()
|
|
}
|