DataHoarder
6e490998d2
All checks were successful
continuous-integration/drone/push Build is passing
440 lines
7.8 KiB
Go
440 lines
7.8 KiB
Go
// Copyright 2015-2016 Cocoon Labs Ltd.
|
|
//
|
|
// See LICENSE file for terms and conditions.
|
|
|
|
package libflac
|
|
|
|
import (
|
|
"io"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/cocoonlife/testify/assert"
|
|
)
|
|
|
|
func TestDecode(t *testing.T) {
|
|
a := assert.New(t)
|
|
|
|
d, err := NewDecoder("testdata/nonexistent.flac")
|
|
a.Equal(d, (*Decoder)(nil), "decoder is nil")
|
|
a.NotNil(err, "err is not nil")
|
|
|
|
d, err = NewDecoder("testdata/sine24-00.flac")
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
a.Equal(d.Channels, 1, "channels is 1")
|
|
a.Equal(d.Depth, 24, "depth is 24")
|
|
a.Equal(d.Rate, 48000, "depth is 48000")
|
|
|
|
samples := 0
|
|
|
|
f, err := d.ReadFrame()
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
a.Equal(f.Channels, 1, "channels is 1")
|
|
a.Equal(f.Depth, 24, "depth is 24")
|
|
a.Equal(f.Rate, 48000, "depth is 48000")
|
|
|
|
samples = samples + len(f.Buffer)
|
|
|
|
for {
|
|
f, err := d.ReadFrame()
|
|
|
|
if err == nil || err == io.EOF {
|
|
if f != nil {
|
|
samples = samples + len(f.Buffer)
|
|
}
|
|
} else {
|
|
a.Equal(err, nil, "error reported")
|
|
break
|
|
}
|
|
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
}
|
|
|
|
a.Equal(samples, 200000, "all samples read")
|
|
d.Close()
|
|
}
|
|
|
|
func TestDecodeOgg(t *testing.T) {
|
|
a := assert.New(t)
|
|
|
|
d, err := NewDecoderOgg("testdata/nonexistent.ogg")
|
|
a.Equal(d, (*Decoder)(nil), "decoder is nil")
|
|
a.NotNil(err, "err is not nil")
|
|
|
|
d, err = NewDecoderOgg("testdata/sine24-00.ogg")
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
a.Equal(d.Channels, 1, "channels is 1")
|
|
a.Equal(d.Depth, 24, "depth is 24")
|
|
a.Equal(d.Rate, 48000, "depth is 48000")
|
|
|
|
samples := 0
|
|
|
|
f, err := d.ReadFrame()
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
a.Equal(f.Channels, 1, "channels is 1")
|
|
a.Equal(f.Depth, 24, "depth is 24")
|
|
a.Equal(f.Rate, 48000, "depth is 48000")
|
|
|
|
samples = samples + len(f.Buffer)
|
|
|
|
for {
|
|
f, err := d.ReadFrame()
|
|
|
|
if err == nil || err == io.EOF {
|
|
if f != nil {
|
|
samples = samples + len(f.Buffer)
|
|
}
|
|
} else {
|
|
a.Equal(err, nil, "error reported")
|
|
break
|
|
}
|
|
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
}
|
|
|
|
a.Equal(samples, 200000, "all samples read")
|
|
d.Close()
|
|
}
|
|
|
|
func TestDecodeReader(t *testing.T) {
|
|
a := assert.New(t)
|
|
|
|
reader, _ := os.Open("testdata/nonexistent.flac")
|
|
|
|
d, err := NewDecoderReader(reader)
|
|
|
|
a.Equal(d, (*Decoder)(nil), "decoder is nil")
|
|
a.Error(err)
|
|
|
|
reader, _ = os.Open("testdata/sine24-00.flac")
|
|
|
|
d, err = NewDecoderReader(reader)
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
a.Equal(d.Channels, 1, "channels is 1")
|
|
a.Equal(d.Depth, 24, "depth is 24")
|
|
a.Equal(d.Rate, 48000, "depth is 48000")
|
|
|
|
samples := 0
|
|
|
|
f, err := d.ReadFrame()
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
a.Equal(f.Channels, 1, "channels is 1")
|
|
a.Equal(f.Depth, 24, "depth is 24")
|
|
a.Equal(f.Rate, 48000, "depth is 48000")
|
|
|
|
samples = samples + len(f.Buffer)
|
|
|
|
for {
|
|
f, err := d.ReadFrame()
|
|
|
|
if err == nil || err == io.EOF {
|
|
if f != nil {
|
|
samples = samples + len(f.Buffer)
|
|
}
|
|
} else {
|
|
a.Equal(err, nil, "error reported")
|
|
break
|
|
}
|
|
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
}
|
|
|
|
a.Equal(samples, 200000, "all samples read")
|
|
d.Close()
|
|
}
|
|
|
|
func TestDecodeReaderOgg(t *testing.T) {
|
|
a := assert.New(t)
|
|
|
|
reader, _ := os.Open("testdata/nonexistent.ogg")
|
|
|
|
d, err := NewDecoderReaderOgg(reader)
|
|
|
|
a.Equal(d, (*Decoder)(nil), "decoder is nil")
|
|
a.Error(err)
|
|
|
|
reader, _ = os.Open("testdata/sine24-00.ogg")
|
|
|
|
d, err = NewDecoderReaderOgg(reader)
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
a.Equal(d.Channels, 1, "channels is 1")
|
|
a.Equal(d.Depth, 24, "depth is 24")
|
|
a.Equal(d.Rate, 48000, "depth is 48000")
|
|
|
|
samples := 0
|
|
|
|
f, err := d.ReadFrame()
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
a.Equal(f.Channels, 1, "channels is 1")
|
|
a.Equal(f.Depth, 24, "depth is 24")
|
|
a.Equal(f.Rate, 48000, "depth is 48000")
|
|
|
|
samples = samples + len(f.Buffer)
|
|
|
|
for {
|
|
f, err := d.ReadFrame()
|
|
|
|
if err == nil || err == io.EOF {
|
|
if f != nil {
|
|
samples = samples + len(f.Buffer)
|
|
}
|
|
} else {
|
|
a.Equal(err, nil, "error reported")
|
|
break
|
|
}
|
|
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
}
|
|
|
|
a.Equal(samples, 200000, "all samples read")
|
|
d.Close()
|
|
}
|
|
|
|
func TestEncode(t *testing.T) {
|
|
a := assert.New(t)
|
|
|
|
e, err := NewEncoder("not-existdir/foo.flac", 2, 24, 48000)
|
|
a.Equal(e, (*Encoder)(nil), "encoder is nil")
|
|
a.NotNil(err, "err is not nil")
|
|
|
|
fileName := "testdata/test.flac"
|
|
|
|
e, err = NewEncoder(fileName, 2, 24, 48000)
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
|
|
f := Frame{Channels: 1, Depth: 24, Rate: 48000}
|
|
|
|
err = e.WriteFrame(f)
|
|
|
|
a.Error(err, "channels mismatch")
|
|
|
|
f.Channels = 2
|
|
f.Buffer = make([]int32, 2*100)
|
|
|
|
err = e.WriteFrame(f)
|
|
|
|
a.Equal(err, nil, "frame encoded")
|
|
|
|
e.Close()
|
|
|
|
os.Remove(fileName)
|
|
}
|
|
|
|
func TestEncodeOgg(t *testing.T) {
|
|
a := assert.New(t)
|
|
|
|
e, err := NewEncoder("not-existdir/foo.ogg", 2, 24, 48000)
|
|
a.Equal(e, (*Encoder)(nil), "encoder is nil")
|
|
a.NotNil(err, "err is not nil")
|
|
|
|
fileName := "testdata/test.ogg"
|
|
|
|
e, err = NewEncoder(fileName, 2, 24, 48000)
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
|
|
f := Frame{Channels: 1, Depth: 24, Rate: 48000}
|
|
|
|
err = e.WriteFrame(f)
|
|
|
|
a.Error(err, "channels mismatch")
|
|
|
|
f.Channels = 2
|
|
f.Buffer = make([]int32, 2*100)
|
|
|
|
err = e.WriteFrame(f)
|
|
|
|
a.Equal(err, nil, "frame encoded")
|
|
|
|
e.Close()
|
|
|
|
os.Remove(fileName)
|
|
}
|
|
|
|
func TestRoundTrip(t *testing.T) {
|
|
a := assert.New(t)
|
|
|
|
inputFile := "testdata/sine24-00.flac"
|
|
outputFile := "testdata/test.flac"
|
|
|
|
d, err := NewDecoder(inputFile)
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
|
|
e, err := NewEncoder(outputFile, d.Channels, d.Depth, d.Rate)
|
|
|
|
samples := 0
|
|
|
|
for {
|
|
f, err := d.ReadFrame()
|
|
if err == nil || err == io.EOF {
|
|
if f != nil {
|
|
_ = e.WriteFrame(*f)
|
|
samples = samples + len(f.Buffer)
|
|
}
|
|
} else {
|
|
a.Equal(err, nil, "error reported")
|
|
break
|
|
}
|
|
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
}
|
|
|
|
a.Equal(samples, 200000, "all samples read")
|
|
d.Close()
|
|
e.Close()
|
|
|
|
os.Remove(outputFile)
|
|
}
|
|
|
|
func TestRoundTripStereo(t *testing.T) {
|
|
a := assert.New(t)
|
|
|
|
inputFile := "testdata/sine16-12.flac"
|
|
outputFile := "testdata/test.flac"
|
|
|
|
d, err := NewDecoder(inputFile)
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
|
|
e, err := NewEncoder(outputFile, d.Channels, d.Depth, d.Rate)
|
|
|
|
samples := 0
|
|
|
|
for {
|
|
f, err := d.ReadFrame()
|
|
if err == nil || err == io.EOF {
|
|
if f != nil {
|
|
_ = e.WriteFrame(*f)
|
|
samples = samples + len(f.Buffer)
|
|
}
|
|
} else {
|
|
a.Equal(err, nil, "error reported")
|
|
break
|
|
}
|
|
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
}
|
|
|
|
a.Equal(samples, 400000, "all samples read")
|
|
d.Close()
|
|
e.Close()
|
|
|
|
os.Remove(outputFile)
|
|
}
|
|
|
|
func TestRoundTripReaderWriter(t *testing.T) {
|
|
a := assert.New(t)
|
|
|
|
inputFile := "testdata/sine24-00.flac"
|
|
outputFile := "testdata/test.flac"
|
|
|
|
reader, _ := os.Open(inputFile)
|
|
|
|
d, err := NewDecoderReader(reader)
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
|
|
writer, _ := os.Create(outputFile)
|
|
|
|
e, err := NewEncoderWriter(writer, d.Channels, d.Depth, d.Rate, 8, true, 0)
|
|
|
|
samples := 0
|
|
|
|
for {
|
|
f, err := d.ReadFrame()
|
|
if err == nil || err == io.EOF {
|
|
if f != nil {
|
|
_ = e.WriteFrame(*f)
|
|
samples = samples + len(f.Buffer)
|
|
}
|
|
} else {
|
|
a.Equal(err, nil, "error reported")
|
|
break
|
|
}
|
|
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
}
|
|
|
|
a.Equal(samples, 200000, "all samples read")
|
|
d.Close()
|
|
e.Close()
|
|
|
|
os.Remove(outputFile)
|
|
}
|
|
|
|
func TestRoundTripReaderWriterSeeker(t *testing.T) {
|
|
a := assert.New(t)
|
|
|
|
inputFile := "testdata/sine24-00.flac"
|
|
outputFile := "testdata/test-seek.flac"
|
|
|
|
reader, _ := os.Open(inputFile)
|
|
|
|
d, err := NewDecoderReader(reader)
|
|
|
|
a.Equal(err, nil, "err is nil")
|
|
|
|
writer, _ := os.Create(outputFile)
|
|
|
|
e, err := NewEncoderWriteSeeker(writer, d.Channels, d.Depth, d.Rate, 8, false, 0)
|
|
|
|
samples := 0
|
|
|
|
for {
|
|
f, err := d.ReadFrame()
|
|
if err == nil || err == io.EOF {
|
|
if f != nil {
|
|
_ = e.WriteFrame(*f)
|
|
samples = samples + len(f.Buffer)
|
|
}
|
|
} else {
|
|
a.Equal(err, nil, "error reported")
|
|
break
|
|
}
|
|
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
}
|
|
|
|
a.Equal(samples, 200000, "all samples read")
|
|
d.Close()
|
|
e.Close()
|
|
|
|
os.Remove(outputFile)
|
|
}
|
|
|
|
func TestVersion(t *testing.T) {
|
|
|
|
t.Logf("version: %s", Version())
|
|
}
|
|
|
|
func TestVendor(t *testing.T) {
|
|
|
|
t.Logf("vendor: %s", Vendor())
|
|
}
|