Okay, so Max didn't want to introduce me, so I introduced myself, my name is Frank Bargnes,
I am also a general provident, I have been one of the first members of the reality jockey
RJ DJ team, I only worked there as a freelancer, so I am not in the middle of the company,
but we have big meetings, I am always there as well, and this RJ DJ project for the iPhone
started some years ago, I think two years ago, so with a series of sprints, so-called sprints,
I missed the first one, you have to ask Roman for what happened with the first sprint,
I think you were there, but then there was a second sprint where they were collecting advanced
PD users to kind of like find out what is needed, what would be needed for getting PD as a music software.
On a mobile device at that time it was only the iPhone, Android came later,
so the basic idea of RJ DJ the software is to create a new kind of music,
that is not just a fixed track anymore, as you all know from MP3 files or so,
but that is a dynamic, generative, algorithmic, reactive music,
and so it has to embed some kind of logic as well, so it is not only just static music,
but something that also has a meter level, and for that reason we decided to use PD,
and because the iPhone on the Apple is, well, it is unique like, so it was quite easy
after a lot of fiddling to get PD kind of running,
so I should switch off the screen saver first, search.
But as you see, I am already here on the screen, I am my heart on the Linux user,
so I really am not very much into this Apple world,
and so one of my tasks was to develop a library that I am going to present here,
the RJ library, but I always took great care to somehow make sure that it is not
in any way specific to Apple or to iPhone or to some stuff like that,
so that it also is a very useful general purpose library,
so that is the library as it came here,
and I call this now abstractions for getting things done, just a silly name,
it is one of the goals of the library came from the first goal of RJ DJ
is to make this music available to lots of people,
and lots of people currently mean there are several million downloads of the RJ DJ software on two iPhones,
so it was quite amazing when the first version came out and I had a piece of music on this,
so normally if there is a PD convention, then there are 100 people on the concerts of many of us here,
but normally we play with a concert where there are 20 people,
and maybe 10 of them are also performing at the same night,
and so it is not such a big community,
but with this RJ DJ on the iPhone suddenly had downloads in one week of my piece of music
of like 20,000 downloads or so,
because there were so many people interested in that, it became quite a hype,
and even now the app, the inception app that is also using the RJ DJ thing,
I think it has 10 million downloads,
so it is a completely different community that is reached through this,
and so distributability was very important,
and as many of you know it is distributability of a patch is quite difficult,
so many patches are not even distributable between your own laptop and your friend's laptop,
because maybe there is some external missing,
there is a path setting wrong or something like that,
so we didn't want to deal with this problem at all,
so what is the way to get out of this problem,
so how can you make a patch distributable,
one possibility is to use only the object classes that actually are available anywhere where you have PD,
and this means the PD vanilla object class.
So basically these are the ones that you get if you press help,
and you have the usual background list,
so other objects in the RJ DJ library or the abstractions are built using these objects here,
and because of license reasons we could not include expression,
the object family that is GPL and GPL and Apple App Store, they don't like each other,
and another way to make your scene or patch,
a scene is a patch including additional resources like a wave file or so,
which is to bundle all the abstractions that you use into the same directory that your own music lives.
So I know several composers who actually work like this,
they go even to more extremes, they bundle a whole PD,
and they use the source code of PD, and they use the binary of PD,
all the externals, they put it in one directory and then they start working,
and they do this every time they start a new composition,
so just to make sure that it will be runnable for a longer time.
So you don't have to be that extreme, but bundling abstractions into the directory even by copying it
might be a feasible approach.
So the RJ library actually is designed exactly for this process,
you can install it globally, but it's quite okay to just copy it over into your project directory.
And that's what I sometimes call on the PD list, it's a deer lip, it's not a lip deer, which is the term invented by I think Hans-Christoph Steiner
for the bundling of libraries in PD Extended.
So that's like the opposite, no installation, global installation is necessary.
So if you want someone else to run a patch that is using this library,
you just give them your patch including the library and it will just run, it doesn't have to install anything.
It's useful to use a declare message, a declare object to make your past available under a shorter name
without the RJ's object name in front, although it's strictly necessary.
You can also use the full RJ library by typing every object name with RJ slash and then something.
For declare as some of you know, it's better to use it in some kind of top level patch,
it's not available inside of abstractions.
So yeah, a lot of these, of details of these are also in the paper and it's just a library,
so what I'm going to do now is I will just show lots of objects of this library.
There are many objects actually, there are 171 documented objects as of today,
which I found out by counting the help files.
It took me all night, I count every help file.
And to make this, it's already a huge number,
so we have an object listing that is similar to the help intro file that we already seen here.
So there's this help intro file, I made a similar overview file for the RJ library
and that's called overview and it's a file that you can put into your patch
and if you open it, you get this little extra overview file,
it will be a little bit small to read, but these are, the RJ library is divided into sections
and these are the section names, it's like analysis, synthesizers, effects, GUIs, mappings,
and if you click on one of these, for example the GUIs,
then it opens up a listing of all the objects that are dealing with some kind of graphical user interface
in the RJ library and all the controllers here.
And then you can of course always go to the help file of the object and take a look at it.
So, yeah, now I'm going to start with the examples.
One section is called the mappings section.
It has lots of small objects and bigger objects that deal with translating things from one room into another room.
A very simple one is the M scale object.
It just does, maybe here I can make the font a bit bigger without breaking the layout,
but it's similar to a scale object that is available in some other libraries.
You just provide an input range, an output range, and a curve, so it can go a linear or a curved way.
So for example, this one here is scaling the input value of 0 to 172 to a range of 0 to 1,
so you're using a DB curve, so it gets faster the further you get.
You can also scale of course the opposite direction.
You can use a linear scale as well by just using one here or different kinds of scaling.
So here's a graphical example as well, which shows you the curves that are possible.
This is the DB, or going this direction.
So it's just a scalar, so it's sometimes useful.
The RJ library has objects like this that are very simple, but useful.
There are also some more, I'd say, exotic objects.
One is the chord dictionary, chord dict.
It's a dictionary of chords, like jazz chords, like sustain, major 7, etc.
So now that's too big.
So for example, if you want to play a major 7 chord, then you get one here,
and sending this symbol inside you will get a different one.
So it's just for musicians, because a lot of RJ DJ people using this library and the software
are coming from a musician background, maybe even a jazz or pop music background,
not only just new music, so it would be named.
So it supports all these chords, which are listed here,
and it will then give out a list, just dump the note steps, excluding the root note,
so the root note you have to be on your own.
You can make real progressions with this.
So this is a little example, which here you see a list of chords.
So it starts with the major chord on step number 1, then the major chord on 4,
then the diminished chord on 7.
So you click this, and then it will go through.
And you can easily change it to a different one,
or another one.
Yeah, so that's just a chord dictionary.
It's mapping chord names to actual chord numbers.
Controllers. Controllers are things that control other things.
So a metro is an obvious example of a built-in controller.
It controls the timing of the rest of the patch.
So here also a fading thing.
Here's a three level fader, which I just took as a thing.
So here you have a note, and this is the cross fader between three inputs.
It's all accepting signals, so you have the oscillator going in, noise going in,
and the phaser going in, and this is the fading signal.
So you really scale over these three things.
And actually it goes around.
You already hear the sine wave, so if you would go further, then it would go back to the sine.
And what else? Controller.
Yeah, I like this one. See, tap-tap.
It's so stupid, but it's really nice.
It's just a, well, you tap rhythm.
See, you tap your rhythm, quantized.
Let's make this with sound.
So I use the sound input output, sorry.
And one of the synthesizers, let's say the drum electro with a hi-hat.
So I clear the tap-tap.
And then you see here, there's just a counting metro here.
And now I can tap by tapping the big bang here.
And then it will, oh sorry, I didn't connect this.
So it's just repeating itself with tap-tap, and you can dump it so it gets saved into a message box to later restore it.
So this is just something, you can make a longer tap-tap, and of course the tempo.
So it's just storing on and off values by tapping.
This was quite nice for the iPhone, so if you wanted something to, yeah, just tap the phone to make your rhythm, then this is a C-tap-tap.
This line means there's a new slide coming.
Ah, and it's crashing.
Okay, I knew, I knew it.
It was crashing so much.
So I have to go through everything.
I didn't implement the go somewhere thing, tap-tap.
Yes, it might happen again.
More examples.
Effects, oh sorry.
Effects, of course, is a big, big topic in the RJDJ thing, because it's a phone.
You have the microphone going in, and then you apply an effect on it, and suddenly the world is different.
It's like on drugs.
And so we have lots of effects.
A simple one that I just chose here is a dub delay.
Basically it's a ping-pong-like delay that works by dividing a bass duration into various steps and then playing back ping-pong-like things.
So you see the bass duration currently is set to 500 milliseconds, and the left divisor is 2, which means there's a delay of 250 milliseconds.
And the signal first going to the right side is divided by 3, so you have an overlapping thing.
Then you can set a feedback, of course, to 1, for example.
So it's not stopping.
There's also a bandpass filter inside.
So if I would set this to smaller, then it will build up.
Well, at the dry, wet level.
And you can, of course, change this.
So it's a dub delay.
A dynamics processor is included.
So just another example, which is a multi-thing.
It has so many parameters that there is an extra page here.
It's a compressor, noise gate, limiter, and expander, all in one.
It's a bit more complicated to use because it has so many parameters.
But in general, I think the compressor mode is like this.
Here I get some random noises here.
I think I have to put the threshold away.
So you see on the upper table is the original signal, and then the lower one is the compressed signal,
and then you can add make up here, so it gets louder.
You see, it's so complicated to use that I'm not using it.
But it works quite nice as a noise gate, which is something that is important if you're dealing with on the iPhone.
You have environmental sounds, and sometimes it's quite useful too.
But if you only want to have someone's voice, then you can filter out the noise
with the noise gate mode of this dynamic processor.
Utilities included are, for example, there is a list drip object.
Maybe some of you know the list abstraction, that lists apps library.
I also wrote with the help of many others.
This is a huge library of list processing abstractions.
And the RJ library includes a handful of copies of these.
So the ones that I consider to be the most important ones, which is among others the list drip object,
which just, if you have a list, and then you sequence it, serialize it into single ones.
There's also included the list filter, list map, list reduce.
So you have filter map reduce, which is a set of list operations where you can build other list operations out of.
Many objects in the list apps library are already internally using this map and reduce in filter operations.
But here you get these included in the RJ library, so that in most of the time, like 80, 90% of the time,
it's not necessary to also include the list apps abstraction library.
Yeah, MakePoly, you have already seen with the cart dictionary example patch that there was a polyphony going on.
There are some objects here which help by making other objects polyphonic.
So for example, and this is the MakePoly object.
Well, here's a little synthesizer, which normally is mono.
It's a Rhodes piano.
Actually, in this play patch, you see that it's trying to play four notes at once, but you only hear one.
So and I can replace this synthesizer by you make poly eight voices, one wins voice stealing as voting.
So I have eight voices inside.
This is realized by dynamic patching internally.
So here you have these eight voices realized.
And if I only need four or if I need 16, then I would just say, okay, 16.
You see now there are more.
So that's also something very useful that is already included in the RJ library.
So synthesizers, you have, there are lots of synthesizers are basically sound generators.
There's the very simple one, which is the SOSC, which is like the OSC tilde object that you know.
But it includes not only the sine wave, but also, so that's a sine wave.
It also includes a triangle, a saw wave, band limited, at least a little bit, a pulse with modulated square and a triangle wave with various parameters.
So the triangle wave can be, you can change the slope.
The square wave, you can make it, you can modulate the pulse wave.
And for the saw, I'm not sure what it, I think it doesn't have any parameters.
And it's also possible to, to let them run on at the same time.
So it's just an oscillator, but on acid, on drugs and whatever.
Rode, you have seen already is a FM4 operator, FM synthesized piano, actually taken from the synthesis toolkit, the parameters from the SDK toolkit.
I won't go into more details.
So a recent, very recent addition are a bunch of synthesizers written by Andy Fanel, who has written many other synthesizers already.
So some of you probably know his book and his tutorials.
And a lot of his example patches and synthesizers have been, have found their way into other libraries already, PD Montreal and so on.
But now recently he developed a set of, I think, six or seven new synthesizers, especially for, for the RJ library.
They, the help files unfortunately make PD33, 43 crash sometimes.
I don't know why, but this is PD42, so I should be safe.
Yeah, all these synthesizers, they share the same set of parameters and it's already five minutes here.
So just to click these, but it's like a Roland Juno type of synthesizer.
So it has a graphical interface and it comes with lots of presets.
And there's another one.
I just show it here.
It makes completely different sounds, but it uses the same programmer.
So it's quite easy to, to get these, these presets running.
Sorry, this was S, I'll just go WSB, wave shaped synth type B.
Again, you can find it through by going through this overview file.
Okay, I think we explained this will take a little bit too long.
It's in, it's in very much detail in the paper.
All these objects are, it's possible to state, they save everything there.
They include a parameter control and persistence system based on, on, on my old set abstraction.
The basic idea is that everything that you send to the right inlet of an abstraction,
it gets dispatched by a special dispatcher object.
Here is an example, the frequency modulating thing.
This is the right inlet and then it goes into dispatcher objects.
So these are like a, all the 24 parameters that these objects have.
And all of these parameters can be saved then.
So let me show how this works.
So here I have some parameters and I change them.
And if I want to save them, I use this construction for, to use some global sense and receives.
It's also in the, in the paper.
So if I want to save these, I click and then I get them into a message box.
These are the things that I've changed here, but I can also save them into a text file or whatever.
So that's, that's built in.
Okay.
Your final feature is deals with a sample management.
We have a special modularized system for dealing with samples that are loaded and played back from tables into and from tables.
The basic idea is to have sample bank objects that hold and fill the tables.
There's a simple one called use sample bank.
Which you just, if you look at the help file, you create it with the name of a table in internal table and a sample that should be loaded.
And then it will just auto inside.
It has a sound fire and it will load the table.
And if you want to play back this table here, you can use matching objects like the as play table object.
It's here.
So I could play back a table.
It's an object here.
Let's say I open a file.
Let's say a drum file.
Clap.
Yeah.
You see, this is important.
These two set the sample rate that is used for playing back the samples.
This should include the, this should be the rate of the files, the sample rate of the file that you are using.
By default, it's actually half CD sample rate because that's what most of the stuff on the iPhone uses.
And another sample bank variant is the sample kit, which is more complex.
It loads a complete directory with audio files by just one object.
So you have a directory.
I have one here and this is going to crash soon.
So here you see a lot of samples and one index dot text file.
And this maps samples to numbers and then you can access and play back a sample by number from this sample kit.
So here's how it works.
Sample kits.
Here's the sample kit object with an optional prefix.
Then I send a message open 808 kit.
And then I can, or a different kit, I send it by open drums, which will now open the other directory.
This also works, of course, for piano sounds.
If you have each piano sound mapped to numbers from zero to 127, you can play back a piano sound or a synth sound.
And here's just a little thing that is playing a random rhythm over this sample kit by using some other object.
So I can really switch on the fly once it's loaded quite fast.
Okay, this has been killed.
Future, well, there's much more inside the library.
Take a look at all the other objects.
It's 171.
I could only show you about 10 or so.
So there's much more inside and I would really like for you to explore it.
It's really not tied to the iPhone or something.
So if you don't own an iPhone, you're still allowed to use it.
And I use it actually now in all my projects.
Let's make a copy.
There's some work to do in the analysis section.
There were some talks this morning where there was some work that you could use.
So the only thing I can invite you is to enjoy the taste of vanilla ice cream for the rest of your life.
Thank you very much for listening.
Where can you download this?
Oh, I didn't write it.
It's in the paper, but you can download it.
If you go to...
It's on GitHub.
I'm not sure.
I don't think I'm connected to them.
But yeah, yeah, and it's probably easy to find.
You may ask again on the mailing list or I can send it to you later.
There's also the blog of RJDJ.
There is a little page which explains a little bit more about this setup.
And then...
Oh, and it's free.
It's GPL and BSD mixed.
Is there a way to write to a server?
Well, RJDJ only has NetReceive inside in NetSend.
So if you can build away NetReceive, NetSend to talk to your server, then it's possible.
But there's nothing fixed in it.
But there's a way to write to a server.
No more questions then.
Thank you.
