Add minim examples

Author: monkstone

external_library/java/minim/adsr_example.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'picrate'
+
+# ADSRExample is an example of using the ADSR envelope within an instrument.
+# For more information about Minim and additional features,
+# visit http://code.compartmental.net/minim/
+# author: Anderson Mills<br/>
+# Anderson Mills's work was supported by numediart (www.numediart.org)
+class ADSRExample < Processing::App
+  load_libraries :minim, :tone_instrument
+  java_import 'ddf.minim.Minim'
+
+  attr_reader :out
+
+  def setup
+    sketch_title 'ADSR Example'
+    minim = Minim.new(self)
+    @out = minim.get_line_out(Minim::MONO, 2048)
+    # pause time when adding a bunch of notes at once
+    out.pause_notes
+    # make four repetitions of the same pattern
+    4.times do |i|
+      # add some low notes
+      out.play_note(1.25 + i * 2.0, 0.3, ToneInstrument.new(out, 75, 0.49))
+      out.play_note(2.50 + i * 2.0, 0.3, ToneInstrument.new(out, 75, 0.49))
+
+      # add some middle notes
+      out.play_note(1.75 + i * 2.0, 0.3, ToneInstrument.new(out, 175, 0.4))
+      out.play_note(2.75 + i * 2.0, 0.3, ToneInstrument.new(out, 175, 0.4))
+
+      # add some high notes
+      out.play_note(1.25 + i * 2.0, 0.3, ToneInstrument.new(out, 3750, 0.07))
+      out.play_note(1.5 + i * 2.0, 0.3, ToneInstrument.new(out, 1750, 0.02))
+      out.play_note(1.75 + i * 2.0, 0.3, ToneInstrument.new(out, 3750, 0.07))
+      out.play_note(2.0 + i * 2.0, 0.3, ToneInstrument.new(out, 1750, 0.02))
+      out.play_note(2.25 + i * 2.0, 0.3, ToneInstrument.new(out, 3750, 0.07))
+      out.play_note(2.5 + i * 2.0, 0.3, ToneInstrument.new(out, 5550, 0.09))
+      out.play_note(2.75 + i * 2.0, 0.3, ToneInstrument.new(out, 3750, 0.07))
+    end
+    # resume time after a bunch of notes are added at once
+    out.resumeNotes
+  end
+
+  # draw is run many times
+  def draw
+    # erase the window to black
+    background(0)
+    # draw using a white stroke
+    stroke(255)
+    # draw the waveforms
+    (0...(out.bufferSize - 1)).each do |i|
+      # find the x position of each buffer value
+      x1  =  map1d(i, 0..out.bufferSize, 0..width)
+      x2  =  map1d(i + 1, 0..out.bufferSize, 0..width)
+      # draw a line from one buffer position to the next for both channels
+      line(x1, 50 + out.left.get(i) * 50, x2, 50 + out.left.get(i + 1) * 50)
+      line(x1, 150 + out.right.get(i) * 50, x2, 150 + out.right.get(i + 1) * 50)
+    end
+  end
+
+  def settings
+    size(512, 200, P2D)
+  end
+end
+
+ADSRExample.new

external_library/java/minim/create_instrument.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'picrate'
+# This sketch demonstrates how to create synthesized sound with Minim
+# using an AudioOutput and an Instrument we define. By using the
+# playNote method you can schedule notes to played at some point in the
+# future, essentially allowing to you create musical scores with code.
+# Because they are constructed with code, they can be either
+# deterministic or different every time. This sketch creates a
+# deterministic score, meaning it is the same every time you run the
+# sketch. For more complex examples of using playNote check out
+# algorithmicCompExample and compositionExample. For more information
+# about Minim and additional features, visit
+# http://code.compartmental.net/minim/
+class CreateInstrument < Processing::App
+  load_libraries :minim, :sine_instrument
+  java_import 'ddf.minim.Minim'
+
+  attr_reader :out
+
+  def settings
+    size(512, 200, P2D)
+  end
+
+  def setup
+    sketch_title 'Create Instrument'
+    minim = Minim.new(self)
+    @out = minim.getLineOut
+    # when providing an Instrument, we always specify start time and duration
+    out.playNote(0.0, 0.9, SineInstrument.new(97.99))
+    out.playNote(1.0, 0.9, SineInstrument.new(123.47))
+    # we can use the Frequency class to create frequencies from pitch names
+    out.playNote(2.0, 2.9, SineInstrument.new(Frequency.ofPitch('C3').asHz))
+    out.playNote(3.0, 1.9, SineInstrument.new(Frequency.ofPitch('E3').asHz))
+    out.playNote(4.0, 0.9, SineInstrument.new(Frequency.ofPitch('G3').asHz))
+  end
+
+  def draw
+    background(0)
+    stroke(255)
+    # draw the waveforms
+    (out.bufferSize - 1).times do |i|
+      line(i, 50 + out.left.get(i) * 50, i + 1, 50 + out.left.get(i + 1) * 50)
+      line(i, 150 + out.right.get(i) * 50, i + 1, 150 + out.right.get(i + 1) * 50)
+    end
+  end
+end
+
+CreateInstrument.new

