fiddle_fluidsynth 0.0.1

data/lib/fiddle_fluidsynth/command_interface/handler.rb

@@ -0,0 +1,95 @@
+#
+# filename: fiddle-fluidstynth/command_interface/handler.rb
+#
+
+
+# References
+# - [API Reference](https://www.fluidsynth.org/api/modules.html)
+#
+class FiddleFluidSynth
+
+  # Handles text commands and reading of configuration files.
+  # ==== References
+  # - API References, Command Interface/[Command Handler](https://www.fluidsynth.org/api/group__command__handler.html)
+  # - [library fiddle](https://docs.ruby-lang.org/ja/latest/library/fiddle.html)
+  #
+
+  #
+  module C
+
+    # Lifecycle Functions.
+    #
+    #
+
+    # Create a new command handler.
+    extern 'fluid_cmd_handler_t* new_fluid_cmd_handler' +
+      '(fluid_synth_t*, fluid_midi_router_t*)'
+
+    # Create a new command handler.
+    extern 'fluid_cmd_handler_t* new_fluid_cmd_handler2' +
+      '(fluid_settings_t*, fluid_synth_t*,' +
+      ' fluid_midi_router_t*, fluid_player_t*)'
+
+    # Delete a command handler.
+    extern 'void delete_fluid_cmd_handler(fluid_cmd_handler_t*)'
+
+
+    # Functions.
+    #
+    #
+
+    # Process a string command.
+    # extern 'int fluid_command(void*, void*, int)'
+    extern 'int fluid_command(fluid_cmd_handler_t*, char*, fluid_ostream_t)'
+
+    # Execute shell commands in a file.
+    extern 'int fluid_source(fluid_cmd_handler_t*, char*)'
+
+
+  end
+end
+
+
+# Lifecycle Functions.
+#
+#
+class FiddleFluidSynth
+
+  def cmd_handler_new( synth=self.synth, router: )
+    ret = C.new_fluid_cmd_handler(synth, router)
+    ret
+  end
+
+  def cmd_handler_new2( settings=self.settings,
+                        synth: , router: , player: )
+    ret = C.new_fluid_cmd_handler2(settings, synth, router, player)
+    ret
+  end
+
+  def cmd_handler_delete( cmd_handler )
+    ret = C.delete_fluid_cmd_handler(cmd_handler)
+    ret
+  end
+
+end
+
+
+# Functions.
+#
+#
+class FiddleFluidSynth
+
+  def cmd_command( handler, cmd, out )
+    ret = C.fluid_command(handler, cmd, out)
+    ret
+  end
+
+  def cmd_source( handler, filename )
+    ret = C.fluid_source(handler, filename)
+    ret
+  end
+
+end
+
+
+#### endof filename: fiddle-fluidstynth/command_interface/handler.rb

data/lib/fiddle_fluidsynth/command_interface/server.rb

@@ -0,0 +1,79 @@
+#
+# filename: fiddle-fluidstynth/command_interface/server.rb
+#
+
+
+# References
+# - [API Reference](https://www.fluidsynth.org/api/modules.html)
+#
+class FiddleFluidSynth
+
+  # TCP socket server for a command handler.
+  # ==== References
+  # - API References, Command Interface/[Command Server](https://www.fluidsynth.org/api/group__command__server.html)
+  # - [library fiddle](https://docs.ruby-lang.org/ja/latest/library/fiddle.html)
+  #
+
+  #
+  module C
+
+    # Lifecycle Functions.
+    #
+    #
+
+    # Create a new TCP/IP command shell server.
+    extern 'fluid_server_t* new_fluid_server' +
+      '(fluid_settings_t*, fluid_synth_t*, fluid_midi_router_t*)'
+
+    # Create a new TCP/IP command shell server.
+    extern 'fluid_server_t* new_fluid_server2' +
+      '(fluid_settings_t*, fluid_synth_t*,' +
+      ' fluid_midi_router_t*, fluid_player_t*)'
+
+    # Delete a TCP/IP shell server.
+    extern 'void delete_fluid_server(fluid_server_t*)'
+
+    # Join a shell server thread (wait until it quits).
+    extern 'int fluid_server_join(fluid_server_t*)'
+
+
+    # Functions.
+    #
+    #
+
+    # nothing.
+
+  end
+end
+
+
+# Lifecycle Functions.
+#
+#
+class FiddleFluidSynth
+
+  def server_new( settings: , synth: , router: )
+    ret = C.new_fluid_server(synth, router)
+    ret
+  end
+
+  def server_new2( settings: , synth: , router: , player: )
+    ret = C.new_fluid_server2(settings, synth, router, player)
+    ret
+  end
+
+  def server_delete( server )
+    ret = C.delete_fluid_server(server)
+    ret
+  end
+
+  def server_join( server )
+    ret = C.fluid_server_join(server)
+    ret
+  end
+
+
+end
+
+
+#### endof filename: fiddle-fluidstynth/command_interface/server.rb

