fiddle_fluidsynth 0.0.1

data/lib/fiddle_fluidsynth/midi_input/player.rb

@@ -0,0 +1,289 @@
+#
+# filename: fiddle-fluidsynth/midi_input/player.rb
+#
+
+
+# References
+# - fluidsynth.org, [API Reference](https://www.fluidsynth.org/api/modules.html)
+#
+class FiddleFluidSynth
+
+  # Parse standard MIDI files and emit MIDI events.
+  # ==== References
+  # - MIDI Input/[MIDI File Player](https://www.fluidsynth.org/api/group__midi__player.html)
+  # - [library fiddle](https://docs.ruby-lang.org/ja/latest/library/fiddle.html)
+  #
+
+  #
+  # [](https://www.fluidsynth.org/api/group__midi__player.html#gac792e9405fca53c296f7cef4d5fadfde)
+  #
+  enum(
+    :fluid_player_set_tempo_type,
+    FLUID_PLAYER_TEMPO_INTERNAL:      nil,
+    FLUID_PLAYER_TEMPO_EXTERNAL_BPM:  nil,
+    FLUID_PLAYER_TEMPO_EXTERNAL_MIDI: nil,
+    FLUID_PLAYER_TEMPO_NBR:           nil,
+  )
+
+  #
+  # - [](https://www.fluidsynth.org/api/group__midi__player.html#ga5ec93766f61465dedbbac9bdb76ced83)
+  #
+  enum(
+    :fluid_player_status,
+    FLUID_PLAYER_READY:    nil,
+    FLUID_PLAYER_PLAYING:  nil,
+    FLUID_PLAYER_STOPPING: nil,
+    FLUID_PLAYER_DONE:     nil,
+  )
+
+  #
+  module C
+
+
+    # Lifecycle Functions.
+    #
+    #
+
+    # Create a new MIDI player.
+    extern 'fluid_player_t* new_fluid_player(fluid_synth_t*)'
+
+    # Delete a MIDI player instance.
+    extern 'void delete_fluid_player(fluid_player_t*)'
+
+
+    # Functions.
+    #
+    #
+
+    # Add a MIDI file to a player queue.
+    # extern 'int fluid_player_add(void* player, const char*)' # also ok.
+    extern 'int fluid_player_add(fluid_player_t*, char*)'
+
+    # Add a MIDI file to a player queue, from a buffer in memory.
+    extern 'int fluid_player_add_mem(fluid_player_t*, void*, size_t)'
+
+    # Get the tempo currently used by a MIDI player.
+    extern 'int fluid_player_get_bpm(fluid_player_t*)'
+
+    # Get the number of tempo ticks passed.
+    extern 'int fluid_player_get_current_tick(fluid_player_t*)'
+
+    # Get the division currently used by a MIDI player.
+    extern 'int fluid_player_get_division(fluid_player_t*)'
+
+    # Get the tempo currently used by a MIDI player.
+    extern 'int fluid_player_get_midi_tempo(fluid_player_t*)'
+
+    # Get MIDI player status.
+    extern 'int fluid_player_get_status(fluid_player_t*)'
+
+    # Looks through all available MIDI tracks and gets the absolute tick
+    # of the very last event to play.
+    extern 'int fluid_player_get_total_ticks(fluid_player_t*)'
+
+    # Wait for a MIDI player until the playback has been stopped.
+    extern 'int fluid_player_join(fluid_player_t*)'
+
+    # Activates play mode for a MIDI player if not already playing.
+    extern 'int fluid_player_play(fluid_player_t*)'
+
+    # Seek in the currently playing file.
+    extern 'int fluid_player_seek(fluid_player_t*, int)'
+
+    ### setters.
+
+    # Set the tempo of a MIDI player in beats per minute.
+    extern 'int fluid_player_set_bpm(fluid_player_t*, int)'
+
+    # Enable looping of a MIDI player.
+    extern 'int fluid_player_set_loop(fluid_player_t*, int)'
+
+    # Set the tempo of a MIDI player.
+    extern 'int fluid_player_set_midi_tempo(fluid_player_t*, int)'
+
+    # Change the MIDI callback function.
+    extern 'int fluid_player_set_playback_callback' +
+      '(fluid_player_t*, handle_midi_event_func_t, void*)'
+
+    # Set the tempo of a MIDI player.
+    extern 'int fluid_player_set_tempo(fluid_player_t*, int, double)'
+
+    # Add a listener function for every MIDI tick change.
+    extern 'int fluid_player_set_tick_callback' +
+      '(fluid_player_t*, handle_midi_tick_func_t, void*)'
+      # '(fluid_player_t*, void*, void*)'
+
+    # Pauses the MIDI playback.
+    extern 'int fluid_player_stop(fluid_player_t*)'
+
+  end
+end
+
+
+# Lifecycle Functions.
+#
+#
+class FiddleFluidSynth
+
+  def self.player_new( synth )
+    ret = C.new_fluid_player(synth)
+    ret
+  end
+  def player_new( synth = self.synth )
+    self.class.player_new(synth)
+  end
+
+  def self.player_delete( player )
+    ret = C.delete_fluid_player(player)
+    ret
+  end
+  def player_delete( player = self.player )
+    self.class.player_delete(player)
+  end
+
+end
+
+
+#
+#
+#
+class FiddleFluidSynth
+
+  # def player_add( file: , player: self.player )
+  def player_add( player = self.player, file: )
+    ret = C.fluid_player_add(player, file)
+    ret
+  end
+
+  def player_add_mem( player = self.player, buf: , size: )
+    ret = C.fluid_player_add_mem(player, buf, size)
+    ret
+  end
+
+  #
+  def player_get_bpm( player = self.player )
+    ret = C.fluid_player_get_bpm(player)
+    ret
+  end
+  alias :player_bpm :player_get_bpm
+
+  def player_get_current_tick( player = self.player )
+    ret = C.fluid_player_get_current_tick(player)
+    ret
+  end
+
+  def player_get_division( player = self.player )
+    ret = C.fluid_player_get_division(player)
+    ret
+  end
+
+  def player_get_midi_tempo( player = self.player )
+    ret = C.fluid_player_get_midi_tempo(player)
+    ret
+  end
+
+  def player_get_status( player = self.player )
+    ret = C.fluid_player_get_status(player)
+    ret
+  end
+  alias :player_status :player_get_status
+
+  def player_get_total_ticks( player = self.player )
+    ret = C.fluid_player_get_total_ticks(player)
+    ret
+  end
+
+  def player_join( player = self.player )
+    ret = C.fluid_player_join(player)
+    ret
+  end
+
+  def player_play( player = self.player )
+    ret = C.fluid_player_play(player)
+    ret
+  end
+
+  #
+  def player_seek( player = self.player, ticks: )
+    ret = C.fluid_player_seek(player, ticks)
+    ret
+  end
+
+  ### .
+
+  #
+  def player_set_bpm( player = self.player, bpm: )
+    deprecated_msg_instead('player_set_tempo()', meth: __method__)
+    ret = C.fluid_player_set_bmp(player, bpm)
+    ret
+  end
+
+  #
+  # ==== Args
+  # times:: Times left to loop the playlist. -1 means loop infinitely.
+  #
+  def player_set_loop( player = self.player, times: )
+    ret = C.fluid_player_set_loop(player, times)
+    ret
+  end
+
+  def player_set_midi_tempo( player = self.player, tempo: )
+    deprecated_msg_instead('player_set_tempo()', meth: __method__)
+    ret = C.fluid_player_set_midi_tempo(player, tempo)
+    ret
+  end
+
+  def player_set_playback_callback( player=self.player,
+                                    handler: , handler_data: )
+    ret = C.fluid_player_set_playback_callback(player, handler, handler_data)
+    ret
+  end
+
+  def player_set_tempo( player=self.player, tempo: )
+    ret = C.fluid_player_set_tempo(player, tempo)
+    ret
+  end
+
+  #
+  # ==== Args
+  # handler:: callback function address (in Fiddle::Pointer(FFI::Pointer)).
+  # handler_data:: Fiddle::Pointer.new(FFI::Pointer#address).
+  #   (actually this arg is
+  #   meaningless in Ruby. because we can use closure to describe
+  #   callback function.)
+  # yeild::
+  #   {|user_data, cur_tick| ... } is tick callback function, where
+  #   cur_tick is current tick in MIDI file.
+  #
+  # ==== See Also
+  # - util/util.rb:define_tick_callback().
+  #
+  def player_set_tick_callback( player=self.player,
+                                handler: nil, handler_data: nil )
+    #
+    if handler.nil? && block_given?
+      cb_ptr = self.define_tick_callback(){|user_data, cur_tick|
+        yield(user_data, cur_tick)
+      }
+      handler = cb_ptr
+    elsif !(handler.nil?)
+      # do nothing.
+    else
+      raise "Specify the handler in args or block."
+    end
+
+    #
+    ret = C.fluid_player_set_tick_callback(player, handler, handler_data)
+    ret
+  end
+
+  def player_stop( player = self.player )
+    ret = C.fluid_player_stop(player)
+    ret
+  end
+
+
+end
+
+
+#### endof filename: fiddle-fluidsynth/midi_input/player.rb

