refactor(go): Move everything from go4k to root package sointu

bridge/asmformat_test.go

@@ -0,0 +1,134 @@
+package bridge_test
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io/ioutil"
+	"log"
+	"math"
+	"os"
+	"path"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/vsariola/sointu"
+	"github.com/vsariola/sointu/bridge"
+	"gopkg.in/yaml.v2"
+)
+
+func TestAllAsmFiles(t *testing.T) {
+	_, myname, _, _ := runtime.Caller(0)
+	files, err := filepath.Glob(path.Join(path.Dir(myname), "..", "tests", "*.yml"))
+	if err != nil {
+		t.Fatalf("cannot glob files in the test directory: %v", err)
+	}
+	for _, filename := range files {
+		basename := filepath.Base(filename)
+		testname := strings.TrimSuffix(basename, path.Ext(basename))
+		t.Run(testname, func(t *testing.T) {
+			if runtime.GOOS != "windows" && strings.Contains(testname, "sample") {
+				t.Skip("Samples (gm.dls) available only on Windows")
+				return
+			}
+			asmcode, err := ioutil.ReadFile(filename)
+			if err != nil {
+				t.Fatalf("cannot read the .asm file: %v", filename)
+			}
+			var song sointu.Song
+			err = yaml.Unmarshal(asmcode, &song)
+			if err != nil {
+				t.Fatalf("could not parse the .yml file: %v", err)
+			}
+			synth, err := bridge.Synth(song.Patch)
+			if err != nil {
+				t.Fatalf("Compiling patch failed: %v", err)
+			}
+			buffer, err := sointu.Play(synth, song)
+			buffer = buffer[:song.TotalRows()*song.SamplesPerRow()*2] // extend to the nominal length always.
+			if err != nil {
+				t.Fatalf("Play failed: %v", err)
+			}
+			if os.Getenv("SOINTU_TEST_SAVE_OUTPUT") == "YES" {
+				outputpath := path.Join(path.Dir(myname), "actual_output")
+				if _, err := os.Stat(outputpath); os.IsNotExist(err) {
+					os.Mkdir(outputpath, 0755)
+				}
+				outFileName := path.Join(path.Dir(myname), "actual_output", testname+".raw")
+				outfile, err := os.OpenFile(outFileName, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
+				defer outfile.Close()
+				if err != nil {
+					t.Fatalf("Creating file failed: %v", err)
+				}
+				var createdbuf bytes.Buffer
+				err = binary.Write(&createdbuf, binary.LittleEndian, buffer)
+				if err != nil {
+					t.Fatalf("error converting buffer: %v", err)
+				}
+				_, err = outfile.Write(createdbuf.Bytes())
+				if err != nil {
+					log.Fatal(err)
+				}
+			}
+			if song.Output16Bit {
+				int16Buffer := convertToInt16Buffer(buffer)
+				compareToRawInt16(t, int16Buffer, testname+".raw")
+			} else {
+				compareToRawFloat32(t, buffer, testname+".raw")
+			}
+		})
+	}
+}
+
+func compareToRawFloat32(t *testing.T, buffer []float32, rawname string) {
+	_, filename, _, _ := runtime.Caller(0)
+	expectedb, err := ioutil.ReadFile(path.Join(path.Dir(filename), "..", "tests", "expected_output", rawname))
+	if err != nil {
+		t.Fatalf("cannot read expected: %v", err)
+	}
+	expected := make([]float32, len(expectedb)/4)
+	buf := bytes.NewReader(expectedb)
+	err = binary.Read(buf, binary.LittleEndian, &expected)
+	if err != nil {
+		t.Fatalf("error converting expected buffer: %v", err)
+	}
+	if len(expected) != len(buffer) {
+		t.Fatalf("buffer length mismatch, got %v, expected %v", len(buffer), len(expected))
+	}
+	for i, v := range expected {
+		if math.IsNaN(float64(buffer[i])) || math.Abs(float64(v-buffer[i])) > 1e-6 {
+			t.Fatalf("error bigger than 1e-6 detected, at sample position %v", i)
+		}
+	}
+}
+
+func compareToRawInt16(t *testing.T, buffer []int16, rawname string) {
+	_, filename, _, _ := runtime.Caller(0)
+	expectedb, err := ioutil.ReadFile(path.Join(path.Dir(filename), "..", "tests", "expected_output", rawname))
+	if err != nil {
+		t.Fatalf("cannot read expected: %v", err)
+	}
+	expected := make([]int16, len(expectedb)/2)
+	buf := bytes.NewReader(expectedb)
+	err = binary.Read(buf, binary.LittleEndian, &expected)
+	if err != nil {
+		t.Fatalf("error converting expected buffer: %v", err)
+	}
+	if len(expected) != len(buffer) {
+		t.Fatalf("buffer length mismatch, got %v, expected %v", len(buffer), len(expected))
+	}
+	for i, v := range expected {
+		if math.IsNaN(float64(buffer[i])) || v != buffer[i] {
+			t.Fatalf("error at sample position %v", i)
+		}
+	}
+}
+
+func convertToInt16Buffer(buffer []float32) []int16 {
+	int16Buffer := make([]int16, len(buffer))
+	for i, v := range buffer {
+		int16Buffer[i] = int16(math.Round(math.Min(math.Max(float64(v), -1.0), 1.0) * 32767))
+	}
+	return int16Buffer
+}

bridge/bridge.go

@@ -0,0 +1,111 @@
+package bridge
+
+// #cgo CFLAGS: -I"${SRCDIR}/../build/"
+// #cgo LDFLAGS: "${SRCDIR}/../build/libsointu.a"
+// #include <sointu.h>
+import "C"
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/vsariola/sointu"
+	"github.com/vsariola/sointu/compiler"
+)
+
+func Synth(patch sointu.Patch) (*C.Synth, error) {
+	s := new(C.Synth)
+	comPatch, err := compiler.Encode(&patch, compiler.AllFeatures{})
+	if err != nil {
+		return nil, fmt.Errorf("error compiling patch: %v", err)
+	}
+	if len(comPatch.Commands) > 2048 { // TODO: 2048 could probably be pulled automatically from cgo
+		return nil, errors.New("bridge supports at most 2048 commands; the compiled patch has more")
+	}
+	if len(comPatch.Values) > 16384 { // TODO: 16384 could probably be pulled automatically from cgo
+		return nil, errors.New("bridge supports at most 16384 values; the compiled patch has more")
+	}
+	for i, v := range comPatch.Commands {
+		s.Commands[i] = (C.uchar)(v)
+	}
+	for i, v := range comPatch.Values {
+		s.Values[i] = (C.uchar)(v)
+	}
+	for i, v := range comPatch.DelayTimes {
+		s.DelayTimes[i] = (C.ushort)(v)
+	}
+	for i, v := range comPatch.SampleOffsets {
+		s.SampleOffsets[i].Start = (C.uint)(v.Start)
+		s.SampleOffsets[i].LoopStart = (C.ushort)(v.LoopStart)
+		s.SampleOffsets[i].LoopLength = (C.ushort)(v.LoopLength)
+	}
+	s.NumVoices = C.uint(comPatch.NumVoices)
+	s.Polyphony = C.uint(comPatch.PolyphonyBitmask)
+	s.RandSeed = 1
+	return s, nil
+}
+
+// Render renders until the buffer is full or the modulated time is reached, whichever
+// happens first.
+// Parameters:
+//   buffer     float32 slice to fill with rendered samples. Stereo signal, so
+//              should have even length.
+//   maxtime    how long nominal time to render in samples. Speed unit might modulate time
+//              so the actual number of samples rendered depends on the modulation and if
+//              buffer is full before maxtime is reached.
+// Returns a tuple (int, int, error), consisting of:
+//   samples    number of samples rendered in the buffer
+//   time       how much the time advanced
+//   error      potential error
+// In practice, if nsamples = len(buffer)/2, then time <= maxtime. If maxtime was reached
+// first, then nsamples <= len(buffer)/2 and time >= maxtime. Note that it could happen that
+// time > maxtime, as it is modulated and the time could advance by 2 or more, so the loop
+// exit condition would fire when the time is already past maxtime.
+// Under no conditions, nsamples >= len(buffer)/2 i.e. guaranteed to never overwrite the buffer.
+func (synth *C.Synth) Render(buffer []float32, maxtime int) (int, int, error) {
+	if len(buffer)%1 == 1 {
+		return -1, -1, errors.New("RenderTime writes stereo signals, so buffer should have even length")
+	}
+	samples := C.int(len(buffer) / 2)
+	time := C.int(maxtime)
+	errcode := int(C.su_render(synth, (*C.float)(&buffer[0]), &samples, &time))
+	if errcode > 0 {
+		return int(samples), int(time), &RenderError{errcode: errcode}
+	}
+	return int(samples), int(time), nil
+}
+
+// Trigger is part of C.Synths' implementation of sointu.Synth interface
+func (s *C.Synth) Trigger(voice int, note byte) {
+	s.SynthWrk.Voices[voice] = C.Voice{}
+	s.SynthWrk.Voices[voice].Note = C.int(note)
+}
+
+// Release is part of C.Synths' implementation of sointu.Synth interface
+func (s *C.Synth) Release(voice int) {
+	s.SynthWrk.Voices[voice].Release = 1
+}
+
+// Render error stores the exact errorcode, which is actually just the x87 FPU flags,
+// with only the critical failure flags masked. Useful if you are interested exactly
+// what went wrong with the patch.
+type RenderError struct {
+	errcode int
+}
+
+func (e *RenderError) Error() string {
+	var reasons []string
+	if e.errcode&0x40 != 0 {
+		reasons = append(reasons, "FPU stack over/underflow")
+	}
+	if e.errcode&0x04 != 0 {
+		reasons = append(reasons, "FPU divide by zero")
+	}
+	if e.errcode&0x01 != 0 {
+		reasons = append(reasons, "FPU invalid operation")
+	}
+	if e.errcode&0x3800 != 0 {
+		reasons = append(reasons, "FPU stack push/pops are not balanced")
+	}
+	return "RenderError: " + strings.Join(reasons, ", ")
+}