data/lib/fiddle_fluidsynth/command_interface/shell.rb

@@ -0,0 +1,76 @@
+#
+# filename: fiddle-fluidstynth/command_interface/shell.rb
+#
+
+
+# References
+# - [API Reference](https://www.fluidsynth.org/api/modules.html)
+#
+class FiddleFluidSynth
+
+  # Interactive shell to control and configure a synthesizer instance.
+  # ==== References
+  # - API References, Command Interface/[Command Shell](https://www.fluidsynth.org/api/group__command__shell.html)
+  # - [library fiddle](https://docs.ruby-lang.org/ja/latest/library/fiddle.html)
+  #
+
+  #
+  module C
+
+    # Lifecycle Functions.
+    #
+    #
+
+    # Create a new FluidSynth command shell.
+    extern 'fluid_shell_t* new_fluid_shell' +
+      '(fluid_settings_t*, fluid_cmd_handler_t*,' +
+      ' fluid_istream_t, fluid_ostream_t, int)'
+
+    # A convenience function to create a shell interfacing to standard
+    # input/output console streams.
+    extern 'void fluid_usershell(fluid_settings_t*, fluid_cmd_handler_t*)'
+
+    # Delete a FluidSynth command shell.
+    extern 'void delete_fluid_shell(fluid_shell_t*)'
+
+    # Functions.
+    #
+    #
+
+    # nothing.
+
+
+  end
+end
+
+
+# Lifecycle Functions.
+#
+#
+class FiddleFluidSynth
+
+  # def cmd_shell_new( settings: , handler: , in: , out: , thread: )
+  def cmd_shell_new( settings=self.settings,
+                     handler: , instm: , outstm: , thread: )
+    ret = C.new_fluid_shell(settings, handler, instm, outstm, thread)
+    ret
+  end
+
+  def cmd_usershell( settings=self.settings, handler: )
+    ret = C.fluid_usershell(settings, handler)
+    ret
+  end
+
+  def cmd_shell_delete( shell )
+    ret = C.delete_fluid_shell(shell)
+    ret
+  end
+
+end
+
+# Functions.
+#
+#
+
+
+#### endof filename: fiddle-fluidstynth/command_interface/shell.rb

data/lib/fiddle_fluidsynth/command_interface.rb

@@ -0,0 +1,9 @@
+#
+# filename: fiddle-fluidsynth/command_interface/command_interface.rb
+#
+require_relative "./command_interface/command_interface"
+require_relative "./command_interface/handler"
+require_relative "./command_interface/server"
+require_relative "./command_interface/shell"
+
+#### endof filename: fiddle-fluidsynth/command_interface/command_interface.rb

data/lib/fiddle_fluidsynth/core_ext/fiddle.rb

