[long post]
In recent projects I have been working on this sampler idea within SuperCollider again, and from time to time I find myself making improvements to the code: here is an update on what we have already seen in the course of this thread.
In particular, I found myself improving the function for loading samples with the aim of making the function compatible with different naming conventions of audiofiles for different sample banks I was working with.
In general, it is my understanding that the name of an audio file within a sample bank can be composed of several fields that define, from time to time:
- the musical instrument which have been recorded;
- the technique used for the recording (sus, vib, stac, pizz);
- the dynamics (p, mp, f, piano, mezzo-forte);
- the note name;
- possibly the round robin index;
- others…
In addition, the name of the note field, might contain the identifier for the alteration (sharp). I have noticed that while some sample banks use ‘#’ as a convention for notating sharp notes, others use the lowercase ‘s’ instead.
It should also be considered that some samples are designed to be used alternately with others (especially samples for percussive instruments or for certain sound effects). In these cases, there is a field identifying the index within the series to be used for random selection (the round robin). Sometimes it is called RRx (where x is used here in place of a number, like 0, 1, 2 or 3), other times they use rrx or r0x, etc…
All of these fields, in turn, could be separated from each other by means of a delimiter character (generally the ‘_’ but can also be the ‘-’).
The function for loading samples now offers the possibility of specifying:
- the delimiter character;
- the identification character for alteration (sharp);
- an array of symbols within which to specify the various fields by which to filter the audio files within the sample bank;
if you want to test the function please follow the passages below 
First of all you need to download (one of all of) these three samplebanks:
- the Versilian Chamber Orchestra Community Edition (a.k.a VSCO);
- the Versilian Community Sample Library (a.k.a. VCSL);
- the (beloved) Sonatina Symphonic Orchestra;
These sound libraries were chosen for their permissiveness in terms of the licence to use.
In spite of the work done towards the community, the quality of the samples and the permissiveness of the licence under which it was released, I would in no way recommend the Philharmonia Sound Library because:
- is missing audiofiles and, in other cases, entire musical instruments found in other libraries;
- contains several inconsistencies in the way the files are named;
- there are just blatant errors whereby sometimes a file is named after a musical note when the recording corresponds to a different one;
- in percussive samples, note onsets have an inconsistent distance in time from the beginning of the audiofile;
In the past few months I have pointed out these anomalies by writing them a message but the only support I got was a sentence like “there’s not much we can do about it, they are files that were created a long time ago”. too bad 
After you have downloaded the samplesbanks and saved them to your PC then you have to save the paths (you will nee them later to load the samples)
~path_vscoBasepath = "/home/nicola/Musica/samples/VSCO-2-CE-master/";
~path_vcslBasepath = "/home/nicola/Musica/samples/VCSL/VCSL-1.2.2-RC/";
~path_ssoBasepath = "/home/nicola/Musica/samples/Sonatina Symphonic Orchestra/Samples/";
You create an empy dictionary where to store the samplebanks
if (~my_samples.notNil) {
~my_samples.do({
|key|
if (~my_samples[key].notNil) {
~my_samples[key][\buffers].do({
| buffer |
if (buffer.notNil) {
buffer.free;
};
});
};
});
};
~my_samples = ();
You evaluate the (updated!!!) loading function
~func_load_samplebank = {
| key, relpath, delimiterChar, sharpChar, namefilter, destination, basepath="/my/placeholder/path/here/" |
var path, tmp_buffers, tmp_array;
path = PathName(basepath +/+ relpath);
tmp_buffers = path.entries.removeAllSuchThat({
|item|
var fileNameComponentsAsSymbols = item.fileNameWithoutExtension.split( delimiterChar ).collect({|e| e.asSymbol});
fileNameComponentsAsSymbols.includesAll( namefilter );
});
tmp_array = tmp_buffers.collect({
| item, index |
var d, string, output, noteNameAll, octNumber, noteName, isSharp, midiNumber;
d = ();
string = item.fileNameWithoutExtension;
output = string.findRegexp("[abcdefgABCDEFG]"++sharpChar++"?[0123456789]");
noteNameAll = output[0][1];
octNumber = noteNameAll.rotate(1)[0].asString.asInteger;
noteName = noteNameAll[0].asString;
isSharp = noteNameAll.contains( sharpChar ); // boolean
midiNumber = (octNumber +1) * 12;
switch( noteName.toLower,
"c", { midiNumber = midiNumber+0; },
"d", { midiNumber = midiNumber+2; },
"e", { midiNumber = midiNumber+4; },
"f", { midiNumber = midiNumber+5; },
"g", { midiNumber = midiNumber+7; },
"a", { midiNumber = midiNumber+9; },
"b", { midiNumber = midiNumber+11; },
);
if (isSharp) {midiNumber = midiNumber + 1;};
//[noteNameAll, noteName, isSharp, octNumber, midiNumber].postln;//.debug("[fullname, note, sharp, octave, midinum]");
d[\midi] = midiNumber.asInteger;
d[\note] = noteNameAll;
// uncomment the line below if you want to see a more verbose debug
//d[\buffer] = Buffer.readChannel(s, item.fullPath.debug("reading file"), channels:0);
d[\buffer] = Buffer.readChannel(s, item.fullPath, channels:0);
d;
});
key.debug("loading");
tmp_array.sortBy(\midi);
destination[key] = ();
destination[key][\buffers] = tmp_array.collect({|item| item[\buffer]; });
destination[key][\midinotes] = tmp_array.collect({|item| item[\midi]; });
// check evaluation function in order to check if the samples array
// has been succesfully filled or not
if( destination[key][\buffers].isEmpty,
{ postf("ERROR: loading '%' samplebank", key); },{"loading succesfull".postln;}
);
destination;
};
);
And eventually load the samples. Here we will try our hand at using the loading function to load samples from all 3 libraries to test how it works.
Loading from VSCO
let’s try loading some String samples. Violins, Violas and Cellos are using this naming convention respectively: VlnEns_susVib_G4_v2.wav, ViolaEns_susvib_G4_v2_1.wav and susvib_G3_v3_1.wav
~func_load_samplebank.(\vsco_vln_susVib, "/Strings/Violin Section/susVib", $_, $#, [\VlnEns, \susVib, \v2], ~my_samples, basepath:~path_vscoBasepath);
~func_load_samplebank.(\vsco_viole_susVib, "/Strings/Viola Section/susvib", $_, $#, [\ViolaEns, \susvib, \v2], ~my_samples, basepath:~path_vscoBasepath);
~func_load_samplebank.(\vsco_cello_susVib, "/Strings/Cello Section/susvib", $_, $#, [\susvib, \v3], ~my_samples, basepath:~path_vscoBasepath);
test the samples banks
~my_samples[\vsco_vln_susVib][\buffers].size;
~my_samples[\vsco_vln_susVib][\midinotes].size;
~my_samples[\vsco_vln_susVib][\buffers].do({|b| b.path.postln});
~my_samples[\vsco_vln_susVib][\buffers][0].play;
~my_samples[\vsco_viole_susVib][\buffers].size;
~my_samples[\vsco_viole_susVib][\midinotes].size;
~my_samples[\vsco_viole_susVib][\buffers].do({|b| b.path.postln});
~my_samples[\vsco_viole_susVib][\buffers][0].play;
~my_samples[\vsco_cello_susVib][\buffers].size;
~my_samples[\vsco_cello_susVib][\midinotes].size;
~my_samples[\vsco_cello_susVib][\buffers].do({|b| b.path.postln});
~my_samples[\vsco_cello_susVib][\buffers][0].play;
Loading from VCSL
Let’s try with handchimes and three different dynamics for the glockenspiel. Their are respectively followind these naming conventions sus_G#5_r01_main.wav and glock_soft_G6_01.wav.
Let’s load and test them like this:
~func_load_samplebank.(\vcsl_handchimes, "/Idiophones/Struck Idiophones/Hand Chimes/", $_, $#, [\sus, \main, \r01], ~my_samples, basepath:~path_vcslBasepath);
~func_load_samplebank.(\vcsl_glock_soft, "/Idiophones/Struck Idiophones/Glockenspiel/", $_, $#, [\glock, \soft], ~my_samples, basepath:~path_vcslBasepath);
~func_load_samplebank.(\vcsl_glock_medium, "/Idiophones/Struck Idiophones/Glockenspiel/", $_, $#, [\glock, \medium], ~my_samples, basepath:~path_vcslBasepath);
~func_load_samplebank.(\vcsl_glock_loud, "/Idiophones/Struck Idiophones/Glockenspiel/", $_, $#, [\glock, \loud], ~my_samples, basepath:~path_vcslBasepath);
~my_samples[\vcsl_handchimes][\buffers][0].play
~my_samples[\vcsl_glock_soft][\buffers].size
~my_samples[\vcsl_glock_soft][\buffers][2].play
~my_samples[\vcsl_glock_medium][\buffers][2].play
~my_samples[\vcsl_glock_loud][\buffers][2].play
Let’s try now with a much longer sample like this bowed vibrophone (naming convention: Vibes_bowed_A2_rr1_Main.wav):
~func_load_samplebank.(\vscl_vib_bowed, "/Idiophones/Struck Idiophones/Vibraphone/Bowed/", $_, $#, [\Vibes, \bowed, \Main], ~my_samples, basepath:~path_vcslBasepath);
~my_samples[\vscl_vib_bowed][\buffers][2].play
Loading from SSO
Sonatina’ Violins samples audifiles are named something like: 1st-violins-sus-a#6.wav so we load them and test them like this:
~func_load_samplebank.(\sso_violins, "/1st Violins/", $-, $#, ["1st".asSymbol, \violins, \sus], ~my_samples, basepath:~path_ssoBasepath);
~my_samples[\sso_violins][\buffers].size
~my_samples[\sso_violins][\buffers][3].play