fiddle_fluidsynth 0.0.1

data/examples/ffs_fx.rb

@@ -0,0 +1,200 @@
+#!/usr/bin/env ruby
+#
+#
+
+# Original comments:
+# FluidSynth FX - An example of using effects with fluidsynth
+#
+# This code is in the public domain.
+#
+# To compile:
+#   gcc -g -O -o fluidsynth_fx fluidsynth_fx.c -lfluidsynth
+#
+# To run
+#   fluidsynth_fx soundfont gain
+#
+# [Peter Hanappe]
+#
+
+# fiddle_fluidsynth comments:
+# `ffs_fx.rb` is fiddle_fluidsynth version of `fluidsynth_fx.c`.
+# This code is also in the public domain.
+#
+# [YAMAMOTO, Masayuki]
+
+#
+require_relative "../lib/fiddle_fluidsynth"
+#require "fiddle_fluidsynth"
+
+
+#
+# if ARGV.size != 2
+unless (1..2).cover? ARGV.size
+  $stderr.puts "ARGV (#{ARGV.size}): #{ARGV}"
+  $stderr.puts "#{__FILE__} [SOUNDFONT] <GAIN>"
+  exit 1
+end
+opt_idx = 0
+$stderr.puts "ARGV (#{ARGV.size}): #{ARGV}"
+if File.exist? ARGV[opt_idx]
+  opt_idx += 1
+end
+gain = ARGV[opt_idx].to_f
+
+
+# Original comments:
+# This function implements the callback function of the audio driver
+# (see new_fluid_audio_driver2 below). The data argument is a pointer
+# to your private data structure. 'len' is the number of audio frames
+# in the buffers. 'nfx' and 'nout' are the number of input and output
+# audio buffers. 'fx' and 'out' are arrays of float buffers containing
+# the audio. The audio driver fills zero-initializes those buffers.
+# You are responsible for filling up those buffers, as the result will
+# be sent to the sound card. This is usually done by asking the synth
+# to fill those buffers appropriately using fluid_synth_process()
+#
+# NOTE: The API was designed to be generic. Audio driver may fill the
+# buffers with audio input from the soundcard, rather than zeros.
+FFS = FiddleFluidSynth
+fs  = nil  # define later (FFS instance).
+cb_ptr = FFS.define_audio_func{|data, len, nfx, fx, nout, outbuf|
+
+  # FiddleFluidSynth comments:
+  # BE CAREFUL! all variables in the arguments (esp. the pointers)
+  # are in FFI, not in Fiddle!!!
+  #
+
+  usr_data = data
+  # $stderr.puts "gain: #{gain}"
+
+  #
+  $stderr.puts "len: #{len}, nfx: #{nfx}, fx: #{fx.inspect}," +
+    " nout: #{nout}, outbuf: #{outbuf.inspect}"
+
+  if fx.null?
+    # Original comments:
+    # Note that some audio drivers may not provide buffers for effects like
+    # reverb and chorus. In this case it's your decision what to do. If you
+    # had called fluid_synth_process() like in the else branch below, no
+    # effects would have been rendered. Instead, you may mix the effects
+    # directly into the out buffers.
+
+    $stderr.puts "fx is nil."
+    $stderr.puts "#audio_channels: #{fs.synth_count_audio_channels(fs.synth)}"
+    $stderr.puts "#audio_groups:   #{fs.synth_count_audio_groups(fs.synth)}"
+    $stderr.puts "#effects_groups: #{fs.synth_count_effects_groups(fs.synth)}"
+
+    fx_ptr     = Fiddle::Pointer.new(fx.address)
+    outbuf_ptr = Fiddle::Pointer.new(outbuf.address)
+    if fs.synth_process(fs.synth, len: len,
+        nfx: nfx, fx: fx_ptr, nout: nout, outbuf: outbuf_ptr) != 
+        FiddleFluidSynth::FLUID_OK
+      $stderr.puts "(1) synth_process() is failed."
+      return FiddleFluidSynth::FLUID_FAILED
+    else
+      $stderr.puts "(1) synth_process() is succeeded."
+    end
+  else
+    # Original comments:
+    # Call the synthesizer to fill the output buffers with its
+    # audio output.
+
+    # FiddleFluidSynth comments:
+    # FiddleFluidSynth#synth_process() is wrapped by Fiddle, so we have to
+    # use Fiddle::Pointer instead of FFI::Pointer...
+    #
+
+    #
+    fx_ptr     = Fiddle::Pointer.new(fx.address)
+    outbuf_ptr = Fiddle::Pointer.new(outbuf.address)
+    if fs.synth_process(fs.synth, len: len,
+        nfx: nfx, fx: fx_ptr, nout: nout, outbuf: outbuf_ptr) != 
+        FiddleFluidSynth::FLUID_OK
+      $stderr.puts "(2) synth_process() is failed."
+      return FiddleFluidSynth::FLUID_FAILED
+    else
+      $stderr.puts "(2) synth_process() is succeeded."
+    end
+  end
+
+  #
+  # $stderr.puts "effector: start."
+  ptr_size   = FFI.type_size(:pointer)
+  float_size = FFI.type_size(:float)
+  # raise SyntaxError, "test."
+
+  out_ptr = outbuf
+  fx_ptr  = fx
+
+  # Original comments:
+  # Apply your effects here. In this example, the gain is
+  # applied to all the dry-audio output buffers.
+
+  # for outbuf.
+  # $stderr.puts "effector: out."
+  nout.times do |_i|
+    ch_ptr = out_ptr.get_pointer(_i * ptr_size)
+
+    len.times do |_j|
+      v  = ch_ptr.get_float(_j * float_size)
+      nv = v*gain
+      ch_ptr.put_float(_j*float_size, nv)
+      # $stderr.puts "#{_j}: #{v} =>#{nv} (gain: #{gain})"
+    end
+  end
+
+
+  # Original comments:
+  # Apply the same effect to all available effect buffer.
+  #
+
+  # for fx.
+  # $stderr.puts "effector: fx."
+  nfx.times do |_i|
+    ch_ptr = fx_ptr.get_pointer(_i * ptr_size)
+
+    len.times do |_j|
+      v = ch_ptr.get_float(_j * float_size)
+      ch_ptr.put_float(_j*float_size, v*gain)
+    end
+  end
+
+  #return FiddleFluidSynth::FLUID_OK  # LongJumpError.
+  FiddleFluidSynth::FLUID_OK
+}
+
+
+# Original comments:
+# Create the audio driver. As soon as the audio driver is
+# created, the synthesizer can be played.
+
+# FiddleFluidSynth comments:
+# Create the audio driver in the initializer of FFS.
+#
+fs = if ARGV.size == 2
+       FiddleFluidSynth.new(
+         soundfont_full_path: ARGV[0],
+         player_f: false,
+         # audio_driver_new2_f: true,
+         audio_driver_callback: cb_ptr)
+     else
+       FiddleFluidSynth.new(
+         player_f: false,
+         audio_driver_callback: cb_ptr)
+     end
+
+# Original comments:
+# play a note.
+#
+fs.noteon(0, 60, 100)
+
+#
+print 'Press "Enter" to stop: '
+$stdin.getc
+fs.raise_error_in_callback
+puts "done."
+
+#
+fs.delete
+
+#### end.