@@ -0,0 +1,142 @@
+#
+#
+#
+require 'fiddle'
+
+# `'-'*Fiddle::SIZEOF_INT` is bad when string is frozen literal.
+# So we introduce this Fiddle helper.
+#
+
+#
+#
+#
+def Fiddle.SIZEOF_INT
+  Fiddle::SIZEOF_INT
+end
+def Fiddle.sizeof_int
+  self.SIZEOF_INT()
+end
+
+def Fiddle.SIZEOF_DOUBLE
+  Fiddle::SIZEOF_DOUBLE
+end
+def Fiddle.sizeof_dbl
+  self.SIZEOF_DOUBLE()
+end
+
+def Fiddle.SIZEOF_FLOAT
+  Fiddle::SIZEOF_FLOAT
+end
+def Fiddle.sizeof_flt
+  self.SIZEOF_FLOAT()
+end
+
+def Fiddle.SIZEOF_VOIDP
+  Fiddle::SIZEOF_VOIDP
+end
+def Fiddle.sizeof_voidp
+  self.SIZEOF_VOIDP()
+end
+
+
+#
+class Fiddle::Pointer
+  def self.malloc_n( sz: )
+    Fiddle::Pointer.malloc(sz)
+  end
+
+  #
+  def self.malloc_int
+    self.malloc_n(sz: Fiddle.sizeof_int)
+  end
+  def self.malloc_i; self.malloc_int; end
+
+  #
+  def self.malloc_dbl
+    self.malloc_n(sz: Fiddle.sizeof_dbl)
+  end
+
+  #
+  def self.malloc_flt
+    self.malloc_n(sz: Fiddle.sizeof_flt)
+  end
+
+  #
+  def self.malloc_voidp
+    self.malloc_n(sz: Fiddle.sizeof_voidp)
+  end
+
+  #
+  def self.malloc_char_ptr2( str_ary )
+    ary_size = str_ary.size
+    self.malloc_n(sz: Fiddle.sizeof_voidp*ary_size)
+  end
+
+end
+
+#
+class Fiddle::Pointer
+
+  def self.set_int(ptr, v)
+    ptr[0, Fiddle.sizeof_int] = [v].pack("i")
+  end
+
+  def self.set_dbl(ptr, v)
+    ptr[0, Fiddle.sizeof_dbl] = [v].pack("E")
+  end
+
+  def self.set_flt(ptr, v)
+    ptr[0, Fiddle.sizeof_flt] = [v].pack("f")
+  end
+
+  def self.set_voidp(ptr, v)
+    ptr[0, Fiddle.sizeof_voidp] = [v].pack("J")
+  end
+
+  def self.set_char_ptr2(ptr2, str_ary)
+    atr_ary.each_with_index do |str, index|
+      tmp_ptr = Fiddle::Pointer.malloc(str.bytesize + 1)
+      tmp_ptr[0, str.bytesize+1] = "#{str}\0"
+
+      ptr2[index*Fiddle.sizeof_voidp,
+           Fiddle.sizeof_voidp] = [tmp_ptr.to_i].pack("Q")
+    end
+
+    ptr2
+  end
+
+end
+
+
+#
+class Fiddle::Pointer
+  def self.unpack1( val: , fmt: )
+    val[0, val.size].unpack1(fmt)
+  end
+
+  #
+  def self.decode1_int( val )
+    self.unpack1(val: val, fmt: 'i')
+  end
+  def self.decode1_i(val); decode1_int(val); end
+  def decode1_int
+    self.class.decode1_i(self)
+  end
+  alias decode1_i decode1_int
+
+  #
+  def self.decode1_dbl( val )
+    self.unpack1(val: val, fmt: 'E')
+  end
+  def decode1_dbl
+    self.class.decode1_dbl(self)
+  end
+
+  #
+  def self.decode_char_ptr2( ptr2 )
+  end
+
+end
+
+
+####

data/lib/fiddle_fluidsynth/core_ext/module.rb

