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

@@ -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
+// Returns a tuple (int, bool, error), consisting of the number samples
-//              call. Can be a large number, but keep finite to avoid getting
+// rendered (len(buffer)/2 in the case where buffer was filled, less or equal
-//				stuck trying to render rows in case the synth is buggy and
+// if row end was reached before buffer was full), and bool indicating if row
-//				produces no sample.
+// has ended
-//	 callback	called every time a row advances. Won't get called if you have
+func (s *SynthState) Render(buffer []float32) (int, bool, error) {
-//				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) {
 	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
+	retval := int(C.su_render_samples((*C.SynthState)(s), C.int(maxSamples), (*C.float)(&buffer[0])))
-	for i := 0; i < maxRows; i++ {
+	if retval < 0 {
-		remaining = int(C.su_render_samples((*C.SynthState)(s), C.int(remaining), (*C.float)(&buffer[2*(maxSamples-remaining)])))
+		return maxSamples, false, nil
-		if remaining >= 0 { // values >= 0 mean that row end was reached
+	} else if retval == 0 {
-			callback()
+		return maxSamples, true, nil
-		}
+	} else {
-		if remaining <= 0 { // values <= 0 mean that buffer is full, ready to return
+		return maxSamples - retval, true, nil
-			break
-		}
 	}
-	return maxSamples - remaining, nil
 }
 
 func (s *SynthState) SetPatch(patch Patch) error {

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() {
+	n, rowend, err := s.Render(buffer)
-		s.Release(0)
+	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 n < su_max_samples {
+	}
-		t.Fatalf("could not fill the whole buffer, %v samples rendered, %v expected", n, su_max_samples)
+	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"))

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) {
+	samples := s.Samples
-		if row >= s.TotalRows() {
+	if samples < 0 {
-			return
+		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
 }