data/lib/fiddle_fluidsynth/midi_input/router.rb

@@ -0,0 +1,225 @@
+#
+# filename: fiddle-fluidstynth/midi_input/router.rb
+#
+
+
+# References
+# - fluidsynth.org, [API Reference](https://www.fluidsynth.org/api/modules.html)
+#
+class FiddleFluidSynth
+
+  # Rule based transformation and filtering of MIDI events.
+  # ==== References
+  # - API Reference, MIDI Input/[MIDI Router](https://www.fluidsynth.org/api/group__midi__router.html)
+  # - [library fiddle](https://docs.ruby-lang.org/ja/latest/library/fiddle.html)
+  #
+
+  # MIDI router rule type.
+  #
+  #
+  enum(
+    :fluid_midi_router_rule_type,
+    FLUID_MIDI_ROUTER_RULE_NOTE:             nil,
+    FLUID_MIDI_ROUTER_RULE_CC:               nil,
+    FLUID_MIDI_ROUTER_RULE_PROG_CHANGE:      nil,
+    FLUID_MIDI_ROUTER_RULE_PITCH_BEND:       nil,
+    FLUID_MIDI_ROUTER_RULE_CHANNEL_PRESSURE: nil,
+    FLUID_MIDI_ROUTER_RULE_KEY_PRESSURE:     nil,
+    FLUID_MIDI_ROUTER_RULE_COUNT:            nil,
+  )
+
+  #
+  module C
+
+
+    # Lifecycle Functions (MIDI Router).
+    #
+    #
+
+    # Create a new midi router.
+    extern 'fluid_midi_router_t* new_fluid_midi_router' +
+      '(fluid_settings_t*, handle_midi_event_func_t, void*)'
+
+    # Delete a MIDI router instance.
+    extern 'void delete_fluid_midi_router(fluid_midi_router_t*)'
+
+
+    # Lifecycle Functions (MIDI Router Rule).
+    #
+    #
+
+    # Create a new MIDI router rule.
+    extern 'fluid_midi_router_rule_t* new_fluid_midi_router_rule(void)'
+
+    # Free a MIDI router rule.
+    extern 'void delete_fluid_midi_router_rule(fluid_midi_router_rule_t*)'
+
+
+    # Functions.
+    #
+    #
+
+    #  MIDI event callback function to display event information to stdout.
+    extern 'int fluid_midi_dump_postrouter(void*, fluid_midi_event_t*)'
+
+    # MIDI event callback function to display event information to stdout.
+    extern 'int fluid_midi_dump_prerouter(void*, fluid_midi_event_t*)'
+
+    # Add a rule to a MIDI router.
+    extern 'int fluid_midi_router_add_rule' +
+      '(fluid_midi_router_t*, fluid_midi_router_rule_t*, int)'
+
+    # Clear all rules in a MIDI router.
+    extern 'int fluid_midi_router_clear_rules(fluid_midi_router_t*)'
+
+    # Handle a MIDI event through a MIDI router instance.
+    extern 'int fluid_midi_router_handle_midi_event(void*, fluid_midi_event_t*)'
+
+    # Set the channel portion of a rule.
+    extern 'void fluid_midi_router_rule_set_chan' +
+      '(fluid_midi_router_rule_t*, int, int, float, int)'
+
+    # Set the first parameter portion of a rule.
+    extern 'void fluid_midi_router_rule_set_param1' +
+      '(fluid_midi_router_rule_t*, int, int, float, int)'
+
+    # Set the second parameter portion of a rule.
+    extern 'void fluid_midi_router_rule_set_param2' +
+      '(fluid_midi_router_rule_t*, int, int, float, int)'
+
+    # Set a MIDI router to use default "unity" rules.
+    extern 'int fluid_midi_router_set_default_rules(fluid_midi_router_t*)'
+
+
+  end
+end
+
+
+# Lifecycle Functions.
+#
+#
+class FiddleFluidSynth
+
+  ### Router.
+
+  #
+  # ==== See Also
+  # - fluid_synth_handle_midi_event()
+  # - util/callback.rb
+  #
+  # def midi_router_new( handler: , data: , settings: self.settings )
+  def self.midi_router_new( settings: ,
+                            handler: Synth_handle_midi_event_default,
+                            handler_data: nil )
+    ret = C.new_fluid_midi_router(settings, handler, handler_data)
+    ret
+  end
+  def midi_router_new( settings = self.settings,
+                       handler: Synth_handle_midi_event_default,
+                       handler_data: nil )
+    self.class.midi_router_new(
+      settings: settings, handler: handler, handler_data: handler_data)
+  end
+
+  def self.midi_router_delete( router )
+    ret = C.delete_fluid_midi_router(router)
+    ret
+  end
+  def midi_router_delete( router )
+    self.class.midi_router_delete(router)
+  end
+
+  ### Router Rule.
+
+  def self.midi_router_rule_new
+    ret = C.new_fluid_midi_router_rule()
+    ret
+  end
+  def midi_router_rule_new
+    self.class.midi_router_rule_new
+  end
+
+  def self.midi_router_rule_delete( rule )
+    ret = C.delete_fluid_midi_router_rule(rule)
+    ret
+  end
+  def midi_router_rule_delete( rule )
+    self.class.midi_router_rule_delete(rule)
+  end
+
+end
+
+# Functions (Router).
+#
+#
+class FiddleFluidSynth
+
+  def midi_dump_postrouter( data: , event: )
+    ret = C.fluid_midi_dump_postrouter(data, event)
+    ret
+  end
+
+  def midi_dump_prerouter( data: , event: )
+    ret = C.fluid_midi_dump_prerouter(data, event)
+    ret
+  end
+
+end
+
+
+# Functions (Router Rules).
+#
+#
+class FiddleFluidSynth
+
+  #
+  def midi_router_add_rule( router, rule: , type: )
+    ret = C.fluid_midi_router_add_rule(router, rule, type)
+    ret
+  end
+
+  def midi_router_clear_rules( router )
+    ret = C.fluid_midi_router_clear_rules(router)
+    ret
+  end
+
+  #
+  # ==== See Also
+  # - util/callback.rb
+  #
+  def self.midi_router_handle_midi_event( data, event )
+    ret = C.fluid_midi_router_handle_midi_event(data, event)
+    ret
+  end
+  def midi_router_handle_midi_event( data, event )
+    self.class.midi_router_handle_midi_event(data, event)
+  end
+
+  #
+  def midi_router_rule_set_chan( rule, min: , max: , mul: , add: )
+    ret = C.fluid_midi_router_rule_set_chan(rule,min,max,mul,add)
+    ret
+  end
+  alias midi_router_rule_set_ch midi_router_rule_set_chan
+
+  def midi_router_rule_set_param1( rule, min: , max: , mul: , add: )
+    ret = C.fluid_midi_router_rule_set_param1(rule,min,max,mul,add)
+    ret
+  end
+
+  def midi_router_rule_set_param2( rule, min: , max: , mul: , add: )
+    ret = C.fluid_midi_router_rule_set_param2(rule,min,max,mul,add)
+    ret
+  end
+
+  #
+  def midi_router_set_default_rules( router )
+    ret = C.fluid_midi_router_set_default_rules(router)
+    ret
+  end
+
+
+end
+
+
+#### endof filename: fiddle-fluidstynth/midi_input/router.rb