@@ -0,0 +1,123 @@
+#
+# filename: module.rb
+#
+
+#
+#
+#
+class Module
+
+  #
+  #
+  # ==== Example
+  # ```
+  # class Aclass
+  #   define_module(:Foo) do |mod|
+  #     mod.const_set(...)
+  #     :
+  #   end
+  # end
+  # ```
+  def define_module(name, &block)
+    # mod = Module.new(&block)
+    # const_set(name, mod)
+    unless const_defined?(name)
+      mod = Module.new
+      const_set(name, mod)
+    end
+
+    block.call(const_get(name))
+  end
+
+  # define enum constants and its module.
+  # ==== Args
+  # name:: name of the enumerator.
+  # debug_f:: debug mode.
+  # defs:: pairs of key and value of hash.
+  #
+  # ==== Example
+  # ```
+  # class AClass
+  #   enum(:fluid_t,
+  #     Foo: nil,
+  #     Bar: 5,
+  #     Car: nil,
+  #   )
+  # end
+  # puts "AClass::Car: #{AClass::Foo}" => 0
+  # puts AClass::Enum_fluid_t::Car =>6
+  # puts AClass.Enum_fluid_t =>{Foo: 0, Bar: 5, Car: 6,}
+  # ```
+  #
+
+  #
+  #
+  #
+  def enum( name = "", debug_f: false, **defs )
+    # preprocess.
+    if name.is_a? Hash
+      defs = name
+      name = ""
+    end
+
+    #
+    if !(defs[:debug_f].nil?)
+      debug_f = defs[:debug_f]
+      defs.delete(:debug_f)
+    else
+      # $stderr.puts "(**) {#{__method__}} no options."
+    end
+    $stderr.puts "(**) defs: #{defs}" if debug_f
+    $stderr.puts "(**) name: #{name}, debug_f: #{debug_f}," +
+      " defs: #{defs}" if debug_f
+
+    # create a module when name is specified.
+    m_name = ""
+    if name.to_s != ""
+      m_name = "Enum_#{name}"
+      define_module(m_name){|_mod| } unless const_defined?(m_name)
+    end
+
+    #
+    _cnt = 0
+    defs.each do |_k, _v|
+      #
+      raise "The head of `#{_k}' must be in Capital or you misspelled" +
+        " for an option...?" unless _k =~ /^[A-Z]/
+
+      #
+      if _v.is_a? Integer
+        puts "_k: #{_k} = #{_v}" if debug_f
+        const_set(_k, _v)
+        const_get(m_name).const_set(_k,_v) if m_name != ""
+
+        _cnt = _v
+      elsif _v.is_a? Symbol
+        __v = const_get(_v)
+        puts "_k: #{_k} = #{_v}, __v: #{__v}" if debug_f
+        const_set(_k, __v)
+        const_get(m_name).const_set(_k,__v) if m_name != ""
+
+        _cnt = __v
+      elsif _v.nil?
+        _v = _cnt
+        puts "_k: #{_k} = #{_v}" if debug_f
+        const_set(_k, _v)
+        const_get(m_name).const_set(_k,_v) if m_name != ""
+
+        defs[_k] = _v
+      else
+        raise "value:#{_v} must be an Integer."
+      end
+
+      _cnt += 1
+    end
+
+
+    defs
+  end
+
+end
+
+
+#### endof filename: module.rb

data/lib/fiddle_fluidsynth/fiddle_fluidsynth.rb

