move audio.System.Load/Save to audio.Load and audio.Save

Code serializing/deserializing audio should not depend on actual audio.System implementation.

Author: elgopher

audio/audio.go

@@ -7,7 +7,9 @@
 // Sound effects and music can be changed using functions: SetSfx and SetMusic.
 package audio
 
-import "fmt"
+import (
+	"fmt"
+)
 
 // Play starts playing sound effect with given sfxNo on specified channel.
 //
@@ -63,30 +65,6 @@ func GetStat() Stat {
 	return system.Stat()
 }
 
-// Save stores audio system state to byte slice. State is stored in binary form.
-// The format is described in Synthesizer.Save source code.
-func Save() ([]byte, error) {
-	return system.Save()
-}
-
-// Load restores audio system state from byte slice. State is restored from binary form.
-// The format is described in Synthesizer.Save source code.
-func Load(b []byte) error {
-	if err := system.Load(b); err != nil {
-		return err
-	}
-
-	for sfxNo := range Sfx {
-		Sfx[sfxNo] = system.GetSfx(sfxNo)
-	}
-
-	for patternNo := range Pat {
-		Pat[patternNo] = system.GetMusic(patternNo)
-	}
-
-	return nil
-}
-
 var system System = &Synthesizer{}
 
 type Stat struct {
@@ -288,6 +266,4 @@ type System interface {
 	// GetMusic returns music pattern with given number. patterNo is 0-63. Trying to get
 	// pattern number higher than 63 will result in returning empty Pattern (zero-value).
 	GetMusic(patterNo int) Pattern
-	Save() ([]byte, error)
-	Load([]byte) error
 }

audio/memory.go

@@ -3,6 +3,11 @@
 
 package audio
 
+import (
+	"bytes"
+	"fmt"
+)
+
 var (
 	Sfx [64]SoundEffect // Sound effects
 	Pat [64]Pattern     // Music patterns
@@ -18,3 +23,132 @@ func Sync() {
 		system.SetMusic(i, pattern)
 	}
 }
+
+// Save stores audio system state to byte slice. State is stored in binary form.
+func Save() ([]byte, error) {
+	buffer := bytes.NewBuffer(nil)
+
+	buffer.WriteByte(schemaVersion)
+
+	for i := 0; i <= maxSfxNo; i++ {
+		sfx := Sfx[i]
+		for _, note := range sfx.Notes {
+			buffer.WriteByte(byte(note.Pitch))
+			buffer.WriteByte(byte(note.Instrument))
+			buffer.WriteByte(byte(note.Volume))
+			buffer.WriteByte(byte(note.Effect))
+		}
+		buffer.WriteByte(sfx.Speed)
+		buffer.WriteByte(sfx.LoopStart)
+		buffer.WriteByte(sfx.LoopStop)
+		buffer.WriteByte(sfx.Detune)
+		buffer.WriteByte(sfx.Reverb)
+		buffer.WriteByte(sfx.Dampen)
+		buffer.WriteByte(boolToByte(sfx.Noiz))
+		buffer.WriteByte(boolToByte(sfx.Buzz))
+	}
+
+	for i := 0; i <= maxPatternNo; i++ {
+		pattern := Pat[i]
+		for _, sfx := range pattern.Sfx {
+			buffer.WriteByte(sfx.SfxNo)
+			buffer.WriteByte(boolToByte(sfx.Enabled))
+		}
+		buffer.WriteByte(boolToByte(pattern.BeginLoop))
+		buffer.WriteByte(boolToByte(pattern.EndLoop))
+		buffer.WriteByte(boolToByte(pattern.StopAtTheEnd))
+	}
+
+	return buffer.Bytes(), nil
+}
+
+func boolToByte(b bool) byte {
+	if b {
+		return 1
+	}
+
+	return 0
+}
+
+// Load restores audio system state from byte slice. State is restored from binary form.
+func Load(state []byte) error {
+	if len(state) == 0 {
+		return fmt.Errorf("state is empty")
+	}
+
+	version := state[0]
+	if schemaVersion != version {
+		return fmt.Errorf("state version %d is not supported. Only %d is supported.", version, schemaVersion)
+	}
+
+	const expectedStateLen = 9409
+	if len(state) != expectedStateLen {
+		return fmt.Errorf("invalid length of state. Must be %d.", expectedStateLen)
+	}
+
+	offset := 1
+
+	for sfxNo := 0; sfxNo <= maxSfxNo; sfxNo++ {
+		var sfx SoundEffect
+
+		for j, note := range sfx.Notes {
+			note.Pitch = Pitch(state[offset])
+			offset++
+			note.Instrument = Instrument(state[offset])
+			offset++
+			note.Volume = Volume(state[offset])
+			offset++
+			note.Effect = Effect(state[offset])
+			offset++
+
+			sfx.Notes[j] = note
+		}
+
+		sfx.Speed = state[offset]
+		offset++
+		sfx.LoopStart = state[offset]
+		offset++
+		sfx.LoopStop = state[offset]
+		offset++
+		sfx.Detune = state[offset]
+		offset++
+		sfx.Reverb = state[offset]
+		offset++
+		sfx.Dampen = state[offset]
+		offset++
+		sfx.Noiz = byteToBool(state[offset])
+		offset++
+		sfx.Buzz = byteToBool(state[offset])
+		offset++
+
+		Sfx[sfxNo] = sfx
+	}
+
+	for patterNo := 0; patterNo <= maxPatternNo; patterNo++ {
+		var pattern Pattern
+
+		for j, sfx := range pattern.Sfx {
+			sfx.SfxNo = state[offset]
+			offset++
+			sfx.Enabled = byteToBool(state[offset])
+			offset++
+
+			pattern.Sfx[j] = sfx
+		}
+
+		pattern.BeginLoop = byteToBool(state[offset])
+		offset++
+		pattern.EndLoop = byteToBool(state[offset])
+		offset++
+		pattern.StopAtTheEnd = byteToBool(state[offset])
+		offset++
+
+		Pat[patterNo] = pattern
+	}
+
+	return nil
+}
+
+func byteToBool(b byte) bool {
+	return b == 1
+}

audio/synth_bench_test.go renamed to audio/memory_bench_test.go

@@ -10,14 +10,12 @@ import (
 	"github.com/elgopher/pi/audio"
 )
 
-func BenchmarkSynthesizer_Load(b *testing.B) {
+func BenchmarkLoad(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 
-	s := audio.Synthesizer{}
-
 	for i := 0; i < b.N; i++ {
-		err := s.Load(validSave) // 11us
+		err := audio.Load(validSave) // 11us
 		if err != nil {
 			b.Logf("error returned from Synthesizer.Load: %s", err)
 			b.Fail()
@@ -29,15 +27,13 @@ func BenchmarkSynthesizer_Save(b *testing.B) {
 	b.ReportAllocs()
 	b.ResetTimer()
 
-	s := audio.Synthesizer{}
-
 	var (
 		bytes []byte
 		err   error
 	)
 
 	for i := 0; i < b.N; i++ {
-		bytes, err = s.Save() // 27us
+		bytes, err = audio.Save() // 27us
 		if err != nil {
 			b.Logf("error returned from Synthesizer.Save: %s", err)
 			b.Fail()

audio/memory_test.go

@@ -0,0 +1,49 @@
+// (c) 2022-2023 Jacek Olszak
+// This code is licensed under MIT license (see LICENSE for details)
+
+package audio_test
+
+import (
+	_ "embed"
+	"github.com/elgopher/pi/audio"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+//go:embed "internal/valid-save"
+var validSave []byte
+
+func TestSave(t *testing.T) {
+	t.Run("should save in binary format", func(t *testing.T) {
+		audio.Sfx[3] = validEffect
+		audio.Pat[4] = validPattern
+		bytes, err := audio.Save()
+		require.NoError(t, err)
+		assert.Equal(t, validSave, bytes)
+	})
+}
+
+func TestLoad(t *testing.T) {
+	t.Run("should load state", func(t *testing.T) {
+		err := audio.Load(validSave)
+		require.NoError(t, err)
+		assert.Equal(t, validEffect, audio.Sfx[3])
+		assert.Equal(t, validPattern, audio.Pat[4])
+	})
+
+	t.Run("should return error when state is empty", func(t *testing.T) {
+		err := audio.Load([]byte{})
+		assert.Error(t, err)
+	})
+
+	t.Run("should return error when version is not supported", func(t *testing.T) {
+		err := audio.Load([]byte{2})
+		assert.Error(t, err)
+	})
+
+	t.Run("should return error when state has invalid length", func(t *testing.T) {
+		err := audio.Load([]byte{1, 0, 0, 0})
+		assert.Error(t, err)
+	})
+}