bridge/bridge_test.go

@@ -0,0 +1,146 @@
+package bridge_test
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io/ioutil"
+	"path"
+	"runtime"
+	"testing"
+
+	"github.com/vsariola/sointu"
+	"github.com/vsariola/sointu/bridge"
+)
+
+func TestBridge(t *testing.T) {
+	patch := sointu.Patch{
+		Instruments: []sointu.Instrument{
+			sointu.Instrument{1, []sointu.Unit{
+				sointu.Unit{Type: "envelope", Parameters: map[string]int{"stereo": 0, "attack": 64, "decay": 64, "sustain": 64, "release": 80, "gain": 128}},
+				sointu.Unit{Type: "envelope", Parameters: map[string]int{"stereo": 0, "attack": 95, "decay": 64, "sustain": 64, "release": 80, "gain": 128}},
+				sointu.Unit{Type: "out", Parameters: map[string]int{"stereo": 1, "gain": 128}},
+			}}}}
+
+	synth, err := bridge.Synth(patch)
+	if err != nil {
+		t.Fatalf("bridge compile error: %v", err)
+	}
+	synth.Trigger(0, 64)
+	buffer := make([]float32, 2*su_max_samples)
+	err = sointu.Render(synth, buffer[:len(buffer)/2])
+	if err != nil {
+		t.Fatalf("first render gave an error")
+	}
+	synth.Release(0)
+	err = sointu.Render(synth, buffer[len(buffer)/2:])
+	if err != nil {
+		t.Fatalf("first render gave an error")
+	}
+	_, filename, _, _ := runtime.Caller(0)
+	expectedb, err := ioutil.ReadFile(path.Join(path.Dir(filename), "..", "tests", "expected_output", "test_render_samples.raw"))
+	if err != nil {
+		t.Fatalf("cannot read expected: %v", err)
+	}
+	var createdbuf bytes.Buffer
+	err = binary.Write(&createdbuf, binary.LittleEndian, buffer)
+	if err != nil {
+		t.Fatalf("error converting buffer: %v", err)
+	}
+	createdb := createdbuf.Bytes()
+	if len(createdb) != len(expectedb) {
+		t.Fatalf("buffer length mismatch, got %v, expected %v", len(createdb), len(expectedb))
+	}
+	for i, v := range createdb {
+		if expectedb[i] != v {
+			t.Errorf("byte mismatch @ %v, got %v, expected %v", i, v, expectedb[i])
+			break
+		}
+	}
+}
+
+func TestStackUnderflow(t *testing.T) {
+	patch := sointu.Patch{
+		Instruments: []sointu.Instrument{
+			sointu.Instrument{1, []sointu.Unit{
+				sointu.Unit{Type: "pop", Parameters: map[string]int{}},
+			}}}}
+	synth, err := bridge.Synth(patch)
+	if err != nil {
+		t.Fatalf("bridge compile error: %v", err)
+	}
+	buffer := make([]float32, 2)
+	err = sointu.Render(synth, buffer)
+	if err == nil {
+		t.Fatalf("rendering should have failed due to stack underflow")
+	}
+}
+
+func TestStackBalancing(t *testing.T) {
+	patch := sointu.Patch{
+		Instruments: []sointu.Instrument{
+			sointu.Instrument{1, []sointu.Unit{
+				sointu.Unit{Type: "push", Parameters: map[string]int{}},
+			}}}}
+	synth, err := bridge.Synth(patch)
+	if err != nil {
+		t.Fatalf("bridge compile error: %v", err)
+	}
+	buffer := make([]float32, 2)
+	err = sointu.Render(synth, buffer)
+	if err == nil {
+		t.Fatalf("rendering should have failed due to unbalanced stack push/pop")
+	}
+}
+
+func TestStackOverflow(t *testing.T) {
+	patch := sointu.Patch{
+		Instruments: []sointu.Instrument{
+			sointu.Instrument{1, []sointu.Unit{
+				sointu.Unit{Type: "loadval", Parameters: map[string]int{"value": 128}},
+				sointu.Unit{Type: "loadval", Parameters: map[string]int{"value": 128}},
+				sointu.Unit{Type: "loadval", Parameters: map[string]int{"value": 128}},
+				sointu.Unit{Type: "loadval", Parameters: map[string]int{"value": 128}},
+				sointu.Unit{Type: "loadval", Parameters: map[string]int{"value": 128}},
+				sointu.Unit{Type: "loadval", Parameters: map[string]int{"value": 128}},
+				sointu.Unit{Type: "loadval", Parameters: map[string]int{"value": 128}},
+				sointu.Unit{Type: "loadval", Parameters: map[string]int{"value": 128}},
+				sointu.Unit{Type: "loadval", Parameters: map[string]int{"value": 128}},
+				sointu.Unit{Type: "pop", Parameters: map[string]int{}},
+				sointu.Unit{Type: "pop", Parameters: map[string]int{}},
+				sointu.Unit{Type: "pop", Parameters: map[string]int{}},
+				sointu.Unit{Type: "pop", Parameters: map[string]int{}},
+				sointu.Unit{Type: "pop", Parameters: map[string]int{}},
+				sointu.Unit{Type: "pop", Parameters: map[string]int{}},
+				sointu.Unit{Type: "pop", Parameters: map[string]int{}},
+				sointu.Unit{Type: "pop", Parameters: map[string]int{}},
+				sointu.Unit{Type: "pop", Parameters: map[string]int{}},
+			}}}}
+	synth, err := bridge.Synth(patch)
+	if err != nil {
+		t.Fatalf("bridge compile error: %v", err)
+	}
+	buffer := make([]float32, 2)
+	err = sointu.Render(synth, buffer)
+	if err == nil {
+		t.Fatalf("rendering should have failed due to stack overflow, despite balanced push/pops")
+	}
+}
+
+func TestDivideByZero(t *testing.T) {
+	patch := sointu.Patch{
+		Instruments: []sointu.Instrument{
+			sointu.Instrument{1, []sointu.Unit{
+				sointu.Unit{Type: "loadval", Parameters: map[string]int{"value": 128}},
+				sointu.Unit{Type: "invgain", Parameters: map[string]int{"invgain": 0}},
+				sointu.Unit{Type: "pop", Parameters: map[string]int{}},
+			}}}}
+	synth, err := bridge.Synth(patch)
+	if err != nil {
+		t.Fatalf("bridge compile error: %v", err)
+	}
+	buffer := make([]float32, 2)
+	err = sointu.Render(synth, buffer)
+	if err == nil {
+		t.Fatalf("rendering should have failed due to divide by zero")
+	}
+}

