go-ebur128/libebur128_test.go

package libebur128

import (
	"errors"
	"fmt"
	"io/ioutil"
	"os"
	"testing"
	"unsafe"
)

func TestFloat(t *testing.T) {
	t.Parallel()
	state := NewState(2, 44100, LoudnessGlobalMomentary|SamplePeak)
	if state == nil {
		t.Error(errors.New("could not create state"))
		return
	}
	defer state.Close()

	f, err := os.Open("sample/test_f32.raw")
	if err != nil {
		t.Error(err)
		return
	}

	data, err := ioutil.ReadAll(f)
	if err != nil {
		t.Error(err)
		return
	}

	const blockSize = 1024

	floatData := unsafe.Slice((*float32)(unsafe.Pointer(&data[0])), len(data)/4)
	for len(floatData) >= blockSize {
		if err = state.AddFloat(floatData[:blockSize]); err != nil {
			t.Error(err)
			return
		}
		floatData = floatData[blockSize:]
	}

	if len(floatData) > 0 {
		if err = state.AddFloat(floatData); err != nil {
			t.Error(err)
			return
		}
	}
	var loudness float64
	var peak []float64

	if loudness, err = state.GetLoudnessGlobal(); err != nil {
		t.Error(err)
		return
	}
	if peak, err = state.GetSamplePeak(); err != nil {
		t.Error(err)
		return
	}

	var maxPeak float64
	for _, p := range peak {
		if p > maxPeak {
			maxPeak = p
		}
	}

	result := fmt.Sprintf("%f dB, %f", loudness, maxPeak)
	expected := "-15.060377 dB, 0.666256"
	if result != expected {
		t.Errorf("expected %s, got %s", expected, result)
	}
}

func TestDouble(t *testing.T) {
	t.Parallel()
	state := NewState(2, 44100, LoudnessGlobalMomentary|SamplePeak)
	if state == nil {
		t.Error(errors.New("could not create state"))
		return
	}
	defer state.Close()

	f, err := os.Open("sample/test_f32.raw")
	if err != nil {
		t.Error(err)
		return
	}

	data, err := ioutil.ReadAll(f)
	if err != nil {
		t.Error(err)
		return
	}

	const blockSize = 1024

	floatData := unsafe.Slice((*float32)(unsafe.Pointer(&data[0])), len(data)/4)

	doubleData := make([]float64, len(floatData))
	for i := range floatData {
		doubleData[i] = float64(floatData[i])
	}

	for len(doubleData) >= blockSize {
		if err = state.AddDouble(doubleData[:blockSize]); err != nil {
			t.Error(err)
			return
		}
		doubleData = doubleData[blockSize:]
	}

	if len(doubleData) > 0 {
		if err = state.AddDouble(doubleData); err != nil {
			t.Error(err)
			return
		}
	}
	var loudness float64
	var peak []float64

	if loudness, err = state.GetLoudnessGlobal(); err != nil {
		t.Error(err)
		return
	}
	if peak, err = state.GetSamplePeak(); err != nil {
		t.Error(err)
		return
	}

	var maxPeak float64
	for _, p := range peak {
		if p > maxPeak {
			maxPeak = p
		}
	}

	result := fmt.Sprintf("%f dB, %f", loudness, maxPeak)
	expected := "-15.060377 dB, 0.666256"
	if result != expected {
		t.Errorf("expected %s, got %s", expected, result)
	}
}

func TestShort(t *testing.T) {
	t.Parallel()
	state := NewState(2, 44100, LoudnessGlobalMomentary|SamplePeak)
	if state == nil {
		t.Error(errors.New("could not create state"))
		return
	}
	defer state.Close()

	f, err := os.Open("sample/test_s16.raw")
	if err != nil {
		t.Error(err)
		return
	}

	data, err := ioutil.ReadAll(f)
	if err != nil {
		t.Error(err)
		return
	}

	const blockSize = 1024

	intData := unsafe.Slice((*int16)(unsafe.Pointer(&data[0])), len(data)/2)
	for len(intData) >= blockSize {
		if err = state.AddShort(intData[:blockSize]); err != nil {
			t.Error(err)
			return
		}
		intData = intData[blockSize:]
	}

	if len(intData) > 0 {
		if err = state.AddShort(intData); err != nil {
			t.Error(err)
			return
		}
	}
	var loudness float64
	var peak []float64

	if loudness, err = state.GetLoudnessGlobal(); err != nil {
		t.Error(err)
		return
	}
	if peak, err = state.GetSamplePeak(); err != nil {
		t.Error(err)
		return
	}

	var maxPeak float64
	for _, p := range peak {
		if p > maxPeak {
			maxPeak = p
		}
	}

	result := fmt.Sprintf("%f dB, %f", loudness, maxPeak)
	expected := "-15.060377 dB, 0.666260"
	if result != expected {
		t.Errorf("expected %s, got %s", expected, result)
	}
}

func TestInt(t *testing.T) {
	t.Parallel()
	state := NewState(2, 44100, LoudnessGlobalMomentary|SamplePeak)
	if state == nil {
		t.Error(errors.New("could not create state"))
		return
	}
	defer state.Close()

	f, err := os.Open("sample/test_s16.raw")
	if err != nil {
		t.Error(err)
		return
	}

	data, err := ioutil.ReadAll(f)
	if err != nil {
		t.Error(err)
		return
	}

	const blockSize = 1024

	shortData := unsafe.Slice((*int16)(unsafe.Pointer(&data[0])), len(data)/2)

	intData := make([]int32, len(shortData))
	for i := range shortData {
		intData[i] = int32(shortData[i]) << 16
	}

	for len(intData) >= blockSize {
		if err = state.AddInt(intData[:blockSize]); err != nil {
			t.Error(err)
			return
		}
		intData = intData[blockSize:]
	}

	if len(intData) > 0 {
		if err = state.AddInt(intData); err != nil {
			t.Error(err)
			return
		}
	}
	var loudness float64
	var peak []float64

	if loudness, err = state.GetLoudnessGlobal(); err != nil {
		t.Error(err)
		return
	}
	if peak, err = state.GetSamplePeak(); err != nil {
		t.Error(err)
		return
	}

	var maxPeak float64
	for _, p := range peak {
		if p > maxPeak {
			maxPeak = p
		}
	}

	result := fmt.Sprintf("%f dB, %f", loudness, maxPeak)
	expected := "-15.060377 dB, 0.666260"
	if result != expected {
		t.Errorf("expected %s, got %s", expected, result)
	}
}