From 470ba28592aa86fbd3760aa3d84a4d650666f5d1 Mon Sep 17 00:00:00 2001 From: Veikko Sariola Date: Mon, 26 Oct 2020 08:30:43 +0200 Subject: [PATCH] Change the Render function in bridge.go to return a tuple of: number of samples rendered; bool indicating if rowend was reached; and a possible error. The callbacks are gone; the row looping is the job of the user which is probably better for everyone. --- bridge/bridge.go | 34 ++++++++++++++-------------------- bridge/bridge_test.go | 19 ++++++++++++++----- song/song.go | 24 +++++++++--------------- 3 files changed, 37 insertions(+), 40 deletions(-) diff --git a/bridge/bridge.go b/bridge/bridge.go index 7618e61..8a8b337 100644 --- a/bridge/bridge.go +++ b/bridge/bridge.go @@ -83,31 +83,25 @@ func (o Opcode) Mono() Opcode { // Render tries to fill the buffer with samples rendered by Sointu. // Parameters: -// buffer float32 slice to fill with rendered samples. Stereo signal, so +// buffer float32 slice to fill with rendered samples. Stereo signal, so // should have even length. -// maxRows maximum number of tracker rows that will be rendered in one -// call. Can be a large number, but keep finite to avoid getting -// stuck trying to render rows in case the synth is buggy and -// produces no sample. -// callback called every time a row advances. Won't get called if you have -// not set SamplesPerRow explicitly. -// Returns the number samples rendered, len(buffer)/2 in the typical case where buffer was filled -func (s *SynthState) Render(buffer []float32, maxRows int, callback func()) (int, error) { +// Returns a tuple (int, bool, error), consisting of the number samples +// rendered (len(buffer)/2 in the case where buffer was filled, less or equal +// if row end was reached before buffer was full), and bool indicating if row +// has ended +func (s *SynthState) Render(buffer []float32) (int, bool, error) { if len(buffer)%1 == 1 { - return -1, errors.New("Render writes stereo signals, so buffer should have even length") + return -1, false, errors.New("Render writes stereo signals, so buffer should have even length") } maxSamples := len(buffer) / 2 - remaining := maxSamples - for i := 0; i < maxRows; i++ { - remaining = int(C.su_render_samples((*C.SynthState)(s), C.int(remaining), (*C.float)(&buffer[2*(maxSamples-remaining)]))) - if remaining >= 0 { // values >= 0 mean that row end was reached - callback() - } - if remaining <= 0 { // values <= 0 mean that buffer is full, ready to return - break - } + retval := int(C.su_render_samples((*C.SynthState)(s), C.int(maxSamples), (*C.float)(&buffer[0]))) + if retval < 0 { + return maxSamples, false, nil + } else if retval == 0 { + return maxSamples, true, nil + } else { + return maxSamples - retval, true, nil } - return maxSamples - remaining, nil } func (s *SynthState) SetPatch(patch Patch) error { diff --git a/bridge/bridge_test.go b/bridge/bridge_test.go index ff2b605..1cae482 100644 --- a/bridge/bridge_test.go +++ b/bridge/bridge_test.go @@ -32,11 +32,20 @@ func TestBridge(t *testing.T) { s.Trigger(0, 64) s.SamplesPerRow = SAMPLES_PER_ROW * 8 // this song is two blocks of 8 rows, release before second block start buffer := make([]float32, 2*su_max_samples) - n, err := s.Render(buffer, 2, func() { - s.Release(0) - }) - if n < su_max_samples { - t.Fatalf("could not fill the whole buffer, %v samples rendered, %v expected", n, su_max_samples) + n, rowend, err := s.Render(buffer) + if n < su_max_samples/2 { + t.Fatalf("render should have filled half of the buffer on first call, %v samples rendered, %v expected", n, su_max_samples/2) + } + if rowend != true { + t.Fatalf("Row end should have been hit (rowend should have been true) on the first call to Render") + } + s.Release(0) + n, rowend, err = s.Render(buffer[(n * 2):]) + if n < su_max_samples/2 { + t.Fatalf("render should have filled second half of the buffer on the second call, %v samples rendered, %v expected", n, su_max_samples/2) + } + if rowend != true { + t.Fatalf("Row end should have been hit (rowend should have been true) on the second call to Render") } _, filename, _, _ := runtime.Caller(0) expectedb, err := ioutil.ReadFile(path.Join(path.Dir(filename), "..", "tests", "expected_output", "test_render_samples.raw")) diff --git a/song/song.go b/song/song.go index b401db4..eeb76e6 100644 --- a/song/song.go +++ b/song/song.go @@ -98,10 +98,13 @@ func (s *Song) Render() ([]float32, error) { for i := range curVoices { curVoices[i] = s.FirstTrackVoice(i) } - processRow := func(row int) { - if row >= s.TotalRows() { - return - } + samples := s.Samples + if samples < 0 { + samples = s.TotalRows() * s.SamplesPerRow() + } + buffer := make([]float32, samples*2) + totaln := 0 + for row := 0; row < s.TotalRows(); row++ { patternRow := row % s.PatternRows() pattern := row / s.PatternRows() for t := range s.Tracks { @@ -119,17 +122,8 @@ func (s *Song) Render() ([]float32, error) { synth.Trigger(curVoices[t], note) } } + n, _, _ := synth.Render(buffer[2*totaln:]) + totaln += n } - samples := s.Samples - if samples < 0 { - samples = s.TotalRows() * s.SamplesPerRow() - } - buffer := make([]float32, samples*2) - row := 0 - processRow(0) - synth.Render(buffer, s.TotalRows(), func() { - row++ - processRow(row) - }) return buffer, nil }