fix problem with shutdown and open notes

Author: emicklei

core/timeline.go

@@ -57,13 +57,17 @@ func (t *Timeline) Len() int64 {
 func (t *Timeline) Play() {
 	t.resume = make(chan bool)
 	t.isPlaying = true
-	for {
+	for t.isPlaying {
 		t.protection.RLock()
 		here := t.head
 		t.protection.RUnlock()
 		if here == nil {
-			<-t.resume
-			continue
+			// Wait for a signal (new event or shutdown signal)
+			select {
+			case <-t.resume:
+				// Continue to check isPlaying at top of loop
+				continue
+			}
 		}
 		now := time.Now()
 		for now.After(here.when) {
@@ -100,6 +104,25 @@ func (t *Timeline) Reset() {
 	t.tail = nil
 }
 
+// Stop signals the Play loop to exit gracefully.
+// Should be called during shutdown to clean up the timeline goroutine.
+func (t *Timeline) Stop() {
+	t.protection.Lock()
+	wasPlaying := t.isPlaying
+	t.isPlaying = false
+	t.protection.Unlock()
+
+	// If we were playing, wake up the goroutine so it can check isPlaying and exit
+	if wasPlaying && t.resume != nil {
+		select {
+		case t.resume <- true:
+			// Signal sent successfully
+		case <-time.After(100 * time.Millisecond):
+			// Timeout in case goroutine is already stopped
+		}
+	}
+}
+
 // Schedule adds an event for a given time
 func (t *Timeline) Schedule(event TimelineEvent, when time.Time) error {
 	now := time.Now()

midi/midi_message.go

@@ -13,8 +13,10 @@ const (
 	noteOn        int64 = 0x90 // 10010000 , 144
 	noteOff       int64 = 0x80 // 10000000 , 128
 	controlChange int64 = 0xB0 // 10110000 , 176
-	noteAllOff    int64 = 0x78 // 01111000 , 120  (not 123 because sustain)
-	sustainPedal  int64 = 0x40
+	allSoundOff   int64 = 0x78 // CC120
+	allNotesOff   int64 = 0x7B // CC123
+	sustainPedal  int64 = 0x40 // CC64
+	sustainOff    int64 = 0x00
 )
 
 type Message struct {

midi/output_device.go

@@ -38,16 +38,49 @@ func (d *OutputDevice) Reset() {
 			notify.Warnf("reset failed for device:%v", d.id)
 		}
 	}()
+	// Stop the timeline goroutine first, then clear the queue
+	d.timeline.Stop()
 	d.timeline.Reset()
+	// Give timeline time to stop processing any pending events
+	time.Sleep(10 * time.Millisecond)
+
 	if notify.IsDebug() {
 		notify.Debugf("device.%d: sending Note OFF to all 16 channels", d.id)
 	}
 	if d.stream != nil {
-		// send note off all to all channels for current device
+		// Send a robust panic sequence for each channel.
+		// Some devices respond better to CC123, others to CC120, and sustained notes
+		// require a sustain-off first.
 		for c := 1; c <= 16; c++ {
-			if err := d.stream.WriteShort(controlChange|int64(c-1), noteAllOff, 0); err != nil {
+			status := controlChange | int64(c-1)
+			notify.Debugf("reset: sending off events to [channel %d]", c)
+			if err := d.stream.WriteShort(status, sustainPedal, sustainOff); err != nil {
+				notify.Console.Errorf("device.%d: midi write error:%v", d.id, err)
+			}
+			if err := d.stream.WriteShort(status, allNotesOff, 0); err != nil {
+				notify.Console.Errorf("device.%d: midi write error:%v", d.id, err)
+			}
+			if err := d.stream.WriteShort(status, allSoundOff, 0); err != nil {
 				notify.Console.Errorf("device.%d: midi write error:%v", d.id, err)
 			}
+			// Small delay between channels to allow receiver to process messages.
+			time.Sleep(5 * time.Millisecond)
+		}
+
+		// Send explicit note-off messages for all notes on all channels.
+		// This is more direct than relying on CC123/CC120 alone and handles
+		// devices/DAWs that may not respond to control changes during shutdown.
+		noteOff := int64(0x80) // MIDI Note Off status
+		for c := 1; c <= 16; c++ {
+			status := noteOff | int64(c-1)
+			notify.Debugf("reset: sending explicit note-off for all notes on channel %d", c)
+			for n := 0; n <= 127; n++ {
+				if err := d.stream.WriteShort(status, int64(n), 0); err != nil {
+					notify.Console.Errorf("device.%d: note-off write error:%v", d.id, err)
+				}
+			}
+			// Small delay between channels
+			time.Sleep(5 * time.Millisecond)
 		}
 	}
 }

midi/registry_device.go

@@ -47,10 +47,21 @@ func (r *DeviceRegistry) DefaultDeviceIDs() (inputDeviceID, outputDeviceID int)
 }
 
 func (r *DeviceRegistry) Reset() {
+	r.mutex.RLock()
+	outs := make([]*OutputDevice, 0, len(r.out))
 	for _, each := range r.out {
-		each.Reset()
+		outs = append(outs, each)
 	}
+	ins := make([]*InputDevice, 0, len(r.in))
 	for _, each := range r.in {
+		ins = append(ins, each)
+	}
+	r.mutex.RUnlock()
+
+	for _, each := range outs {
+		each.Reset()
+	}
+	for _, each := range ins {
 		each.stopListener()
 	}
 }
@@ -178,7 +189,14 @@ func (r *DeviceRegistry) initInputs() error {
 }
 
 func (r *DeviceRegistry) Close() error {
+	r.mutex.RLock()
+	ins := make([]*InputDevice, 0, len(r.in))
 	for _, each := range r.in {
+		ins = append(ins, each)
+	}
+	r.mutex.RUnlock()
+
+	for _, each := range ins {
 		each.stopListener()
 	}
 	return r.streamRegistry.close()

midi/transport/rt.go

@@ -140,10 +140,8 @@ func (l *RtListener) handleRtEvent(m rtmidi.MIDIIn, data []byte, delta float64)
 func (l *RtListener) Stop() {
 	l.mutex.Lock()
 	defer l.mutex.Unlock()
-	if l.listening {
-		if err := l.midiIn.CancelCallback(); err != nil {
-			notify.Warnf("failed to cancel listener callback")
-		}
-	}
+	// Keep the native callback installed and only gate delivery in handleRtEvent.
+	// Calling CancelCallback can race with in-flight native callbacks and cause
+	// a nil dereference inside the upstream rtmidi binding.
 	l.listening = false
 }

system/tear_down.go

@@ -7,9 +7,14 @@ import (
 )
 
 func TearDown(ctx core.Context) error {
+	// Stop timing/scheduling first to minimize new events during shutdown.
 	dsl.StopAllPlayables(ctx)
-	ctx.Control().Reset()
-	ctx.Device().Close()
+	ctx.Control().Stop()
+	// Force immediate silence before closing MIDI streams.
+	ctx.Device().Reset()
+	if err := ctx.Device().Close(); err != nil {
+		return err
+	}
 	notify.PrintBye()
 	return nil
 }

ui/cli/app.go

@@ -42,17 +42,15 @@ func StartREPL(ctx core.Context) {
 	// start REPL
 	line := liner.NewLiner()
 	defer line.Close()
-	defer tearDown(line, ctx)
+	defer tearDown(line)
 	// TODO liner catches control+c
 	//setupCloseHandler(line)
 	ctx.Device().Report()
 	setup(line)
 	repl(line, ctx)
 }
 
-func tearDown(line *liner.State, ctx core.Context) {
-	ctx.Control().Reset()
-	ctx.Device().Reset()
+func tearDown(line *liner.State) {
 	if f, err := os.Create(history); err != nil {
 		notify.Print(notify.NewErrorf("error writing history file:%v", err))
 	} else {
@@ -77,7 +75,6 @@ func repl(line *liner.State, ctx core.Context) {
 		entry, err := line.Prompt(notify.Prompt())
 		if err != nil {
 			notify.Print(notify.NewError(err))
-			tearDown(line, ctx)
 			goto exit
 		}
 	entry:
@@ -134,13 +131,13 @@ exit:
 // setupCloseHandler creates a 'listener' on a new goroutine which will notify the
 // program if it receives an interrupt from the OS. We then handle this by calling
 // our clean up procedure and exiting the program.
-func setupCloseHandler(line *liner.State, ctx core.Context) {
+func setupCloseHandler(line *liner.State) {
 	c := make(chan os.Signal, 1)
 	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
 	go func() {
 		<-c
 		fmt.Println("\r- Ctrl+C pressed in Terminal")
-		tearDown(line, ctx)
+		tearDown(line)
 		os.Exit(0)
 	}()
 }