external_library/java/minim/data/BD.mp3

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+java_import 'ddf.minim.Minim'
+
+%w[Frequency Instrument Line Oscil Waves].each do |klass|
+  java_import "ddf.minim.ugens.#{klass}"
+end
+
+# to make an Instrument we must define a class
+# that includes Instrument interface (as a module).
+class SineInstrument
+  include Instrument
+  include Processing::Proxy
+
+  attr_reader :wave, :amp_env
+
+  def initialize(frequency)
+    # make a sine wave oscillator
+    # the amplitude is zero because
+    # we are going to patch a Line to it anyway
+    @wave = Oscil.new(frequency, 0, Waves::SINE)
+    @amp_env = Line.new
+    amp_env.patch(wave.amplitude)
+  end
+
+  # this is called by the sequencer when this instrument
+  # should start making sound. the duration is expressed in seconds.
+  def noteOn(duration)
+    # start the amplitude envelope
+    amp_env.activate(duration, 0.5, 0)
+    # attach the oscil to the output so it makes sound
+    wave.patch(out)
+  end
+
+  # this is called by the sequencer when the instrument should
+  # stop making sound
+  def noteOff
+    wave.unpatch(out)
+  end
+end

external_library/java/minim/data/SD.wav

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# java_import 'ddf.minim.Minim'
+
+%w[ADSR Instrument Oscil Waves].each do |klass|
+  java_import "ddf.minim.ugens.#{klass}"
+end
+
+# Every instrument must implement the Instrument interface so
+# playNote can call the instrument's methods.
+class ToneInstrument
+  include Instrument
+  attr_reader :adsr, :out
+
+  # constructor for this instrument NB: includes line_out
+  def initialize(out, frequency, amplitude)
+    # create new instances of any UGen objects as necessary
+    sineOsc = Oscil.new(frequency, amplitude, Waves::TRIANGLE)
+    @adsr = ADSR.new(0.5, 0.01, 0.05, 0.5, 0.5)
+    @out = out
+    # patch everything together up to the final output
+    sineOsc.patch(adsr)
+  end
+
+  # every instrument must have a noteOn method
+  def noteOn(dur)
+    # turn on the ADSR
+    adsr.noteOn
+    # patch to the output
+    adsr.patch(out)
+   end
+
+  # every instrument must have a noteOff method
+  def noteOff
+    # tell the ADSR to unpatch after the release is finished
+    adsr.unpatchAfterRelease(out)
+    # call the noteOff
+    adsr.noteOff
+  end
+end

external_library/java/minim/data/groove.mp3

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'picrate'
+# This sketch demonstrates how to use the loop method of a Playable class.
+# The class used here is AudioPlayer, but you can also loop an AudioSnippet.
+# When you call loop() it will make the Playable playback in an infinite loop.
+# If you want to make it stop looping you can call play() and it will finish the
+# current loop and then stop. Press 'l' to start the player looping.
+class Loop < Processing::App
+  load_library :minim
+  java_import 'ddf.minim.Minim'
+
+  attr_reader :groove
+
+  def settings
+    size(512, 200, P2D)
+  end
+
+  def setup
+    minim = Minim.new(self)
+    @groove = minim.load_file(data_path('groove.mp3'), 2048)
+  end
+
+  def draw
+    background(0)
+    stroke(255)
+    (0...groove.buffer_size - 1).each do |i|
+      line(i, 50 + groove.left.get(i) * 50, i + 1, 50 + groove.left.get(i + 1) * 50)
+      line(i, 150 + groove.right.get(i) * 50, i + 1, 150 + groove.right.get(i + 1) * 50)
+    end
+  end
+
+  def key_pressed
+    return unless key == 'l'
+
+    groove.loop
+  end
+end
+
+Loop.new

external_library/java/minim/data/serif.vlw

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'picrate'
+
+# This sketch demonstrates how to play a file with Minim using an
+# AudioPlayer. It's also a good example of how to draw the waveform of
+# the audio. Full documentation for AudioPlayer can be found at
+# http://code.compartmental.net/minim/audioplayer_class_audioplayer.html
+# For more information about Minim and additional features,
+# visit http://code.compartmental.net/minim/
+class Player < Processing::App
+  load_library :minim
+  java_import 'ddf.minim.Minim'
+
+  PLAYING = 'Press any key to pause playback.'
+  NOT = 'Press any key to start playback.'
+  attr_reader :player
+
+  def settings
+    size(512, 200, P2D)
+  end
+
+  def setup
+    sketch_title 'Playing A File'
+    minim = Minim.new(self)
+    @player = minim.load_file(data_path('groove.mp3'))
+  end
+
+  def draw
+    background(0)
+    stroke(255)
+    (0...player.buffer_size - 1).each do |i|
+      x1 = map1d(i, 0..player.bufferSize, 0..width)
+      x2 = map1d(i + 1, 0..player.bufferSize, 0..width)
+      line(
+        x1,
+        50 + player.left.get(i) * 50,
+        x2,
+        50 + player.left.get(i + 1) * 50
+      )
+      line(
+        x1,
+        150 + player.right.get(i) * 50,
+        x2,
+        150 + player.right.get(i + 1) * 50
+      )
+    end
+    # draws a vertical line where playback is up to
+    posx = map1d(player.position, 0..player.length, 0..width)
+    stroke(0, 200, 0)
+    line(posx, 0, posx, height)
+    message = player.playing? ? PLAYING : NOT
+    text(message, 10, 20)
+  end
+
+  def key_pressed
+    if player.playing?
+      player.pause
+      # if finished, rewind and call play again
+    elsif player.position == player.length
+      player.rewind
+      player.play
+    else
+      player.play
+    end
+  end
+end
+
+Player.new