nativeaudio

audio_test.go (8978B)

---

 package test
 
 import (
 	"bytes"
 	_ "embed"
 	"encoding/binary"
 	"fmt"
 	"runtime"
 	"slices"
 	"strings"
 	"testing"
 
 	"git.sr.ht/~jackmordaunt/nativeaudio"
 )
 
 var (
 	//go:embed compressed.m4a
 	compressed []byte
 	//go:embed uncompressed.s16le.pcm
 	uncompressed []byte
 	//go:embed uncompressed.s16le.macos.pcm
 	uncompressed_macos []byte
 	//go:embed corrupt.m4a
 	corrupt []byte
 )
 
 // getUncompressed returns the uncompressed result produced on the
 // current platform.
 func getUncompressed() []byte {
 	switch runtime.GOOS {
 	case "darwin":
 		return uncompressed_macos
 	default:
 		return uncompressed
 	}
 }
 
 // TestLoad ensures that output from the native decoders are close to
 // the output of ffmpeg.
 func TestLoad(t *testing.T) {
 	by, f, err := newDecoder(t).DecodeFile("compressed.m4a")
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	t.Logf("format: %+v", f)
 	// Check for known meta data values (ffprobe -i compressed.m4a).
 	if f.BytesPerSample != 2 {
 		t.Fatalf("unexpected bit depth: want 2, got %d", f.BytesPerSample)
 	}
 	if f.SampleRate != 44100 {
 		t.Fatalf("unexpected sample rate: want 44100, got %d", f.SampleRate)
 	}
 	if f.Channels != 2 {
 		t.Fatalf("unexpected channel count: want 2, got %d", f.Channels)
 	}
 	// Test passes on exact match, otherwise do a tolerance test.
 	if bytes.Equal(by, getUncompressed()) {
 		return
 	}
 	if !equal(t, by, getUncompressed(), f.Channels*f.BytesPerSample) {
 		t.Fatalf("native output does not match ffmpeg output")
 	}
 }
 
 // TestDecode ensures that output from the native decoders are similar to
 // the output of ffmpeg.
 func TestDecode(t *testing.T) {
 	by, f, err := newDecoder(t).Decode(compressed)
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	t.Logf("format: %+v", f)
 	// Check for known meta data values (ffprobe -i compressed.m4a).
 	if f.BytesPerSample != 2 {
 		t.Fatalf("unexpected bit depth: want 2, got %d", f.BytesPerSample)
 	}
 	if f.SampleRate != 44100 {
 		t.Fatalf("unexpected sample rate: want 44100, got %d", f.SampleRate)
 	}
 	if f.Channels != 2 {
 		t.Fatalf("unexpected channel count: want 2, got %d", f.Channels)
 	}
 	// Test passes on exact match, otherwise do a tolerance test.
 	if bytes.Equal(by, getUncompressed()) {
 		return
 	}
 	if !equal(t, by, getUncompressed(), f.Channels*f.BytesPerSample) {
 		t.Fatalf("native output does not match ffmpeg output")
 	}
 }
 
 // TestDecodeCorrupt ensures that we get an error value on invalid input and
 // that we don't crash the process.
 func TestDecodeCorrupt(t *testing.T) {
 	_, f, err := newDecoder(t).Decode(corrupt)
 	if err == nil {
 		t.Fatalf("expected error for corrupt audio data, got nil")
 	}
 	t.Logf("format: %+v", f)
 }
 
 // TestMemoryLeak runs the decode several times, forces a GC and verifies
 // that no data is left over from this package.
 func TestMemoryLeak(t *testing.T) {
 	runtime.MemProfileRate = 1
 
 	// Scoped so the Decoder itself is unreachable before the profile is
 	// taken. Holding it live would show up here as an allocation that
 	// was never freed, which is exactly what this test looks for.
 	func() {
 		d, err := nativeaudio.New()
 		if err != nil {
 			t.Fatalf("creating decoder: %v", err)
 		}
 		defer d.Close()
 		for ii := 0; ii < 10; ii++ {
 			by, f, err := d.DecodeFile("compressed.m4a")
 			if err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
 			_ = by
 			_ = f
 		}
 	}()
 
 	runtime.GC()
 	runtime.GC()
 
 	var profiles []runtime.MemProfileRecord
 
 	for {
 		n, ok := runtime.MemProfile(profiles, false)
 		if ok {
 			profiles = profiles[:n]
 			break
 		}
 		profiles = slices.Grow(profiles, n)[:n]
 	}
 
 	for _, p := range profiles {
 		f := runtime.FuncForPC(p.Stack0[0])
 
 		if !strings.Contains(f.Name(), "nativeaudio") {
 			continue
 		}
 
 		t.Errorf("un-freed data: %s -> %d\n", f.Name(), p.InUseBytes())
 	}
 }
 
 // equal decodes the PCM samples and tests if they are "close enough"
 // using a heuristic tolerance.
 //
 // Silence at either end is trimmed first. How much padding surrounds the
 // audio is not a property of the audio: AAC carries encoder delay, and
 // how many priming and trailing frames survive the round trip differs
 // between decoder implementations and between ffmpeg releases. The
 // reference here was generated by one ffmpeg; a later one decodes the
 // same file to 767 fewer trailing frames of silence, and the audio
 // between the silent ends is unchanged. Comparing raw lengths turns that
 // into a failure and dates the fixture to whichever ffmpeg produced it.
 //
 // After trimming the two must agree on length exactly. Sample values are
 // compared as signed integers by mean absolute difference, which must
 // stay under one quantisation step (1 LSB). Different AAC decoders
 // legitimately differ by rounding, so bit-exact output is not expected.
 //
 // Trimming cannot hide a bad decode. Only frames that are entirely zero
 // are removed, so lost audio still reaches the comparison, and any
 // misalignment introduced would put the mean far above 1 rather than
 // passing quietly.
 func equal(t *testing.T, left, right []byte, align int) bool {
 	if len(left) == 0 || len(right) == 0 {
 		return false
 	}
 	left, right = trimSilence(left, align), trimSilence(right, align)
 	if len(left) == 0 && len(right) == 0 {
 		// Both sides decoded to nothing but silence, which is agreement.
 		return true
 	}
 	if len(left) != len(right) {
 		t.Logf("length mismatch after trimming silence: native %d bytes, reference %d bytes", len(left), len(right))
 		return false
 	}
 	var (
 		lsamples = make([]int16, len(left)/2)
 		rsamples = make([]int16, len(right)/2)
 	)
 	if err := binary.Read(bytes.NewReader(left), binary.LittleEndian, lsamples); err != nil {
 		panic(fmt.Errorf("left: binary read: %w", err))
 	}
 	if err := binary.Read(bytes.NewReader(right), binary.LittleEndian, rsamples); err != nil {
 		panic(fmt.Errorf("right: binary read: %w", err))
 	}
 	var (
 		size int = min(len(lsamples), len(rsamples))
 		sum  int = 0
 	)
 	for ii := 0; ii < size; ii++ {
 		var (
 			lsample = int(lsamples[ii])
 			rsample = int(rsamples[ii])
 		)
 		sum += abs(lsample - rsample)
 	}
 	mean := float64(sum) / float64(size)
 	t.Logf("mean: %f, sum: %d, size: %d\n", mean, sum, size)
 	return mean < 1.0
 }
 
 // TestEqual guards the comparison itself. Trimming silence is what lets
 // the reference PCM outlive the ffmpeg that produced it, and the failure
 // mode of getting it wrong is a comparison that passes for good, so the
 // cases it must still reject are worth pinning down.
 func TestEqual(t *testing.T) {
 	reference := getUncompressed()
 	const align = 4 // the fixture is 16-bit stereo.
 
 	reject := func(name string, mutate func([]byte) []byte) {
 		t.Run(name, func(t *testing.T) {
 			if equal(t, mutate(append([]byte(nil), reference...)), reference, align) {
 				t.Errorf("expected the comparison to reject %s", name)
 			}
 		})
 	}
 
 	// Every sample louder by one step, which is the tolerance exactly.
 	reject("amplitude", func(b []byte) []byte {
 		for i := 0; i+1 < len(b); i += 2 {
 			v := int16(uint16(b[i]) | uint16(b[i+1])<<8)
 			if v < 32767 {
 				v++
 			}
 			b[i], b[i+1] = byte(v), byte(uint16(v)>>8)
 		}
 		return b
 	})
 
 	// Audio dropped from the middle, where no amount of trimming helps.
 	reject("truncated", func(b []byte) []byte {
 		mid := len(b) / 2
 		return append(b[:mid], b[mid+1000*align:]...)
 	})
 
 	// Shifted by a frame, so the channels land on each other.
 	reject("shifted", func(b []byte) []byte {
 		lead := 0
 		for lead+align <= len(b) && isZero(b[lead:lead+align]) {
 			lead += align
 		}
 		return append(b[:lead:lead], b[lead+align:]...)
 	})
 
 	t.Run("identity", func(t *testing.T) {
 		if !equal(t, append([]byte(nil), reference...), reference, align) {
 			t.Errorf("expected the comparison to accept identical input")
 		}
 	})
 }
 
 // trimSilence removes whole silent frames from both ends of the PCM.
 //
 // A frame at a time, rather than a byte at a time: the low byte of a
 // sample is zero whenever its value is a multiple of 256, so trimming
 // individual zero bytes would leave the buffer straddling a frame
 // boundary and compare the left channel against the right.
 func trimSilence(b []byte, align int) []byte {
 	if align <= 0 {
 		return b
 	}
 	for len(b) >= align && isZero(b[:align]) {
 		b = b[align:]
 	}
 	for len(b) >= align && isZero(b[len(b)-align:]) {
 		b = b[:len(b)-align]
 	}
 	return b
 }
 
 func isZero(b []byte) bool {
 	for _, c := range b {
 		if c != 0 {
 			return false
 		}
 	}
 	return true
 }
 
 func abs(n int) int {
 	if n < 0 {
 		return -n
 	}
 	return n
 }
 
 func BenchmarkDecode(b *testing.B) {
 	b.Run("native-decode", func(b *testing.B) {
 		d := newDecoder(b)
 		b.ResetTimer()
 		for ii := 0; ii < b.N; ii++ {
 			by, f, err := d.Decode(compressed)
 			if err != nil {
 				b.Fatalf("unexpected error during decode: %v", err)
 			}
 			_ = by
 			_ = f
 		}
 	})
 	b.Run("ffmpeg-decode", func(b *testing.B) {
 		for ii := 0; ii < b.N; ii++ {
 			by, f, err := nativeaudio.FFmpegDecode(compressed)
 			if err != nil {
 				b.Fatalf("unexpected error during decode: %v", err)
 			}
 			_ = by
 			_ = f
 		}
 	})
 }