data/examples/ffs_metronome.rb

@@ -0,0 +1,260 @@
+#!/usr/bin/env ruby
+#
+#
+
+# Original comments:
+# FluidSynth Metronome - Sequencer API example
+#
+# This code is in the public domain.
+#
+# To compile:
+#   gcc -o fluidsynth_metronome -lfluidsynth fluidsynth_metronome.c
+#
+# To run:
+#   fluidsynth_metronome soundfont [beats [tempo]]
+#
+# [Pedro Lopez-Cabanillas <plcl@users.sf.net>]
+
+# fiddle_fluidsynth comments:
+# `ffs_metronome.rb` is FiddleFluidSynth version of `fluidsynth_metronome.c`.
+# This code is also in the public domain.
+#
+# [YAMAMOTO, Masayuki, ]
+
+#
+require_relative '../lib/fiddle_fluidsynth'
+# require 'fiddle_fluidsynth'
+
+
+#
+# @audiodriver = nil
+@seq   = nil
+
+#
+@synth_dest, @client_dest = nil, nil
+@time_marker = nil
+
+# default tempo, beats per minute.
+TEMPO = 120
+tempo = TEMPO
+@note_duration = 60000 / TEMPO
+
+# metronome click/bell.
+@weak_note   = 33   # click sound.
+@strong_note = 34   # click+bell sound.
+
+# number of notes in one pattern (beats).
+@pattern_size = 4
+
+
+# schedule a note on message.
+#
+#
+FFS = FiddleFluidSynth
+def schedule_noteon( ch, key, ticks )
+
+  # ev = FFS.event_new
+  # ev.set_type(:noteon, ch: ch, key: key, vel: 127)
+  # :
+  # FFS.event_delete(ev)
+  FFS.seq_event(:noteon, ch: ch, key: key, vel: 127){|ev|
+    ev.source = -1
+    ev.dest   = @synth_dest
+
+    #
+    if @seq.send_at(event: ev, time: ticks, absolute: 1) == \
+        FFS::FLUID_FAILED
+      $stderr.puts "(**) {#{__method__}} seq. send_at() failed."
+    end
+    # if FFS::FLUID_FAILED == _tmp
+    #   $stderr.puts "(**) {#{__method__}} seq. send_at() failed (#{_tmp})."
+    # else
+    #   $stderr.puts "(**) {#{__method__}} seq. send_at() succeeded (#{_tmp})."
+    # end
+  }
+
+end
+
+
+# schedule a timer event (shall trigger the callback).
+#
+#
+def schedule_timer_event
+
+  # $stderr.puts "{#{__method__}} Scheduling timer event at #{@time_marker}"
+  # $stderr.puts "  Current tick: #{@seq.tick}"
+
+  #ev = FFS.event_new
+  # FFS.event_set_src(ev, src: -1)
+  # FFS.event_set_dest(ev, dest: @client_dest)
+  # FFS.event_timer(ev, data: nil)
+  #ev.set_type(:timer, data: nil)
+  # :
+  #FFS.event_delete(ev)
+  FFS.seq_event(:timer, data: nil){|ev|
+    ev.source = -1
+    ev.dest   = @client_dest
+    # $stderr.puts "{#{__method__}} set as a timer event for #{ev.inspect}"
+
+    if @seq.send_at(event: ev, time: @time_marker, absolute: 1) == \
+        FFS::FLUID_FAILED
+      $stderr.puts "(**) {#{__method__}} seq. send_at() failed."
+    end
+    # if FFS::FLUID_FAILED == _tmp
+    #   $stderr.puts "(**) {#{__method__}} seq. send_at() failed (#{_tmp})."
+    # else
+    #   $stderr.puts "(**) {#{__method__}} seq. send_at() succeeded (#{_tmp})."
+    # end
+  }
+
+end
+
+
+# schedule the metronome pattern.
+#
+#
+def schedule_pattern
+  # $stderr.puts "{#{__method__}} Scheduling pattern events at #{@time_marker}"
+  # $stderr.puts "  Current tick: #{@seq.tick}"
+
+  #
+  note_time = @time_marker
+
+  #
+  # @pattern_size.times do |_i|
+  (0...@pattern_size).each do |_i|
+    # 0 is also true in Ruby... so we have to change the logic.
+    _note = !(_i.zero?) ? @weak_note : @strong_note
+    $stderr.puts "  #{_note}, scheduled at note_time: #{note_time}" if \
+      ARGV.size == 4
+
+    schedule_noteon(9, _note, note_time)
+    note_time += @note_duration
+  end
+
+  @time_marker = note_time
+  # $stderr.puts "{#{__method__}} Next time marker: #{@time_marker}"
+end
+
+#
+@seq_cb_ptr = FFS.define_event_callback{|time, ev, seq, data|
+  # $stderr.puts "{#{Time.now}} on callback."
+  schedule_timer_event()
+  schedule_pattern()
+}
+
+#
+def usage( prog_name = __FILE__ )
+  puts "Usage: #{prog_name} [soundfont] [beats [tempo]]"
+  puts "   or  #{prog_name} -h"
+  puts "\tsoundfont [optional]: soundfont file name (in full path)," +
+    " default #{FFS.obtain_full_path_for_soundfont}."
+  puts "\tbeats [optional]:     number of pattern beats, default #{@pattern_size}"
+  puts "\ttempo [optional]:     BPM (Beats Per Minute), default #{TEMPO}"
+end
+
+
+### main.
+
+if ARGV[0] == '-h' || ARGV[0] == '--help'
+  usage()
+  exit 1
+end
+
+#
+opt_idx = 0
+fs =  if File.exist?("#{ARGV[opt_idx]}")
+        tmp = FiddleFluidSynth.new(
+                soundfont_full_path: "#{ARGV[opt_idx]}", player_f: false)
+        opt_idx += 1
+        $stderr.puts "(1) opt_idx: #{opt_idx}"
+        tmp
+      else
+        $stderr.puts "(2) opt_idx: #{opt_idx}"
+        FiddleFluidSynth.new(player_f: false)
+      end
+$stderr.puts "opt_idx: #{opt_idx}"
+
+#
+# @seq   = fs.sequencer_new2(0)
+@seq   = fs.sequencer_new2
+if @seq.null?
+  raise "Cannot prepare the sequencer!"
+end
+puts "seq. clients: #{@seq.count_clients}"
+
+
+# register the synthesizer (automatically destination)
+# to the sequencer.
+#
+@synth_dest  = @seq.register_fluidsynth(fs.synth)
+if FFS::FLUID_FAILED == @synth_dest
+  raise "Client (synth) registsteration failed."
+end
+puts "seq_id: #{@synth_dest}, seq. clients: #{@seq.count_clients}"
+
+
+# register the sequencer client.
+#
+#
+@client_dest = @seq.register_client(
+                 name: 'ffs_metronome',
+                 event_callback: @seq_cb_ptr, data: nil)
+if FFS::FLUID_FAILED == @client_dest
+  raise "Client registsteration failed."
+end
+puts "seq_id: #{@client_dest}, seq. clients: #{@seq.count_clients}"
+
+
+# If we prepare the audio driver twice, note_duration become half.
+# I dont know why...
+#
+# @audiodriver = fs.audio_driver_prepare
+
+#
+#if ARGV.size >= 2 && ARGV[opt_idx]
+if ARGV.size >= 1 && ARGV[opt_idx]
+  $stderr.puts "(**) beats setting (#ARGV: #{ARGV.size}, opt_idx: #{opt_idx})."
+  beats = ARGV[opt_idx].to_i
+  opt_idx += 1
+  $stderr.puts "(**) beats is set to: #{beats}."
+  @pattern_size = beats if beats > 0
+end
+
+#
+if ARGV.size >= 2 && ARGV[opt_idx]
+  $stderr.puts "(**) tempo setting (#ARGV: #{ARGV.size}, opt_idx: #{opt_idx})."
+  tempo = ARGV[opt_idx].to_i
+  opt_idx += 1
+  @note_duration = 60000/tempo if tempo > 0
+  $stderr.puts "(**) tempo is set to #{tempo}."
+end
+
+# get the current time in ticks.
+#
+#
+# @time_marker = fs.sequencer_get_tick(@seq)
+@time_marker = @seq.tick
+
+# schedule patterns.
+schedule_pattern()
+schedule_timer_event()
+schedule_pattern()
+
+# wait for user input.
+#
+#
+puts "beats: #{@pattern_size}/tempo: #{tempo}" +
+  " =>note_duration: #{@note_duration} [ms]"
+print 'Press "Enter" to stop: '
+$stdin.getc
+fs.raise_error_in_callback
+puts "done."
+
+#
+puts "Cleaning up..."
+fs.delete
+puts "fs.deleted."
+
+puts "Done. Exiting program."
+#### end.

