- HANS
BIO PROJECTS WORKSCONTACTAUDIO
DOORSCHEMERING:
ABOUT THE COMPOSITION
In this article
I will explain some of my idea's, composing- and
sound design-techniques I have used to create "Doorschemering for Piano
and Sound Tracks".
You can listen to the performance of this work through this link:
Doorschemering
You can order the performing material through this link:
Order Doorschemering
The composition is based on the note B-flat. Recordings of low piano
tones of this note are analysed, and the result of these analyses are
used in the composition as well as in the sound design. If you play and
listen to loud played piano tones you will hear a whole world of
different frequencies sounding inside the decaying tone. Harmonic and
non-harmonic tones seem to have their own live swelling and decaying in
different periods. This phenomena triggered me to make this work as it
is.
For the analysis I used two basic programs: SPEAR
and CERES3, other link here,
running on a Macintosh and Silicon Graphics computer. As for now I have
not found a version of CERES3 for the Mac, if anyone has a version
please let me know.
Both programs perform a so called Fast Fourier Analysis of the sound,
resulting in a complex of its component frequencies. For the theory
about the Fourier Analysis see Wikipedia.
SPEAR AND SUPERCOLLIDER
SPEAR:
The program SPEAR I used to select the harmonics for the harmonic
structure of the composition as well as for the creation of the
electronic sounds.
An analysis of a low B-flat tone looks like this:
The darker the line, the louder this frequency is present in the
analyzed sound.
If you need, you can zoom-in to study parts of the spectrum more
closely:
You can clearly see the strait lines of the harmonic components, the
overtones, of the sound. The SPEAR program gives you the opportunity to
access the precise frequency and loudness of a component within in a
chosen time-frame. I used that to create a set of pitches (of course
rounded to the 'well-tempered' scale of the piano) out of which I
choose my chords for the piece. For other -transposed- parts of the
composition I reused this procedure. So the harmonic texture of
the composition is always in line with the basic sound, the 'color' of
the work. This might be an old technique, but the overtones of a low
piano tone are sometimes rather enharmonic, so the chords you can make
out of them can be strangely dissonant. Of course the more harmonic
overtones are generally louder (darker lines) then the more dissonant
overtones. I used this phenomena to create chords with different
'distances' of the fundamental.
SUPERCOLLIDER:
The analysis-data as a result of my use of the SPEAR-program I used
also to create the sounds of the sound tracks. With this program you
can export 'Partials', the connected lines in the pictures, they
formulate the development of the loudness and pitch of harmonic and
non-harmonic frequencies which make up the sound. If you do this over a
freshly analyzed sound you will get a massive set of data, unusable. So
you must reduce the amount of data you want to export, you can do this
by selecting the 'partial' and export only the data of these. I used
this technique to split the sound in very-low-, low-, middle- and
high-frequencies.
The export will give you a text-file in which time, frequency and
loudness are coupled in large arrays. Like in the result
here.
From this data I abstracted the frequency- and loudness-development in
such a way I can use them for recreation in the sound-program
SuperCollider (well know in the electronic music scene):
//van Bes0laagfilters
s.boot;
(
SynthDef(\bes0laagfilt1, { |out = 0, pn=0,rq=0.03, lvl=2|
var freq, level, input, uit, flt;
freq = 1.0028769051131*58.154999;
level = EnvGen.kr(Env.new([0.021867, 0.225344, 0.029643, 0.066617, 0],[14.75, 7.1, 2.45, 2.0],'lin'),doneAction: 2);
input = PinkNoise.ar;
flt = BPF.ar(input, freq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,8*2);
Out.ar(out, uit)
}).add;
SynthDef(\bes0laagfilt2, { |out = 0, pn=0,rq=0.03, lvl=2|
var freq, level, input, uit, flt;
freq = 1.0028769051131*115.014557;
level = EnvGen.kr(Env.new([0.0, 0.068889, 0.496781, 0.021730, 0],[0.1, 5.7, 24.4, 2.0],'lin'),doneAction: 2);
input = PinkNoise.ar;
flt = BPF.ar(input, freq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,4*2);
Out.ar(out, uit)
}).add;
SynthDef(\bes0laagfilt3, { |out = 0, pn=0,rq=0.03, lvl=2|
var freq, level, input, uit, flt;
freq = 1.0028769051131*232.856949;
level = EnvGen.kr(Env.new([0.0, 0.079922, 0.111011, 0.028578, 0],[0.35, 10.0, 12.95, 2.0],'lin'),doneAction: 2);
input = BrownNoise.ar;
flt = BPF.ar(input, freq,0.015,level*lvl);
uit = Pan2.ar(flt,pn,4*2);
Out.ar(out, uit)
}).add;
SynthDef(\bes0laagfilt4, { |out = 0, pn=0,rq=0.03, lvl=2|
var freq, level, input, uit, flt;
freq = 1.0028769051131*353.409943;
level = EnvGen.kr(Env.new([0, 0.060435, 0.034190, 0],[0.4, 0.65, 2.0],'lin'),doneAction: 2);
input = WhiteNoise.ar;
flt = BPF.ar(input, freq,0.013,level*lvl);
uit = Pan2.ar(flt,pn,4*2);
Out.ar(out, uit)
}).add;
SynthDef(\bes0laagfilt5, { |out = 0, pn=0,rq=0.03, lvl=2|
var freq, level, input, uit, flt;
freq = 1.0028769051131*383.918793;
level = EnvGen.kr(Env.new([0.0, 0.218084, 0.229064, 0.005065, 0],[0.4, 5.35, 22.05, 2.0],'lin'),doneAction: 2);
input = BrownNoise.ar;
flt = BPF.ar(input, freq,0.018,level*lvl);
uit = Pan2.ar(flt,pn,2*2);
Out.ar(out, uit)
}).add;
SynthDef(\bes0laagfilt6, { |out = 0, pn=0,rq=0.03, lvl=2|
var freq, level, input, uit, flt;
freq = 1.0028769051131*415.192078;
level = EnvGen.kr(Env.new([0.0, 0.199251, 0.258331, 0.004821, 0],[0.4, 6.85, 23.05, 2.0],'lin'),doneAction: 2);
input = WhiteNoise.ar;
flt = BPF.ar(input, freq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,5*2);
Out.ar(out, uit)
}).add;
SynthDef(\bes0laagfilt7, { |out = 0, pn=0,rq=0.03, lvl=2|
var freq, level, input, uit, flt;
freq = 1.0028769051131*477.725189;
level = EnvGen.kr(Env.new([0, 0.379109, 0.007691, 0],[2.25, 22.25, 2.0],'lin'),doneAction: 2);
input = WhiteNoise.ar;
flt = BPF.ar(input, freq,0.006,level*lvl);
uit = Pan2.ar(flt,pn,4*2);
Out.ar(out, uit)
}).add;
)
////////sequens
(
a=Pbind(\instrument, \bes0laagfilt1,
\pn, Prand([-0.5,-0.6,-0.8,-1.0],inf),
\lvl, Prand([2.0, 2.5, 3.0, 3.5, 4.0],inf),
\dur, (0.1+ 5.7+ 24.4)).play;
b=Pbind(\instrument, \bes0laagfilt2,
\pn,Prand([0.0,-0.2,-0.4,-0.6,-0.7,-0.9,-1.0],inf),
\lvl, Prand([1.8, 2.0, 1.9, 2.3, 2.5],inf),
\dur, (14.75+ 7.1+ 2.45)).play;
c=Pbind(\instrument, \bes0laagfilt3,
\pn, Prand([0.0,-0.1,-0.3,-0.5,-0.6,-0.8,-1.0],inf),
\lvl, Prand([1.85, 2.0, 1.95, 2.23, 2.45],inf),
\dur, (0.35+ 10.0+ 12.95)).play;
d=Pbind(\instrument, \bes0laagfilt4,
\pn, Prand([0.0,-0.2,-0.4,-0.6,-0.7,-0.9,-1.0],inf),
\lvl, Prand([1.9, 2.05, 1.95, 2.3, 2.4],inf),
\dur, (0.4+ 0.65)).play;
e=Pbind(\instrument, \bes0laagfilt5,
\pn, Prand([0.0,-0.1,-0.3,-0.5,-0.6,-0.8,-1.0],inf),
\lvl, Prand([1.5, 2.0, 1.85, 2.2, 2.3],inf),
\dur, (0.4+ 5.35+ 22.05)).play;
f=Pbind(\instrument, \bes0laagfilt6,
\pn, Prand([0.0,-0.2,-0.4,-0.6,-0.7,-0.9,-1.0],inf),
\lvl, Prand([1.5, 2.0, 1.75, 2.1, 2.2],inf),
\dur, (0.4+ 6.85+ 23.05)).play;
g=Pbind(\instrument, \bes0laagfilt7,
\pn, Prand([0.0,-0.1,-0.3,-0.5,-0.6,-0.8,-1.0],inf),
\lvl, Prand([1.8, 2.0, 1.9, 2.1, 2.2],inf),
\dur, (2.25+ 22.25)).play;
)
a.play;
b.play;
c.play;
d.play;
e.play;
f.play;
g.play;
a.stop; b.stop; c.stop; d.stop; e.stop; f.stop; g.stop;
s.quit;
I used a filtered noise (pink noise for the lowest frequency, brown
noise for the middle frequencies, white noise for the high frequencies)
as the bases for the sounds of the sound tracks, for some parts
frequency-modulated generators.
(NB. the factor -1.0028769051131- in this patch is to correct the
tuning of the analyzed piano, which was tuned a bit too low)
You will get sounds like these:
Bes0-FilterHgMid1-20.wav
Bes0-FilterLg1-20.wav
Bes0-FilterMid3min.wav
Bes0-FiltersLosH6-20Mtro.wav
Bes0-FiltersLosL1-30.wav
Bes0-FiltersLosM1-30.wav
The sounds are more or less harmonic in their appearance since they
originated from an analysis of a real existing, pitched, so harmonic,
sound.
The spaciousness of the sounds arise from the irregular noises that are
at the basis of the sounds.
SUBHARMONIC SOUNDS
A variant of this technique I used for the end part of
'Doorschemering'. Instead of using the array of frequencies directly, I
wanted to create a sub-harmonic array. I did this by calculating the
ratio between the current frequency and the basic frequency of the low
B-flat. Then dividing a high B-flat by this ratio.
In the
example-patch:
freq = our current frequency from the analyzed data,
fact = the ratio calculated from the lowest partial, and
frq = the new
frequency with the reversed ratio applied. A subharmonic patch:
s.boot;
//van Bes0midfilters
(
SynthDef(\bes0hoogfilt1, { |out = 0, pn=0,rq=0.03, lvl=6 |
var freq, level, input, uit, flt;
var bes0 = 57.246178 , bes1 = 3729.3100921447 , fact, frq;
freq = 2800.997070;
fact = freq/bes0;
frq = bes1/fact;
level = EnvGen.kr(Env.new([0.001035, 0.000038, 0.001035, 0.003384, 0],[2.4, 17.7, 8.2, 2.0],[2,3,1,1]),doneAction: 2);
input = WhiteNoise.ar;
flt = BPF.ar(input,2* frq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,4*24);
Out.ar(out, uit)
}).add;
SynthDef(\bes0hoogfilt2, { |out = 0, pn=0, lvl=6 |
var freq, level, input, uit, rq=0.03, flt;
var bes0 = 57.246178 , bes1 = 3729.3100921447 , fact, frq;
pn = (1.6).rand-0.8;
freq = 1850.763672;
fact = freq/bes0;
frq = bes1/fact;
level = EnvGen.kr(Env.new([0.013553, 0.000403, 0.013553, 0.015482, 0],[2.6, 18.85, 8.05, 2.0],[-2,2,2,1]),doneAction: 2);
input = WhiteNoise.ar;
flt = BPF.ar(input,2* frq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,4*24);
Out.ar(out, uit)
}).add;
SynthDef(\bes0hoogfilt3, { |out = 0, pn=0,rq=0.03, lvl=6 |
var freq, level, input, uit, flt;
var bes0 = 57.246178 , bes1 = 3729.3100921447 , fact, frq;
freq = 2152.895996;
fact = freq/bes0;
frq = bes1/fact;
level = EnvGen.kr(Env.new([0.011367, 0.000494, 0.011367, 0.013618, 0],[3.6, 22.6, 6.1, 2.0],[1,3,1,1]),doneAction: 2);
input = WhiteNoise.ar;
flt = BPF.ar(input,2* frq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,4*24);
Out.ar(out, uit)
}).add;
SynthDef(\bes0hoogfilt4, { |out = 0, pn=0,rq=0.03, lvl=6 |
var freq, level, input, uit, flt;
var bes0 = 57.246178 , bes1 = 3729.3100921447 , fact, frq;
freq = 2485.529053;
fact = freq/bes0;
frq = bes1/fact;
level = EnvGen.kr(Env.new([0.006703, 0.000144, 0.006703, 0.008532, 0],[3.65, 23.8, 5.85, 2.0],[-2, 4,2,1]),doneAction: 2);
input = WhiteNoise.ar;
flt = BPF.ar(input,2* frq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,4*24);
Out.ar(out, uit)
}).add;
SynthDef(\bes0hoogfilt5, { |out = 0, pn=0,rq=0.03, lvl=6 |
var freq, level, input, uit, flt;
var bes0 = 57.246178 , bes1 = 3729.3100921447 , fact, frq;
freq = 3311.020020;
fact = freq/bes0;
frq = bes1/fact;
level = EnvGen.kr(Env.new([0.002500, 0.000093, 0.002500, 0.005660, 0],[1.6, 18.25, 14.45, 2.0],-2),doneAction: 2);
input = BrownNoise.ar;
flt = BPF.ar(input,2* frq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,4*24);
Out.ar(out, uit)
}).add;
SynthDef(\bes0hoogfilt6, { |out = 0, pn=0,rq=0.03, lvl=6 |
var freq, level, input, uit, flt;
var bes0 = 57.246178 , bes1 = 3729.3100921447 , fact, frq;
freq = 3693.570801;
fact = freq/bes0;
frq = bes1/fact;
level = EnvGen.kr(Env.new([0.002070, 0.000068, 0.002070, 0.004951, 0],[1.5, 26.0, 2.58, 2.0],-2),doneAction: 2);
input = BrownNoise.ar;
flt = BPF.ar(input,2* frq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,4*24);
Out.ar(out, uit)
}).add;
SynthDef(\bes0hoogfilt7, { |out = 0, pn=0,rq=0.03, lvl=6 |
var freq, level, input, uit, flt;
var bes0 = 57.246178 , bes1 = 3729.3100921447 , fact, frq;
freq = 4546.268555;
fact = freq/bes0;
frq = bes1/fact;
level = EnvGen.kr(Env.new([0.000957, 0.000034, 0.000957, 0.005791, 0],[0.45, 29.85, 0.2, 2.0],[1,-2,-2,1]),doneAction: 2);
input = BrownNoise.ar;
flt = BPF.ar(input,2* frq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,4*24);
Out.ar(out, uit)
}).add;
SynthDef(\bes0hoogfilt8, { |out = 0, pn=0,rq=0.03, lvl=6 |
var freq, level, input, uit, flt;
var bes0 = 57.246178 , bes1 = 3729.3100921447 , fact, frq;
freq = 4852.927246;
fact = freq/bes0;
frq = bes1/fact;
level = EnvGen.kr(Env.new([0.002107, 0.000063, 0.002107, 0.005053, 0],[1.6, 19.2, 9.2, 2.0],[-2,2,3,1]),doneAction: 2);
input = BrownNoise.ar;
flt = BPF.ar(input,2* frq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,4*24);
Out.ar(out, uit)
}).add;
SynthDef(\bes0hoogfilt9, { |out = 0, pn=0,rq=0.03, lvl=6 |
var freq, level, input, uit, flt;
var bes0 = 57.246178 , bes1 = 3729.3100921447 , fact, frq;
freq = 5461.421387;
fact = freq/bes0;
frq = bes1/fact;
level = EnvGen.kr(Env.new([0.000938, 0.000034, 0.000938, 0.003947, 0],[0.7, 27.05, 4.55, 2.0],[1,-3,2,1]),doneAction: 2);
input = BrownNoise.ar;
flt = BPF.ar(input,2* frq,0.01, level*lvl);
uit = Pan2.ar(flt,pn,4*24);
Out.ar(out, uit)
}).add;
)
////////sequens //rand werkt niet, moet zijn Prand en een sequens waar je uit kiest
(
h=Pbind(\instrument, \bes0hoogfilt1,
\pn, Prand([0.0,0.2,0.4,0.6,0.7,0.9,1.0],inf),
\lvl, Prand([5.0,5.7, 6.0,6.5, 6.9],inf),
\dur, (2.4+ 17.7+ 8.2)).play;
i=Pbind(\instrument, \bes0hoogfilt2,
\pn, Prand([0.0,0.1,0.3,0.5,0.6,0.8,1.0],inf),
\lvl, Prand([5.0, 5.7, 6.0, 6.3, 7.0],inf),
\dur, (2.6+ 18.85+ 8.05)).play;
j=Pbind(\instrument, \bes0hoogfilt3,
\pn, Prand([0.0,0.2,0.4,0.6,0.7,0.9,1.0],inf),
\lvl, Prand([5.0, 5.7, 6.0, 6.3, 7.0],inf),
\dur, (3.6+ 22.6+ 6.1)).play;
k=Pbind(\instrument, \bes0hoogfilt4,
\pn, Prand([0.0,0.1,0.3,0.5,0.6,0.8,1.0],inf),
\lvl, Prand([5.0, 5.5, 6.0, 6.5, 7.0],inf),
\dur, (3.65+ 23.8+ 5.85)).play;
l=Pbind(\instrument, \bes0hoogfilt5,
\pn, Prand([0.0,0.2,0.4,0.6,0.7,0.9,1.0],inf),
\lvl, Prand([5.0, 5.5, 6.0, 6.5, 7.0],inf),
\dur, (1.6+ 18.25+ 14.45)).play;
m=Pbind(\instrument, \bes0hoogfilt6,
\pn, Prand([0.0,0.1,0.3,0.5,0.6,0.8,1.0],inf),
\lvl, Prand([5.0, 5.7, 6.0, 6.3, 7.0],inf),
\dur, (1.5+ 26.0+ 2.58)).play;
n=Pbind(\instrument, \bes0hoogfilt7,
\pn, Prand([0.0,0.2,0.4,0.6,0.7,0.9,1.0],inf),
\lvl, Prand([5.0, 5.5, 6.0, 6.5, 7.0],inf),
\dur, (0.45+ 29.85+ 0.2)).play;
o=Pbind(\instrument, \bes0hoogfilt8,
\pn, Prand([0.0,0.1,0.3,0.5,0.6,0.8,1.0],inf),
\lvl, Prand([5.0, 5.5, 6.0, 6.5, 7.0],inf),
\dur, (1.6+ 19.2+ 9.2)).play;
p=Pbind(\instrument, \bes0hoogfilt9,
\pn, Prand([0.0,0.2,0.4,0.6,0.7,0.9,1.0],inf),
\lvl, Prand([5.0, 5.7, 6.0, 6.3, 7.0],inf),
\dur, (0.7+ 27.05+ 4.55)).play;
)
h.play;
i.play;
j.play;
k.play;
l.play;
m.play;
n.play;
o.play;
p.play;
h.stop; i.stop; j.stop; k.stop; l.stop; m.stop; n.stop; o.stop; p.stop;
s.quit;
This will create sounds like:
Bes0-filterLosHgsub.wav
Bes0-filterLosLgSubOkt.wav
Bes0-filterLosMidsub.wav
Bes1-subMidhg.wav
Notice that these sounds have a sort of minor flavoring instead of the
more major sounds of the original patches.
Another character of these sounds are that the lower you get, the
denser and louder the sounds become. That is because in a sub-harmonic
array the partials far away from the basic (high) frequency the
distance between the individual partials is ever decreasing, thus
creating
a sort of cluster in the lowest part. Listen to this example:
Bes0-subLg0.wav
The sounds created with SPEAR and SUPERCOLLIDER provide the basic
-harmonic- sound of "Doorschemering', for special effects I used
another technique with CERES3 and CSOUND, as described in the next part
of this article.
CERES3, C-PROGRAM AND CSOUND
For sounds more directly derived from chords or melodic gestures, I
used another technique to abstract sounds from original recordings.
This is a technique I 10 years ago for my improvisations and
compositions with Arie van Schutterhoef.
You can create effects like this:
Doorschemering_Csound_dialogue.wav
The basic procedure is this:
-I analyze a recorded sounds with CERES3. This is a program developed
at the Notam in Norway by Oyvind Hammer and later extended by Stanko
Juzbasic. I run this program on a Sillican Graphics computer as I do
not have a Mac OSX or Linux version. With this program you can also do
a Fast Fourier Analysis and export the result to a format you can use.
In this case I export the result, after reducing the amount of data
drastically by using the 'sieve' selection-function, as a csound-file.
Although I reduce the data beforehand, the resulting sound score-file
can be huge. That is because for every slice of the sound you will get
a complete set of instrument-calls for all the frequencies that make up
the sound. Every call with its own frequency and loudness data, the
starting point and length are the same for all calls in one slice. The
length of the slice depend on your 'window-length' of your specific
Fourier Analysis.
The resulting Csound-score could be used to recreate the sound, but
that is not what I really want. I wanted to change one aspect of sound:
changing its length.
For this process, Pieter Suurmond, wrote for me a short C-program to
manipulate some aspects of the Csound-score: The starting point and the
length of an instrument call:
by multiplication the starting point and the length with my stretch
factor I get the desired stretched sound.
But there is more to it:
-As all calls from one slice start at the same time, you can always
hear this stuttering as a new slice starts. This artifact common of
Fourier Analysis and re-synthesizing can be bypassed by adding a small
random to the starting point of every call.
-To perfectly recreate the sound in Csound, you theoretically would use
a gaussian envelope. Pieter has created such an envelope for me, but
the effective part is only 1/5 of the total envelope, the rest is
mostly silence. So the length has to be multiplied by 5. And a small
random-amount can make the sound a bit smoother.
-Some small effect: get rid of the annoying comma-point confusion in
Dutch-language computers; erasing to high and too low frequencies;
erase too soft sounds.
An example of such a C-program can be found here:
/*
COPYLEFT 2005 - Pieter Suurmond en Hans van Eck.
Manipuleert CSOUND score files.
Compile with
gcc -O3 -o 5gaussHE 5gaussHE.c -lm
*/
#include /* Voor printf() enzo. */
#include /* Voor rand() / drand48(). */
/* Als drand48 niet aanwezig mocht zijn (Mac?). */
static double random_0_1()
{
return (double)(rand() & 32767) / 32768.0;
}
#define MAX_LINE_LENGTH 1024
#define MAX_NUM_COLUMNS 32
int main ()
{
char *infile = "invoer", /* Name (padnaam) of the input-file. */
*outfile = "uitvoer"; /* Naam (padnaam) of the output-file. */
FILE *infileptr, *outfileptr;
if ((infileptr = fopen(infile, "rt")))
{
if ((outfileptr = fopen(outfile, "wt")))
{
char linebuff[MAX_LINE_LENGTH + 1];
char *column[MAX_NUM_COLUMNS]; /* Buffer for all columns in 1 row. */
long linenumber = 1;
printf("\n\"%s\" --> \"%s\".\n", infile, outfile);
while (fgets(linebuff, MAX_LINE_LENGTH, infileptr)) /* Read 1023 chars (also \n !). */
/* Assume last char = always \n. */
{
short w, c = 0;
char *i = linebuff;
/* clean array column[]. */
for (w = 0; w < max_num_columns; w++)
column[w] = ""; /* empty string. */
/* First read all columns, in array column[] as text. */
column[c++] = i;
while (*i) /* As long as there are signs. */
{
if (*i <= ' ') /* Spaces and tabs are accepted as seperating signs! */
{
*i++ = 0;
while (*i && (*i <= ' '))
i++;
column[c++] = i;
if (c >= MAX_NUM_COLUMNS)
{
printf("FALSE: too many columns!\n");
exit(1);
}
}
else if (*i <= ',') /* Replace all comma's by dots. */
*i++ = '.';
else
i++;
}
/* Print all columns to output. */
if ((atof(column[3]) > 43.3) && /* Fourth column larger than threshold. */
(atof(column[4]) > 20.0) && /* Fifth column between 20 en 16k. */
(atof(column[4]) < 16000.0) /* only than action. */
)
{
for (w = 0; w < c; w++)
{
/* manipulate every 2nd column, starting time. */
if (w == 1)
{
double d = atof(column[w]); /* String to double. */
d = (d * 5.0) + (0.046 * drand48()); /* Or function drand48(). on SGI*/
fprintf(outfileptr, "%.4f ", d); /* 4 decimals. */
}
/* Manipulate every 3rd column, length of the instrument call. */
else if (w == 2)
{
double d = atof(column[w]);
d = (d * 22.5) + (d * 5.00 * drand48()); /* Or function drand48(). on SGI*/
fprintf(outfileptr, "%.4f ", d); /* 4 decimals. */
}
/* Else the original. */
else
fprintf(outfileptr, "%s ", column[w]);
}
fprintf(outfileptr, "\n"); /* End of line after all columns. */
}
else
printf("Skipped line %ld.\n", linenumber);
linenumber++; /* Line number output. */
}
fclose(outfileptr);
}
else
printf("\nKan bestand \"%s\" niet aanmaken!\n", outfile);
fclose(infileptr);
}
else
printf("\nCan not open \"%s\" file!\n", infile);
printf("Ready.\n\n");
return 0; /* Always give a 0 to the OS: all went OK. */
}
The used Csound orchestra
can be rather simple.
You can realize the sound with a sine-wave or some other wave (I use
the triangle wave a lot), or with filtered noise; as envelope you can
use the above mentioned gaussian envelope or create some other linear
or exponential envelope. As an example a noise-orchestra (used a lot
for this composition) with the gaussian envelope:
;-----------------------------------------------------------------------------------------
; Pieter Suurmond, Amersfoort, 29 dec 1998 - 14 mei 1999.
;-----------------------------------------------------------------------------------------
sr=44100
kr=4410
ksmps=10
nchnls=1
giwortel = 2.5 * sqrt(2); Effective duration is 0.2 * p3.
;-------------------------------------- GAUSSIAN ENVELOPE PLAYER ---------------------
instr 1
iluid init p4
ifreq init p5
ifund init 44100/4096
ibin init ifreq/ifund
iwide init ibin/(ibin+1)
aruis rand p4
anoise oscili aruis, ifreq, 2
a1 butterbp anoise, ifreq, ifund*iwide
k line -giwortel, p3, giwortel; Buigpunten na 0.4 en 0.6 maal p3, top op 0.5 maal p3.
katt = p5 * exp (- k * k); p3 = totale tijdsduur in seconden.
a3 = a1 * katt
out a3
endin
This procedure take a long time for the computer to calculate, as the
score-files of the Csound patch are very long. On my older machines it
took hours to calculate one file, and sometimes after this and I listen
and "Hm, not very interesting, again with different settings". And then
the procedure starts again. For the patient ones among us.
Some sound examples, who are OK'ed:
Glissandi on the piano:
gliss3-droogLgauss.wav
Original and recreated glissandi:
gliss18-donker-lichtRGN.wav
gliss18-donker-lichtRgauss.wav
Melodic line using pen on the strings with the recreated sound, now
linear envelope instead of gaussian, oscillators instead of filtered
noise:
Sound_Examples/SnaarTiks.wav
SnaartiksLinear10osc.wav
EVALUATION
The nice thing of this approach in the creation of the sounds for sound
tracks is that I was able to make really special sounds using only
software that is completely free. The only commercial program I used is
'Logic 8' to mix the sounds together and apply a little equalizer to
get rid of some annoying high hiss (thanks to Pieter with his sharp ear
to point me to this problem).
For next compositions I will see if this procedure can be useful again. If someone has some tips for me please let me know.
CERES3 for Mac OSX, yes that would be great.
Hans van Eck,
2015
for
scores and
performing materials e-mail: Hans.composer@gmail.com
Top