bridge/init_windows.go

@@ -0,0 +1,8 @@
+package bridge
+
+// #include "sointu.h"
+import "C"
+
+func init() {
+	C.su_load_gmdls() // GM.DLS is an windows specific sound bank so samples work currently only on windows
+}

bridge/song_test.go

@@ -0,0 +1,66 @@
+package bridge_test
+
+import (
+	"bytes"
+	"encoding/binary"
+	"io/ioutil"
+	"path"
+	"runtime"
+	"testing"
+
+	"github.com/vsariola/sointu"
+	"github.com/vsariola/sointu/bridge"
+	// TODO: test the song using a mocks instead
+)
+
+const BPM = 100
+const SAMPLE_RATE = 44100
+const TOTAL_ROWS = 16
+const SAMPLES_PER_ROW = SAMPLE_RATE * 4 * 60 / (BPM * 16)
+
+const su_max_samples = SAMPLES_PER_ROW * TOTAL_ROWS
+
+// const bufsize = su_max_samples * 2
+
+func TestPlayer(t *testing.T) {
+	patch := sointu.Patch{
+		Instruments: []sointu.Instrument{sointu.Instrument{1, []sointu.Unit{
+			sointu.Unit{Type: "envelope", Parameters: map[string]int{"stereo": 0, "attack": 32, "decay": 32, "sustain": 64, "release": 64, "gain": 128}},
+			sointu.Unit{Type: "oscillator", Parameters: map[string]int{"stereo": 0, "transpose": 64, "detune": 64, "phase": 0, "color": 96, "shape": 64, "gain": 128, "type": sointu.Sine, "lfo": 0, "unison": 0}},
+			sointu.Unit{Type: "mulp", Parameters: map[string]int{"stereo": 0}},
+			sointu.Unit{Type: "envelope", Parameters: map[string]int{"stereo": 0, "attack": 32, "decay": 32, "sustain": 64, "release": 64, "gain": 128}},
+			sointu.Unit{Type: "oscillator", Parameters: map[string]int{"stereo": 0, "transpose": 72, "detune": 64, "phase": 64, "color": 64, "shape": 96, "gain": 128, "type": sointu.Sine, "lfo": 0, "unison": 0}},
+			sointu.Unit{Type: "mulp", Parameters: map[string]int{"stereo": 0}},
+			sointu.Unit{Type: "out", Parameters: map[string]int{"stereo": 1, "gain": 128}},
+		}}}}
+	patterns := [][]byte{{64, 0, 68, 0, 32, 0, 0, 0, 75, 0, 78, 0, 0, 0, 0, 0}}
+	tracks := []sointu.Track{sointu.Track{1, []byte{0}}}
+	song := sointu.Song{BPM: 100, Patterns: patterns, Tracks: tracks, Patch: patch, Output16Bit: false, Hold: 1}
+	synth, err := bridge.Synth(patch)
+	if err != nil {
+		t.Fatalf("Compiling patch failed: %v", err)
+	}
+	buffer, err := sointu.Play(synth, song)
+	if err != nil {
+		t.Fatalf("Render failed: %v", err)
+	}
+	_, filename, _, _ := runtime.Caller(0)
+	expectedb, err := ioutil.ReadFile(path.Join(path.Dir(filename), "..", "tests", "expected_output", "test_oscillat_sine.raw"))
+	if err != nil {
+		t.Fatalf("cannot read expected: %v", err)
+	}
+	var createdbuf bytes.Buffer
+	err = binary.Write(&createdbuf, binary.LittleEndian, buffer)
+	if err != nil {
+		t.Fatalf("error converting buffer: %v", err)
+	}
+	createdb := createdbuf.Bytes()
+	if len(createdb) != len(expectedb) {
+		t.Fatalf("buffer length mismatch, got %v, expected %v", len(createdb), len(expectedb))
+	}
+	for i, v := range createdb {
+		if expectedb[i] != v {
+			t.Fatalf("byte mismatch @ %v, got %v, expected %v", i, v, expectedb[i])
+		}
+	}
+}