data/examples/ffs_midiplay.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+#
+#
+#
+
+# ffs_midiplay.rb  - fiddle_fluidsynth MIDI file player (tick callback
+# example).
+# This code is in the public domain.
+#
+# [YAMAMOTO, Masayuki]
+#
+
+#
+require_relative '../lib/fiddle_fluidsynth'
+#require 'fiddle_fluidsynth'
+
+
+#
+DEFAULT_SF2_NAME = "default.sf2"
+f_1 = ARGV[0]
+f_2 = ARGV[1]
+
+f_midi = f_2 || f_1
+f_sf2  = (f_2.nil?)? DEFAULT_SF2_NAME : f_1
+puts "SoundFont: #{f_sf2}, MIDI file #{f_midi}"
+
+if f_midi.nil?
+  $stderr.puts "Help: #{File.basename(__FILE__)} [SoundFont] MIDI-file"
+  raise "Specify a MIDI file you want to play at least."
+end
+
+#
+#
+#
+fs = if File.exist?(f_sf2)
+       FiddleFluidSynth.new(soundfont_full_path: f_sf2)
+     else
+       FiddleFluidSynth.new(soundfont_name: f_sf2)
+     end
+fs.start
+
+#
+#
+#
+is_midi = fs.is_midifile(f_midi)
+raise "MIDI file is strange (#{is_midi}): #{f_midi}" \
+  unless fs.is_midifile?(f_midi)
+
+ver_s   = fs.fluidsynth_version_str
+ver_ary = fs.fluidsynth_version
+
+puts "MIDI file (#{is_midi}): #{f_midi}"
+puts "fluidsynth version_str: #{ver_s} (by version: #{ver_ary})"
+puts
+
+#
+#
+#
+fs.player_file(f_midi)
+time_start = Time.now
+puts "#{time_start}: Playing #{f_midi}"
+
+
+#
+# we can pass user_data via handler_data as follows, but this is completely
+# meaningless in FiddleFluidSynth.
+#
+# because we use the closure to define the callback function, i.e.,
+# we can use any variables in the callback freely.
+#
+# ```
+# str_ptr = FFI::MemoryPointer.from_string("this is a test.")
+# fdl_ptr = Fiddle::Pointer.new(str_ptr.address)
+#
+# fs.player_set_tick_callback(handler_data: fdl_ptr_ary){|user_data, cur_tick|
+#    :
+#    puts "#{user_data}/#{user_data.read_string}"  # user_data is FFI::Pointer.
+#    :
+# }
+# ```
+#
+fs.player_set_tick_callback{|user_data, cur_tick|
+  #
+  total_ticks = fs.player_get_total_ticks
+
+  #
+  status = fs.player_status
+  bpm    = fs.player_bpm
+
+  #
+  # puts "#{user_data}/#{user_data.address}"
+  # puts "#{user_data}/#{user_data.read_string}"
+  puts "#{Time.now}: player status: #{status}/bpm: #{bpm}"
+
+  #
+  if cur_tick <= total_ticks
+    puts "Tick: %4d / %4d" % [cur_tick, total_ticks]
+  else
+    puts "(**) All events in the MIDI file are executed" +
+      " (Tick: %4d / %4d)" % [cur_tick, total_ticks]
+  end
+}
+
+
+#
+#
+#
+until fs.player_is_done?
+  sleep(1.0)
+end
+
+
+#
+#
+#
+fs.raise_error_in_callback
+fs.delete
+time_end = Time.now
+puts "#{time_end}: Finished (in #{time_end-time_start} [sec])."
+
+
+#### end.

