As I get ready to move once again (this time to the Ridgewood/Bushwick border) there's not a whole lotta time for personal projects. Yesterday I decided that I would find a quick one and do it no matter how useless it was.
Turned out, I came up with something that's going to be pretty useful (for me). Last week, a coworker pointed me to marcel's awesome Ruby giftube script which extracts animated gifs from online videos. I've been looking to incorporate more audio samples in my music for quite some time, so I forked his script and changed it to extract audio samples instead of gifs, complete with mp3 conversion.
Here's the result:
Being on my way to the west coast and out of arm's reach of the synths, I've had a few hours to switch gears and put together a quick Ruby gem, MicroOSC. It's a utility and DSL for dealing with OSC messaging.
gem install micro-osc
I applied the same principle to OSC that I applied to MIDI with MicroMIDI: distilling the simplest messenger interface that I could think of.
Unlike MIDI, OSC deals with generic user-defined messages. This eliminates the need for describing different concrete message types, something that added a lot complexity to MicroMIDI.
MicroOSC can function as a server, a client or both. In this example, I'll demonstrate them separately, having the two programs talk to each other over a local network.
Here is a server:
require "osc"
OSC.using(:input_port => 8000) do
receive("/greeting") { |val| p "received #{val}" }
p "Ready to receive OSC messages on port(s) #{input_ports.join(', ')}..."
wait_for_input
end
Once you have this running, you should see "Ready to receive OSC messages..." in your Ruby console. Switch to another window and run this client program:
require "osc"
o = OSC.using(:output => { :host => "localhost", :port => 8000 })
o.out("/greeting", "hullo!")
After running it, flip back to your server program and see “received hullo!”, confirming that your two programs were in fact talking to each other!
Notice that in the second program I didn't use a Ruby block style. Doing it this way would generally be better for live coding, and probably some other scenarios as well.
That's it!
Look for another post with real-world examples, advanced techniques and combining with MicroMIDI soon.
I've created a Ruby library called OSC Access for binding OSC directly into Ruby classes and objects.
It conveniently wraps a lot of functionality from osc-ruby, handling server/client sharing and management as well as other tasks commonly associated with OSC.
gem install osc-access
All of OSC Access' functionality is available by including the OSCAccessible module into a class. The module gives you a lot of functionality but you'll want to know about these three methods in particular to get up and running
All OSC input is handled by using the osc_receive method. Here's an example of using osc_receive in a simple way:
class Instrument
include OSCAccessible
osc_receive("/1/fader1") do |instance, val|
instance.velocity = val
end
def velocity=(val)
puts "setting velocity to #{val}"
...
end
end
i = Instrument.new
i.osc_start(:input_port => 8000).join
When this example is run, the method velocity= is called on all instances of the Instrument class whenever OSC messages for the address /1/fader1 are received.
A couple of things to note here...
In order to enable OSC input, an input port must be specified for each instance. I've done that in this example using the osc_start method but there is also a method osc_input which just takes a port number. You can also add multiple input ports and share ports across various objects. (see example...)
Another thing to note is that val is, by default, the value of the first argument of the received OSC message. (OSC messages can have an unlimited number of arguments). You can modify which arg is used, or pass in all of them, by setting the :arg option on osc_receive.
You can also use osc_receive as an instance method. (see example...) However, more usefully, you can create a Hash map spec of osc_receive calls and pass it to an instance like this:
map = {
"/1/fader1" => {
:translate => { :remote => 0..1, :local => 0..127 }
:action => Proc.new { |instance, val| instance.pitch = val }
}
}
class Instrument
include OSCAccessible
def pitch=(val)
puts "setting pitch to #{val}"
...
end
end
i = Instrument.new
i.osc_start(:map => map, :input_port => 8000).join
This kind of approach gives you more flexibility by decoupling the OSC spec for your object from the class -- like a controller and model in MVC.
Osc_receive has a few options:
There's another difference between those two examples: the :translate option means that val will be translated from a number between 0 to 1 to the analogous value between 0 and 127 before being passed to the code block. So for example if the first argument of the received OSC message is equal to 0.5, val will be equal to 63.
By setting the :thru option to true, any messages that are received for /1/fader1 are sent immediately to the output (as well as calling the :action block). For example, using the Instrument class from the last example:
map = {
"/1/fader1" => {
:thru => true
:translate => { :remote => 0..1, :local => 0..127 }
:action => Proc.new { |instance, val| instance.pitch = val }
}
}
i = Instrument.new
i.osc_start(:map => map, :input_port => 8000, :output => { :host => "192.168.1.9", :port => 9000 }).join
As you can see, I also specified an OSC output host and port for this example. If you're ever missing input or output port or host info, your object simply will not perform IO -- it won't raise any kind of exception.
Osc_send gives you the ability to output arbitrary OSC messages. The first argument is the address of the message and any arguments after that are the content. Here is an example of our class definition from this first example with output added
class Instrument
include OSCAccessible
osc_receive("/1/fader1") do |instance, val|
instance.velocity = val
instance.osc_send("/velocity", val)
end
def velocity=(val)
puts "setting velocity to #{val}"
...
end
end
i = Instrument.new
i.osc_start(:map => map, :input_port => 8000, :output => { :host => "192.168.1.9", :port => 9000 }).join
i.osc_send("/greeting", "hi!")
In this example, I'm sending a message from both osc_receive's action block and in the main program block after i is instantiated.
Osc_start starts all of the OSC servers that are connected to your objects. You must call it on an instance before osc_receive will function.
I'll be adding OSC Access to Diamond and coming up with a way to use it with MicroMIDI in the next few days. Thanks for reading.
@i = UniMIDI::Input.use(:first)
@o = UniMIDI::Output.use(:first)
MIDI.using(@i, @o) do
node :roland, :model_id => 0x42, :device_id => 0x10
*@my_map =
[0x40, 0x7F, 0x00],
[0x41, 0x7F, 0x00],
[0x42, 0x7F, 0x00]
receive :cc do |message|
command @my_map[message.index - 1], message.value
end
join
endDefining a Nodecommand @my_map[message.index - 1], message.valueWhen using the command function, the first argument is the sysex address and the second is the value to assign. The value can either be a number, as in this case, or an array of bytes. When making a request, the first argument is also the address but the second argument is the size of the response (in bytes) that you expect to receive
request 0x43, 43If all else fails...
sysex 0x1, 0x2, 0x3, 0x4With no node specified, this will give you a message composed of
F0 01 02 03 04 F7In other words, sysex will create a message and not perform any validation or add a checksum to it. You can still use node with these message-- it will append those bytes immediately after the F0 start byte as it would with a command or request.
@i = UniMIDI::Input.use(:first)
@o = UniMIDI::Output.use(:first)
M(@i, @o) do
tu :n
rc :n { |m| tp(m, :oct, 1) if %w{C E G}.include?(m.note_name) }
j
end
require "micromidi"
@input = UniMIDI::Input.use(:first)
@output = UniMIDI::Output.use(:first)
MIDI.using(@input, @output) do
thru_except :note
receive :note do |message|
message.octave += 1 if %w{C E G}.include?(message.note_name)
output message
end
join
end
@i = UniMIDI::Input.use(:first)
@o = UniMIDI::Output.use(:first)
MIDI.using(@i, @o) do
thru_except :note { |msg| transpose(msg, :octave, 1) }
join
end
Here's an example where MicroMIDI sends some MIDI messages to an output. (see an example here which explains selecting an output...)
require "micromidi" @o = UniMIDI::Output.use(:first) MIDI.using(@o) do note "C" off cc 5, 120 play "C3", 0.5 end
Running this code sends the following to @o:
* note C2 (2 is the default octave)
* note-off for C2, since that was the last note sent
* sets controller number 5 to 120
* note C3, waits half of a second and then note-off for C3
By default, any time you call a method that returns a MIDI message object, it's automatically sent to any outputs that are passed in. You can toggle this feature by calling
output false
or
output true
You can also prevent only a single command from sending output by setting the output option:
note "c", :output => falseSticky Values
If you work with MIDI often, you may have noticed that there was no mention of MIDI channel or velocity in the last example. Most of the time, sending a note-on or note-off message requires those values. In addition, for the first message I didn't specify what octave the note C should be.
Here's an example where the sticky values are used, changed and overriden.
MIDI.using(@o) do channel 1 note "C4" off octave 5 velocity 60 note "E", :channel => 2 off channel 3 note "C3" off end
What winds up being sent to @o is:
* note C4 (channel 1, vel 100)
* note-off C4 (channel 1, vel 100)
* note E5 (channel 2, vel 60)
* note-off E5 (channel 2, vel 60)
* note C3 (channel 3, vel 60)
* note-off C3 (channel 3, vel 60)