@@ -0,0 +1,172 @@
+#
+# filename: fiddle_fluidsynth/fiddle_fluidsynth.rb
+#
+
+#
+require 'fiddle/import'
+require 'rbconfig'
+
+
+# References
+# - fluidsynth.org, [API Reference](https://www.fluidsynth.org/api/modules.html)
+#
+class FiddleFluidSynth
+  module C
+    #
+    begin
+      lib_fluidsynth = self.full_path_for_lib('fluidsynth')
+      dlload lib_fluidsynth
+    rescue
+      raise LoadError, "Couldn't find the fluidsynth library."
+    end
+
+  end
+
+end
+
+
+#
+#
+# ==== References
+# - [Settings Reference](https://www.fluidsynth.org/api/fluidsettings.html)
+#
+#
+class FiddleFluidSynth
+
+  #
+  #
+  # ==== Args
+  # soundfont_name:: SoundFont file name. do NOT load when nil.
+  # reset_presets:: true then presets are updated immediately.
+  #
+  def initialize( soundfont_name: SOUNDFONT_NAME_DEFAULT,
+                  soundfont_path: self.obtain_soundfont_path,
+                  soundfont_full_path:
+                    "#{soundfont_path}/#{soundfont_name}",
+                  # gain:          0.2,
+                  # samplerate:    44100.0,
+                  # midi_channels: 256,
+                  gain:          nil,
+                  samplerate:    nil,
+                  midi_channels: nil,
+                  player_f:       true,
+                  audio_driver_f: true,
+                  audio_driver_name: nil,
+                  audio_driver_new2_f:   false,
+                  audio_driver_callback: nil,
+                  reset_presets: true )
+
+    ### prepare Settings.
+    @settings = self.settings_new
+    if self.settings.null?
+      $stderr.puts "(**) Failed to create settings."
+      self.delete
+      exit
+    end
+
+    # TODO. in args.?
+    #
+    #
+    self.settings.
+      synth_gain           = gain           unless gain.nil?
+    self.settings.
+      synth_sample__rate   = samplerate     unless samplerate.nil?
+    self.settings.
+      synth_midi__channels = midi_channels  unless midi_channels.nil?
+
+    ### prepare Synthesizer.
+    @synth  = self.synth_new(self.settings)
+    if self.synth.null?
+      $stderr.puts "(**) Failed to create synthesizer."
+      self.delete
+      exit
+    end
+
+    ### prepare SoundFont.
+    @soundfont_full_path = soundfont_full_path
+    @reset_presets       = reset_presets
+    @sfid_ary = []      # set in sfont_sfload().
+    @sfid_latest = nil
+
+    #
+    unless soundfont_name.to_s == ""
+      tmp = self.synth_sfload(synth, filename: @soundfont_full_path,
+                              reset_presets: @reset_presets,
+                              verbose_f: true)
+      if FLUID_FAILED == tmp
+        $stderr.puts "(**) Failed to load the SoundFont."
+        self.delete
+        exit
+      end
+    else
+      $stderr.puts "(**) SoundFont has NOT been loaded in the initializer."
+    end
+
+    ### prepare Player.
+    @player = nil
+    if player_f
+      @player = self.player_new(self.synth)
+      if self.player.null?
+        $stderr.puts "(**) Failed to create player."
+        self.delete
+        exit
+      end
+    end
+
+    ### prepare Audio Driver.
+    @audio_driver = nil
+    # self.audio_driver_prepare(
+    #   audio_driver_name, settings: self.settings, synth: self.synth,
+    #   new2_f: audio_driver_new2_f
+    # )
+    # if self.audio_driver.null?
+    #   $stderr.puts "(**) Failed to prepare audio driver."
+    #   self.delete
+    #   exit
+    # end
+    if audio_driver_f
+      self.audio_driver_prepare(
+        audio_driver_name,
+        settings: self.settings, synth: self.synth,
+        new2_f: audio_driver_new2_f, cb_ptr: audio_driver_callback)
+
+    else
+      $stderr.puts "(**) Do prepare audio driver."
+    end
+    @file_renderer = nil
+
+    ### create module hierarchy.
+    self.init_objects(self)
+
+  end
+  attr_reader :settings, :synth, :player
+  attr_reader :audio_driver
+  attr_reader :file_renderer
+
+  attr_reader :soundfont_full_path, :reset_preset
+  # attr_reader :sfid, :sfid_latest
+  attr_reader :sfid_ary, :sfid_latest
+
+end
+
+
+#
+#
+#
+class FiddleFluidSynth
+
+  def delete
+    self.audio_driver_delete(self.audio_driver) if self.audio_driver &&
+                                                     !(self.audio_driver.null?)
+    self.player_delete(self.player)     if self.player &&
+                                             !(self.player.null?)
+    self.synth_delete(self.synth)       if self.synth &&
+                                             !(self.synth.null?)
+    self.settings_delete(self.settings) if self.settings &&
+                                             !(self.settings.null?)
+  end
+
+end
+
+
+#### endof filename: fiddle_fluidsynth/iddle_fluidsynth.rb