data/examples/ffs_simple.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+#
+#
+#
+
+# Original comments:
+# FluidSynth Simple - An example of using fluidsynth
+#
+# This code is in the public domain.
+#
+# To compile:
+#   gcc -g -O -o fluidsynth_simple fluidsynth_simple.c -lfluidsynth
+#
+# To run
+#   fluidsynth_simple soundfont
+#
+# [Peter Hanappe]
+#
+#
+
+
+# `ffs_simple.rb` is the fiddle_fluidsynth version of `fluidsynth_simple.c`
+# This code is in the public domain.
+#
+# [YAMAMOTO, Masayuki]
+
+#
+require_relative '../lib/fiddle_fluidsynth'
+#require 'fiddle_fluidsynth'
+
+#
+fs = FiddleFluidSynth.new(player_f: false)
+
+#
+fs.noteon(0, 60, 100)
+print 'Press "Enter" to stop: '
+$stdin.getc
+puts "done."
+
+
+fs.raise_error_in_callback
+fs.delete
+
+
+#### end.

data/examples/ffs_test1.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+#
+#
+
+# `ffs_test1.rb` is the fiddle_fluidsynth version of `test1.rb` in
+# ruby-fluidsynth.gem.
+#
+# This is from `ruby-fluidsynth.gem` by Daniel W. Steinbrook (2011).
+# (https://github.com/steinbro/ruby-fluidsynth)
+#
+
+require_relative '../lib/fiddle_fluidsynth'
+#require 'fiddle_fluidsynth'
+
+
+# fs = FiddleFluidSynth.new(soundfont_name: nil)
+fs = FiddleFluidSynth.new
+fs.start
+
+sfid = fs.synth_sfload(filename: "#{__dir__}/example.sf2", reset_presets: 0,
+                       verbose_f: true)
+fs.program_select(ch: 0, sfid: sfid, bknum: 0, prenum: 0)
+
+fs.noteon(0, 60, 30)
+fs.noteon(0, 67, 30)
+fs.noteon(0, 76, 30)
+
+sleep(1.0)
+
+fs.noteoff(0, 60)
+fs.noteoff(0, 67)
+fs.noteoff(0, 76)
+
+sleep(1.0)
+
+
+fs.raise_error_in_callback
+fs.delete
+
+
+#### end.

