Not To Record External Midi Notes

I was trying to get Plogue Bidule to sequence Renoise Instrument, but in record-mode Renoise would always record the notes Bidule sequenced into pattern. I know for mapped controller massages we have an option not to record CCs into pattern/automation – is there such an option for note messages?

A solution I found is sending the note messages via OSC, with the ability to specify destination track I just sign them to Master track (midi-in can’t do that), that way the notes won’t get recorded as Master doesn’t have a note pattern.

So the second question is, if OSC to master track is the route to go, is there a method to get Renoise to report current total track numbers to Bidule? via something like Formula? This is not necessary tho, just for some tiny convenience.

I know for mapped controller massages we have an option not to record CCs into pattern/automation – is there such an option for note messages?

For note-off, yes, but not note-on.

with the ability to specify destination track I just sign them to Master track (midi-in can’t do that), that way the notes won’t get recorded as Master doesn’t have a note pattern.

World class hackaround, haha. Very creative…

If you want, you could evaluate expressions remotely by making them part of the OSC message.

Just add your own entries to the GlobalOscActions.lua file

---- Remote evaluation of Lua expressions via OSC
 
 With the OSC message "/renoise/evaluate" you can evaluate Lua expressions 
 remotely, and thus do "anything" the Renoise Lua API offers remotely. This 
 way you don't need to edit this file in order to extend Renoise's OSC 
 implementation, but can do so in your client.
 
 "/renoise/evaluate" expects exactly one argument, the to be evaluated 
 Lua expression, and will run the expression in a custom, safe Lua environment. 
 This custom environment is a sandbox which only allows access to some global 
 Lua functions and the renoise.XXX modules. This means you can not change any 
 globals or locals from this script. Please see below (evaluate_env) for the 
 complete list of allowed functions and modules.

Source:https://xrnx.googlecode.com/svn/trunk/GlobalOscActions.lua

GlobalOscActions is pretty easy to hack into, just make sure you are working on a copy. Things might screw up :slight_smile:

Of course, you could also write a small osc server in lua which will periodically report stuff to whoever is listening.

It depends on how you are going to use it…

Also, neurogami has written a lot of stuff about OSC in Renoise, check his blog.

To have it not record you can also just mute the pattern track slot in the matrix.

Found this in the API:

– number of normal playback tracks (non-master or sends) in song.
renoise.song().sequencer_track_count
-> [read-only, number]

Now it’s the matter of introducing this property into the MIDI triggering process.

GlobalOscActions.lua states that the note triggers are “… realtime critical messages internally. Those will never be triggered here, and thus can not be overloaded here.” so it’s probably not-hackable?

For now it might be easilier to just do a tool to send a sequencer_track_count via midi or plug-in automation.

Even better is if the Formula device could do this; can it reach API?

Guess no?

To have it not record you can also just mute the pattern track slot in the matrix.

I tried, but it still records; isn’t it the same as muting the track?

Well…actually this whole stuff should be easily solved with Redux. :drummer:

A solution I found is sending the note messages via OSC, with the ability to specify destination track I just sign them to Master track (midi-in can’t do that), that way the notes won’t get recorded as Master doesn’t have a note pattern.

So the second question is, if OSC to master track is the route to go, is there a method to get Renoise to report current total track numbers to Bidule? via something like Formula? This is not necessary tho, just for some tiny convenience.

If you are using OSC you can also send messages to toggle recording on and off. I don’t if this will step on other things that should be recorded.

Hacking on GlobalOscActions.lua is reasonably straight-forward if you know some Lua.

I didn’t know any Lua before using Renoise, though I’ve many years experience as a software developer.

I got started by copying existing OSC handler code in GlobalOscActions.lua and making a few tweaks, then digging through the Renoise Lua API to find what was possible.

I’ve now moved to writing my custom OSC in a tool, and having that tool proxy off to the Renoise OSC server all of the built-in Renoise handlers. I did this mainly so I could more easily distribute my code. The bulk of my OSC code is in the OSC Jumper tool.

https://github.com/Neurogami/renoise-ng/tree/master/lua/com.neurogami.OscJumper.xrnx

Lately I’ve been experimenting with having an OSC client in the tool that talks back to what it is that is sending OSC messages to Renoise.

At first this was an on-demand process. I wrote a simple client that would request the current BPM and get it back as an OSC message.

However, I’m interested in writing client scripts that manipulate a running Renoise song by watching for various conditions and then instructing the song to change pattern loops, alter tracks, modify devices, etc.

Renoise has timers that can execute a function at a specified interval. For example, if you had a function that sent back the current track count:

renoise.tool():add_timer(my_track_count_function, 1000)

This would call my_track_count_function() once every second (more or less; it is not atomic-clock precise. :slight_smile: ).

(You can get the track count using renoise.song().sequencer_track_count )

If the number of tracks is not something that changes during a song then this is overkill. (I’ve been using functions that track the current pattern.)

If you just want to occasionally fetch the track count you can write an OSC handler just for that, and have it send back an OSC message.

I looked for my own code for this but seemed to have borked in during some re-writes.