python: fix various cases of callbacks not being freed

Author: jcelerier

bindings/python/example_rawio.py

@@ -8,79 +8,91 @@
 """
 import pylibremidi as lm
 
-# --- MIDI 1 Raw I/O ---
-print("=== MIDI 1 Raw I/O ===")
 
-# The library will give us a callback to call when bytes arrive
-stored_cb = None
+def midi1_example():
+    print("=== MIDI 1 Raw I/O ===")
 
-# Input: receive and print parsed MIDI messages
-in_config = lm.InputConfiguration()
-in_config.on_message = lambda msg: print(f"  Received: {msg}")
-in_config.direct = True  # Call Python callbacks directly (no poll needed)
+    # The library will give us a callback to call when bytes arrive
+    stored_cb = [None]
 
-rawio_in = lm.RawioInputConfiguration()
-rawio_in.set_receive_callback = lambda cb: globals().update(stored_cb=cb)
-rawio_in.stop_receive = lambda: globals().update(stored_cb=None)
+    # Input: receive and print parsed MIDI messages
+    in_config = lm.InputConfiguration()
+    in_config.on_message = lambda msg: print(f"  Received: {msg}")
+    in_config.direct = True  # Call Python callbacks directly (no poll needed)
 
-midi_in = lm.MidiIn(in_config, rawio_in)
-midi_in.open_virtual_port("rawio_in")
+    rawio_in = lm.RawioInputConfiguration()
+    rawio_in.set_receive_callback = lambda cb: stored_cb.__setitem__(0, cb)
+    rawio_in.stop_receive = lambda: stored_cb.__setitem__(0, None)
 
-# Output: loopback written bytes into the input
-out_config = lm.OutputConfiguration()
+    midi_in = lm.MidiIn(in_config, rawio_in)
+    midi_in.open_virtual_port("rawio_in")
 
-def loopback_write(data):
-    if stored_cb:
-        stored_cb(data, 0)
-    return lm.Error()
+    # Output: loopback written bytes into the input
+    out_config = lm.OutputConfiguration()
 
-rawio_out = lm.RawioOutputConfiguration()
-rawio_out.write_bytes = loopback_write
+    def loopback_write(data):
+        if stored_cb[0]:
+            stored_cb[0](data, 0)
+        return lm.Error()
 
-midi_out = lm.MidiOut(out_config, rawio_out)
-midi_out.open_virtual_port("rawio_out")
+    rawio_out = lm.RawioOutputConfiguration()
+    rawio_out.write_bytes = loopback_write
 
-# Send some MIDI messages - they loop back through the rawio transport
-print("Sending Note On C4...")
-midi_out.send_message(0x90, 60, 100)
+    midi_out = lm.MidiOut(out_config, rawio_out)
+    midi_out.open_virtual_port("rawio_out")
 
-print("Sending Note Off C4...")
-midi_out.send_message(0x80, 60, 0)
+    # Send some MIDI messages - they loop back through the rawio transport
+    print("Sending Note On C4...")
+    midi_out.send_message(0x90, 60, 100)
 
-print("Sending CC Volume=80...")
-midi_out.send_message(0xB0, 7, 80)
+    print("Sending Note Off C4...")
+    midi_out.send_message(0x80, 60, 0)
 
-# --- MIDI 2 Raw I/O (UMP) ---
-print("\n=== MIDI 2 Raw I/O (UMP) ===")
+    print("Sending CC Volume=80...")
+    midi_out.send_message(0xB0, 7, 80)
 
-stored_ump_cb = None
+    # close_port breaks the reference cycle: midi_out -> write -> stored_cb -> C++ callback -> midi_in
+    midi_in.close_port()
+    midi_out.close_port()
 
-ump_in_config = lm.UmpInputConfiguration()
-ump_in_config.on_message = lambda msg: print(f"  Received UMP: {msg}")
-ump_in_config.direct = True
 
-rawio_ump_in = lm.RawioUmpInputConfiguration()
-rawio_ump_in.set_receive_callback = lambda cb: globals().update(stored_ump_cb=cb)
-rawio_ump_in.stop_receive = lambda: globals().update(stored_ump_cb=None)
+def midi2_example():
+    print("\n=== MIDI 2 Raw I/O (UMP) ===")
 
-ump_midi_in = lm.MidiIn(ump_in_config, rawio_ump_in)
-ump_midi_in.open_virtual_port("rawio_ump_in")
+    stored_cb = [None]
 
-ump_out_config = lm.OutputConfiguration()
+    ump_in_config = lm.UmpInputConfiguration()
+    ump_in_config.on_message = lambda msg: print(f"  Received UMP: {msg}")
+    ump_in_config.direct = True
 
-def loopback_write_ump(data):
-    if stored_ump_cb:
-        stored_ump_cb(data, 0)
-    return lm.Error()
+    rawio_ump_in = lm.RawioUmpInputConfiguration()
+    rawio_ump_in.set_receive_callback = lambda cb: stored_cb.__setitem__(0, cb)
+    rawio_ump_in.stop_receive = lambda: stored_cb.__setitem__(0, None)
 
-rawio_ump_out = lm.RawioUmpOutputConfiguration()
-rawio_ump_out.write_ump = loopback_write_ump
+    midi_in = lm.MidiIn(ump_in_config, rawio_ump_in)
+    midi_in.open_virtual_port("rawio_ump_in")
 
-ump_midi_out = lm.MidiOut(ump_out_config, rawio_ump_out)
-ump_midi_out.open_virtual_port("rawio_ump_out")
+    ump_out_config = lm.OutputConfiguration()
 
-# Send a MIDI 2.0 Note On UMP (group 0, channel 0, note 60)
-print("Sending UMP Note On...")
-ump_midi_out.send_ump(0x4090003C, 0xC0000000)
+    def loopback_write_ump(data):
+        if stored_cb[0]:
+            stored_cb[0](data, 0)
+        return lm.Error()
 
+    rawio_ump_out = lm.RawioUmpOutputConfiguration()
+    rawio_ump_out.write_ump = loopback_write_ump
+
+    midi_out = lm.MidiOut(ump_out_config, rawio_ump_out)
+    midi_out.open_virtual_port("rawio_ump_out")
+
+    # Send a MIDI 2.0 Note On UMP (group 0, channel 0, note 60)
+    print("Sending UMP Note On...")
+    midi_out.send_ump(0x4090003C, 0xC0000000)
+
+    midi_in.close_port()
+    midi_out.close_port()
+
+
+midi1_example()
+midi2_example()
 print("\nDone.")

bindings/python/pylibremidi.cpp

@@ -68,6 +68,10 @@ struct observer_poll_wrapper {
 
   explicit observer_poll_wrapper(observer_configuration conf, libremidi::observer_api_configuration api_conf) : conf{conf}, impl{process(std::move(conf)), std::move(api_conf)} {}
 
+  ~observer_poll_wrapper() {
+    conf = {};
+  }
+
   observer_configuration process(observer_configuration &&obs) {
     if (obs.on_error)
       obs.on_error = [this](std::string_view errorText, const source_location &) { queue.enqueue(poll_queue::error_message{std::string{errorText}}); };
@@ -128,6 +132,12 @@ struct midi_in_poll_wrapper {
   explicit midi_in_poll_wrapper(ump_input_configuration_wrapper conf) noexcept : python_ump_callbacks{conf}, impl{this->process(std::move(conf))} {}
   explicit midi_in_poll_wrapper(ump_input_configuration_wrapper conf, input_api_configuration api_conf) : python_ump_callbacks{conf}, impl{this->process(std::move(conf)), std::move(api_conf)} {}
 
+  ~midi_in_poll_wrapper() {
+    impl.close_port();
+    python_midi1_callbacks = {};
+    python_ump_callbacks = {};
+  }
+
   input_configuration process(input_configuration_wrapper obs) {
     python_midi1_callbacks = obs;
 
@@ -326,6 +336,11 @@ struct midi_out_poll_wrapper {
   explicit midi_out_poll_wrapper(const output_configuration_wrapper &conf) noexcept : python_midi1_callbacks{conf}, impl{this->process(std::move(conf))} {}
   explicit midi_out_poll_wrapper(output_configuration_wrapper conf, output_api_configuration api_conf) : python_midi1_callbacks{conf}, impl{this->process(std::move(conf)), std::move(api_conf)} {}
 
+  ~midi_out_poll_wrapper() {
+    impl.close_port();
+    python_midi1_callbacks = {};
+  }
+
   output_configuration process(output_configuration_wrapper obs) {
     python_midi1_callbacks = obs;
 

include/libremidi/backends/rawio/midi_in.hpp

@@ -51,6 +51,9 @@ class midi_in final
   {
     if (configuration.stop_receive)
       configuration.stop_receive();
+    // Clear all callbacks to break reference cycles (prevents leaks in binding layers)
+    configuration.set_receive_callback = nullptr;
+    configuration.stop_receive = nullptr;
     return stdx::error{};
   }
 

include/libremidi/backends/rawio/midi_in_ump.hpp

@@ -50,6 +50,8 @@ class midi_in final
   {
     if (configuration.stop_receive)
       configuration.stop_receive();
+    configuration.set_receive_callback = nullptr;
+    configuration.stop_receive = nullptr;
     return stdx::error{};
   }
 

include/libremidi/backends/rawio/midi_out.hpp

@@ -29,7 +29,11 @@ class midi_out final
 
   stdx::error open_virtual_port(std::string_view) override { return stdx::error{}; }
 
-  stdx::error close_port() override { return stdx::error{}; }
+  stdx::error close_port() override
+  {
+    configuration.write_bytes = nullptr;
+    return stdx::error{};
+  }
 
   stdx::error set_port_name(std::string_view) override { return stdx::error{}; }
 

include/libremidi/backends/rawio/midi_out_ump.hpp

@@ -29,7 +29,11 @@ class midi_out final
 
   stdx::error open_virtual_port(std::string_view) override { return stdx::error{}; }
 
-  stdx::error close_port() override { return stdx::error{}; }
+  stdx::error close_port() override
+  {
+    configuration.write_ump = nullptr;
+    return stdx::error{};
+  }
 
   stdx::error set_port_name(std::string_view) override { return stdx::error{}; }