Fluidsynth fixes #81

Fluidsynth fixes (thanks Mark)
Should resolve #81

Author: jwdj

CHANGES

@@ -628,4 +628,4 @@ different panes. Tie/untie option added for notes. Broken rhythm
   menu version. For Linux (Gnome) users these menus are still empty but that is caused by Gnome, not EasyABC.
 - Fixed: Playing selection gave an error: AttributeError: 'bytes' object has no attribute 'encode'  (https://github.com/jwdj/EasyABC/issues/69)
 - Fixed: Now automatic insertion of bars (|) only when no text is selected
-
+- Fixed: FluidSynth issues on 64 bit Mac (thanks Mark)

fluidsynth.py

@@ -4,10 +4,14 @@
     Copyright 2012, Willem Vree
 
     Synth Class, partially copied from pyFluidSynth, Copyright 2008 Nathan Whitehead
+
+    Modified February 2024 S.M.Blinkhorn to pass pointer arguments into CDLL as c_void_p types
+    thereby avoiding Undefined Behaviours leading to access violations on some OSs,
+    notably, 64bit Windows.
 '''
 
 import time
-from ctypes import c_int, c_uint, c_double, c_char_p, byref, CDLL
+from ctypes import c_int, c_uint, c_double, c_float, c_char_p, c_wchar_p, c_void_p, byref, CDLL
 # from ctypes.util import find_library
 
 import sys
@@ -49,6 +53,7 @@ def b(s):
     try:
         lib = lib_locations[i]
         F = CDLL(lib)
+        # print("Library %s" % lib)
         break
     except:
         i += 1
@@ -58,7 +63,11 @@ def b(s):
 
 class Synth:            # interface for the FluidSynth synthesizer
     def __init__(self, gain=0.2, samplerate=44100.0, bsize=64, output_path=None):
+        self.handle = c_void_p
+        F.new_fluid_settings.restype = self.handle
+        F.new_fluid_synth.restype = self.handle
         self.settings = F.new_fluid_settings()
+        # print("Settings: %s" % hex(self.settings))
         self.setting_setnum('synth.gain', gain)
         # self.setting_setnum('synth.sample-rate', samplerate)
         # self.setting_setint('audio.period-size', bsize)
@@ -72,28 +81,28 @@ def __init__(self, gain=0.2, samplerate=44100.0, bsize=64, output_path=None):
             self.setting_setstr("player.timing-source", "sample")
             # since this is a non-realtime scenario, there is no need to pin the sample data
             self.setting_setint("synth.lock-memory", 0)
-        self.synth = F.new_fluid_synth(self.settings)
+        self.synth = F.new_fluid_synth((c_void_p(self.settings)))
         self.audio_driver = None
 
     def setting_setstr(self, name, value):
-        F.fluid_settings_setstr(self.settings, c_char_p(b(name)), c_char_p(b(value)))
+        F.fluid_settings_setstr(c_void_p(self.settings), c_char_p(b(name)), c_char_p(b(value)))
 
     def setting_setint(self, name, value):
-        F.fluid_settings_setint(self.settings, c_char_p(b(name)), c_int(value))
+        F.fluid_settings_setint(c_void_p(self.settings), c_char_p(b(name)), c_int(value))
 
     def setting_setnum(self, name, value):
-        F.fluid_settings_setnum(self.settings, c_char_p(b(name)), c_double(value))
+        F.fluid_settings_setnum(c_void_p(self.settings), c_char_p(b(name)), c_double(value))
 
     def setting_getint(self, name):
         n = c_int()
-        F.fluid_settings_getint(self.settings, c_char_p(b(name)), byref(n))
+        F.fluid_settings_getint(c_void_p(self.settings), c_char_p(b(name)), byref(n))
         return n
 
     def start(self, driver=None):   # initialize the audio driver
         if driver is not None:
             assert(driver in ['alsa', 'oss', 'jack', 'portaudio', 'sndmgr', 'coreaudio', 'dsound', 'pulseaudio'])
             self.setting_setstr('audio.driver', driver)
-        self.audio_driver = F.new_fluid_audio_driver(self.settings, self.synth)
+        self.audio_driver = F.new_fluid_audio_driver(c_void_p(self.settings), c_void_p(self.synth))
         if not self.audio_driver:   # API returns 0 on error (not None)
             self.audio_driver = None
         # else:   # print some info
@@ -103,35 +112,35 @@ def start(self, driver=None):   # initialize the audio driver
 
     def delete(self):              # release all memory
         if self.audio_driver is not None:
-            F.delete_fluid_audio_driver(self.audio_driver)
-        F.delete_fluid_synth(self.synth)
-        F.delete_fluid_settings(self.settings)
+            F.delete_fluid_audio_driver(c_void_p(self.audio_driver))
+        F.delete_fluid_synth(c_void_p(self.synth))
+        F.delete_fluid_settings(c_void_p(self.settings))
         self.settings = self.synth = self.audio_driver = None
 
     def sfload(self, filename, update_midi_preset=0):  # load soundfont
-        return F.fluid_synth_sfload(self.synth, c_char_p(b(filename)), update_midi_preset)
+        return F.fluid_synth_sfload(c_void_p(self.synth), c_char_p(b(filename)), update_midi_preset)
 
     def sfunload(self, sfid, update_midi_preset=0):    # clear soundfont
-        return F.fluid_synth_sfunload(self.synth, sfid, update_midi_preset)
+        return F.fluid_synth_sfunload(c_void_p(self.synth), sfid, update_midi_preset)
 
     def program_select(self, chan, sfid, bank, preset):
-        return F.fluid_synth_program_select(self.synth, chan, sfid, bank, preset)
+        return F.fluid_synth_program_select(c_void_p(self.synth), chan, sfid, bank, preset)
 
     def set_reverb(self, roomsize, damping, width, level):     # change reverb model parameters
-        return F.fluid_synth_set_reverb(self.synth, c_double(roomsize), c_double(damping), c_double(width), c_double(level))
+        return F.fluid_synth_set_reverb(c_void_p(self.synth), c_double(roomsize), c_double(damping), c_double(width), c_double(level))
 
     def set_chorus(self, nr, level, speed, depth_ms, type):    # change chorus model pararmeters
-        return F.fluid_synth_set_chorus(self.synth, nr, c_double(level), c_double(speed), c_double(depth_ms), type)
+        return F.fluid_synth_set_chorus(c_void_p(self.synth), nr, c_double(level), c_double(speed), c_double(depth_ms), type)
 
     def set_reverb_level(self, level):                     # set the amount of reverb (0-127) on all midi channels
         n = F.fluid_synth_count_midi_channels(self.synth)
         for chan in range(n):
-            F.fluid_synth_cc(self.synth, chan, 91, level) # midi control change #91 == reverb level
+            F.fluid_synth_cc(c_void_p(self.synth), chan, 91, level) # midi control change #91 == reverb level
 
     def set_chorus_level(self, level):                     # set the amount of chorus (0-127) on all midi channels
         n = F.fluid_synth_count_midi_channels(self.synth)
         for chan in range(n):
-            F.fluid_synth_cc(self.synth, chan, 93, level) # midi control change #93 == chorus level
+            F.fluid_synth_cc(c_void_p(self.synth), chan, 93, level) # midi control change #93 == chorus level
 
     def set_gain(self, gain):
         self.setting_setnum('synth.gain', gain)
@@ -148,38 +157,40 @@ class Player:               # interface for the FluidSynth internal midi player
     LOOP_INFINITELY = -1
 
     def __init__(self, flsynth):
+        self.handle = c_void_p
+        F.new_fluid_player.restype = self.handle
         self.flsynth = flsynth # an instance of class Synth
-        self.player = F.new_fluid_player(self.flsynth.synth)
+        self.player = F.new_fluid_player(c_void_p(self.flsynth.synth))
 
     def add(self, midifile):  # add midifile to the playlist
-        return F.fluid_player_add(self.player, c_char_p(b(midifile))) == 0
+        return F.fluid_player_add(c_void_p(self.player), c_char_p(b(midifile))) == 0
 
     def play(self, offset=0): # start playing at time == offset in midi ticks
         self.seek(offset)
-        F.fluid_player_play(self.player)
+        F.fluid_player_play(c_void_p(self.player))
 
     def set_loop(self, loops = LOOP_INFINITELY):
-        F.fluid_player_set_loop(self.player, loops)
+        F.fluid_player_set_loop(c_void_p(self.player), loops)
 
     def stop(self):           # stop playing and return position in midi ticks
-        F.fluid_player_stop(self.player)
-        F.fluid_synth_all_notes_off(self.flsynth.synth, -1)   # -1 == all channels
+        F.fluid_player_stop(c_void_p(self.player))
+        F.fluid_synth_all_notes_off(c_void_p(self.flsynth.synth), -1)   # -1 == all channels
         return self.get_ticks()
 
     def wait(self):           # wait until player is finished
-        F.fluid_player_join(self.player)
+        F.fluid_player_join(c_void_p(self.player))
 
     def get_status(self):     # 1 == playing, 2 == player finished
-        return F.fluid_player_get_status(self.player)
+        return F.fluid_player_get_status(c_void_p(self.player))
 
     def get_ticks(self):      # get current position in midi ticks
         # oldFluid #  t = F.fluid_player_get_ticks(self.player)
-        t = F.fluid_player_get_current_tick(self.player)
+        t = F.fluid_player_get_current_tick(c_void_p(self.player))
         return t
 
     def seek(self, ticks_p):  # go to position ticks_p (in midi ticks)
-        F.fluid_synth_all_notes_off(self.flsynth.synth, -1)   # -1 == all channels
-        ticks = F.fluid_player_seek(self.player, ticks_p)
+        F.fluid_synth_all_notes_off(c_void_p(self.flsynth.synth), -1)   # -1 == all channels
+        ticks = F.fluid_player_seek(c_void_p(self.player), ticks_p)
         return ticks
 
     def seekW(self, ticks_p): # go to position ticks_p (in midi ticks) and wait until seeked
@@ -192,27 +203,29 @@ def seekW(self, ticks_p): # go to position ticks_p (in midi ticks) and wait unti
         return ticks
 
     def get_length(self):  # get duration of a midi track in ticks
-        return F.fluid_player_get_total_ticks(self.player)
+        return F.fluid_player_get_total_ticks(c_void_p(self.player))
 
     def delete(self):
-        F.delete_fluid_player(self.player)
+        F.delete_fluid_player(c_void_p(self.player))
 
     def renderLoop(self, callback=None):       # render midi file to audio file
-        renderer = F.new_fluid_file_renderer(self.flsynth.synth)
+        self.handle = c_void_p
+        F.new_fluid_file_renderer.restype = self.handle
+        renderer = F.new_fluid_file_renderer(c_void_p(self.flsynth.synth))
         if not renderer:
             print('failed to create file renderer')
             return
         k = self.flsynth.setting_getint('audio.period-size')         # get block size (samples are rendered one block at a time)
         samples = 0               # sample counter
         while self.get_status() == 1:
-            if F.fluid_file_renderer_process_block(renderer) != 0: # render one block
+            if F.fluid_file_renderer_process_block(c_void_p(renderer)) != 0: # render one block
                 print('renderer_loop error')
                 break
             samples += k.value    # increment with block size
             if callback: callback(samples)   # for progress reporting
         self.stop()  # just for sure: stop the playback explicitly and wait until finished
-        F.fluid_player_join(self.player)
-        F.delete_fluid_file_renderer(renderer)
+        F.fluid_player_join(c_void_p(self.player))
+        F.delete_fluid_file_renderer(c_void_p(renderer))
         return samples
 
     def set_render_mode(self, file_name, file_type):  # set audio file and audio type