data/lib/fiddle_fluidsynth/midi_input.rb

@@ -0,0 +1,11 @@
+#
+# filename: midi_input.rb
+#
+require_relative "./midi_input/midi_input"
+
+require_relative "./midi_input/driver"
+require_relative "./midi_input/events"
+require_relative "./midi_input/player"
+require_relative "./midi_input/router"
+
+#### end.

data/lib/fiddle_fluidsynth/misc/misc.rb

@@ -0,0 +1,162 @@
+#
+# filename: misc/misc.rb
+#
+
+
+# References
+# - [API Reference](https://www.fluidsynth.org/api/modules.html)
+#
+class FiddleFluidSynth
+
+  # Miscellaneous utility functions and defines.
+  # ==== References
+  # - [Miscellaneous](https://www.fluidsynth.org/api/group__misc.html)
+  # - [library fiddle](https://docs.ruby-lang.org/ja/latest/library/fiddle.html)
+  #
+
+  # Value that indicates failure, used by most libfluidsynth functions.
+  FLUID_FAILED = -1
+  # Value that indicates success, used by most libfluidsynth functions.
+  FLUID_OK     =  0
+
+  # these constants are available via #version_str() and #version().
+  # FLUIDSYNTH_VERSION = "2.4.6"
+  # FLUIDSYNTH_VERSION_MAJOR = 2
+  # FLUIDSYNTH_VERSION_MICRO = 4
+  # FLUIDSYNTH_VERSION_MINOR = 6
+
+  #
+  module C
+
+
+    # Functions.
+    #
+    #
+
+    # Wrapper for free() that satisfies at least C90 requirements.
+    extern 'void fluid_free(void*)'
+
+    # Check if a file is a MIDI file.
+    extern 'int fluid_is_midifile(char*)'
+
+    # Check if a file is a SoundFont file.
+    extern 'int fluid_is_soundfont(char*)'
+
+    # Get FluidSynth runtime version.
+    extern 'void fluid_version(int*, int*, int*)'
+
+    # Get FluidSynth runtime version as a string.
+    extern 'char* fluid_version_str(void)'
+
+  end
+
+end
+
+
+#
+#
+#
+class FiddleFluidSynth
+
+  def self.free( ptr )
+    ret = C.fluid_free(ptr)
+    ret
+  end
+  def free( ptr )
+    self.class.free(ptr)
+  end
+
+  def self.is_midifile( file )
+    ret = C.fluid_is_midifile(file)
+    ret
+  end
+  def is_midifile( file )
+    self.class.is_midifile(file)
+  end
+
+  def self.is_midifile?( file )
+    unless File.exist?(file)
+      raise "No such file: #{file}"
+    end
+
+    #ng. self.is_midifile(file) == C::FLUID_OK
+    self.is_midifile(file) != 0
+  end
+  def is_midifile?( file )
+    self.class.is_midifile?(file)
+  end
+
+
+  ### SoundFont
+
+  #
+  def self.is_soundfont( file )
+    ret = C.fluid_is_soundfont(file)
+    ret
+  end
+  def is_soundfont( file )
+    self.class.is_soundfont(file)
+  end
+
+  #
+  def self.is_soundfont?( file )
+    unless File.exist?(file)
+      raise "No such file: #{file}"
+    end
+
+    # self.is_soundfont(file) == C::FLUID_OK
+    self.is_soundfont(file) != 0
+  end
+  def is_soundfont?( file )
+    self.class.is_soundfont?(file)
+  end
+
+  #
+  def self.misc_version( major, micro, minor )
+    ret = C.fluid_version(major, micro, minor)
+    ret
+  end
+  def misc_version( major, micro, minor )
+    self.class.misc_version(major, micro, minor)
+  end
+
+  def self.misc_version_str
+    ret = C.fluid_version_str().to_s
+    ret
+  end
+  def misc_version_str
+    self.class.misc_version_str
+  end
+
+end
+
+#
+#
+#
+class FiddleFluidSynth
+
+  def self.fluidsynth_version
+    ver_maj = Fiddle::Pointer.malloc_i
+    ver_mic = Fiddle::Pointer.malloc_i
+    ver_min = Fiddle::Pointer.malloc_i
+
+    misc_version(ver_maj, ver_mic, ver_min)
+    tmp = [ver_maj, ver_mic, ver_min].map{|e| e.decode1_i }
+
+    ret = tmp
+    ret
+  end
+  def fluidsynth_version; self.class.fluidsynth_version; end
+
+  def self.fluidsynth_version_str
+    # ret = C.fluid_version_str()
+    ret = misc_version_str()
+    ret
+  end
+  def fluidsynth_version_str; self.class.fluidsynth_version_str; end
+
+
+end
+
+
+#### endof filename: misc/misc.rb

data/lib/fiddle_fluidsynth/misc.rb

@@ -0,0 +1,6 @@
+#
+#
+#
+require_relative "./misc/misc"
+
+#