data/examples/ffs_test3.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+#
+#
+#
+
+# `ffs_test3.rb` is the fiddle_fluidsynth version of `test3.rb` in
+# ruby-fluidsynth.gem.
+#
+# This is from `ruby-fluidsynth.gem` by Daniel W.Steinbrook (2011).
+# (https://github.com/steinbro/ruby-fluidsynth)
+#
+
+#
+require_relative '../lib/fiddle_fluidsynth'
+#require 'fiddle_fluidsynth'
+
+
+#
+fs = FiddleFluidSynth.new(soundfont_name: nil)
+fs.start
+
+sfid = fs.synth_sfload(filename: "#{__dir__}/example.sf2", reset_presets: 0,
+                       verbose_f: true)
+sfont = fs.synth_get_sfont_by_id(id: sfid)
+sfont_name = fs.sfont_get_name(sfont)
+
+puts "sfont_name: #{sfont_name}"
+
+fs.program_select(ch: 0, sfid: sfid, bknum: 0, prenum: 0)
+
+fs.noteon(0, 60, 30)
+sleep(0.3)
+
+10.times do |i|
+  fs.cc(0, 93, 127)
+  fs.pitch_bend(0, i * 512)
+  sleep(0.1)
+end
+
+fs.noteoff(0, 60)
+
+sleep(1.0)
+
+
+#
+fs.raise_error_in_callback
+fs.delete
+
+
+#### end.