Python For Audio Signal Processing

John GLOVER, Victor LAZZARINI and Joseph TIMONEY

The Sound and Digital Music Research Group
National University of Ireland, Maynooth
Ireland
{John.C.Glover, Victor.Lazzarini}@nuim.ie
JTimoney@cs.nuim.ie

Abstract matrices of numerical data, and includes imple-

This paper discusses the use of Python for develop- mentations of many standard signal processing
ing audio signal processing applications. Overviews techniques. The major downside to MATLAB
of Python language, NumPy, SciPy and Matplotlib is that it is not free and not open source, which
are given, which together form a powerful platform is a considerable problem for researchers who
for scientific computing. We then show how SciPy want to share code and collaborate. GNU
was used to create two audio programming libraries, Octave [Eaton, 2002] is an open source alter-
and describe ways that Python can be integrated native to MATLAB. It is an interpreted lan-
with the SndObj library and Pure Data, two exist- guage with a syntax that is very similar to
ing environments for music composition and signal
processing.
MATLAB, and it is possible to write scripts that
will run on both systems. However, with both
Keywords MATLAB and Octave this increase in short-
term productivity comes at a cost. For any-
Audio, Music, Signal Processing, Python, thing other than very basic tasks, tools such as
Programming integrated development environments (IDEs),
debuggers and profilers are certainly a useful
1 Introduction resource if not a requirement. All of these
There are many problems that are common to a tools exist in some form for MATLAB/Octave,
wide variety of applications in the field of audio but users must invest a considerable amount
signal processing. Examples include procedures of time in learning to use a programming lan-
such as loading sound files or communicating guage and a set of development tools that have
between audio processes and sound cards, as a relatively limited application domain when
well as digital signal processing (DSP) tasks compared with general purpose programming
such as filtering and Fourier analysis [Allen and languages. It is also generally more difficult
Rabiner, 1977]. It often makes sense to rely on to integrate MATLAB/Octave programs with
existing code libraries and frameworks to per- compositional tools such as Csound [Vercoe et
form these tasks. This is particularly true in al., 2011] or Pure Data [Puckette, 1996], or
the case of building prototypes, a practise com- with other technologies such as web frameworks,
mon to both consumer application developers cloud computing platforms and mobile applica-
and scientific researchers, as these code libraries tions, all of which are becoming increasingly im-
allows the developer to focus on the novel as- portant in the music industry.
pects of their work. For developing and prototyping audio signal
Audio signal processing libraries are available processing applications, it would therefore be
for general purpose programming languages advantageous to combine the power and flexi-
such as the GNU Scientific Library (GSL) for bility of a widely adopted, open source, general
C/C++ [Galassi et al., 2009], which provides a purpose programming language with the quick
comprehensive array of signal processing tools. development process that is possible when using
However, it generally takes a lot more time to interpreted languages that are focused on signal
develop applications or prototypes in C/C++ processing applications. Python [van Rossum
than in a more lightweight scripting language. and Drake, 2006], when used in conjunction
This is one of the reasons for the popularity with the extension modules NumPy [Oliphant,
of tools such as MATLAB [MathWorks, 2010], 2006], SciPy [Jones et al., 2001] and Matplotlib
which allow the developer to easily manipulate [Hunter, 2007] has all of these characteristics.
 Section 2 provides a brief overview of the that make use of these packages are given in
Python programming language. In Section 3 we Section 3.2.
discuss NumPy, SciPy and Matplotlib, which
3.1 NumPy, SciPy and Matplotlib
add a rich set of scientific computing functions
to the Python language. Section 4 describes Python’s scientific computing prowess comes
two libraries created by the authors that rely largely from the combination of three re-
on SciPy, Section 5 shows how these Python lated extension modules: NumPy, SciPy and
programs can be integrated with other software Matplotlib. NumPy [Oliphant, 2006] adds
tools for music composition, with final conclu- a homogenous, multidimensional array object
sions given in Section 6. to Python. It also provides functions that
perform efficient calculations based on array
2 Python data. NumPy is written in C, and can be ex-
tended easily via its own C-API. As many ex-
Python is an open source programming lan-
isting scientific computing libraries are written
guage that runs on many platforms including
in Fortran, NumPy comes with a tool called
Linux, Mac OS X and Windows. It is widely
f2py which can parse Fortran files and create
used and actively developed, has a vast array of
a Python extension module that contains all
code libraries and development tools, and inte-
the subroutines and functions in those files as
grates well with many other programming lan-
callable Python methods.
guages, frameworks and musical applications.
SciPy builds on top of NumPy, providing
Some notable features of the language include:
modules that are dedicated to common issues
• It is a mature language and allows for pro- in scientific computing, and so it can be com-
gramming in several different paradigms in- pared to MATLAB toolboxes. The SciPy mod-
cluding imperative, object-orientated and ules are written in a mixture of pure Python,
functional styles. C and Fortran, and are designed to operate ef-
• The clean syntax puts an emphasis on pro- ficiently on NumPy arrays. A complete list of
ducing well structured and readable code. SciPy modules is available online at
Python source code has often been com- http://docs.scipy.org, but examples include:
pared to executable pseudocode. File input/output (scipy.io): Provides
• Python provides an interactive interpreter, functions for reading and writing files in
which allows for rapid code development, many different data formats, including
prototyping and live experimentation. .wav, .csv and matlab data files (.mat).
• The ability to extend Python with modules Fourier transforms (scipy.fftpack):
written in C/C++ means that functional- Contains implementations of 1-D and
ity can be quickly prototyped and then op- 2-D fast Fourier transforms, as well as
timised later. Hilbert and inverse Hilbert transforms.
• Python can be embedded into existing ap- Signal processing (scipy.signal): Provides
plications. implementations of many useful signal
• Documentation can be generated automat- processing techniques, such as waveform
ically from the comments and source code. generation, FIR and IIR filtering and
• Python bindings exist for cross-platform multi-dimensional convolution.
GUI toolkits such as Qt [Nokia, 2011]. Interpolation (scipy.interpolate): Consists
• The large number of high-quality library of linear interpolation functions and cubic
modules means that you can quickly build splines in several dimensions.
sophisticated programs.
Matplotlib is a library of 2-dimensional plot-
A complete guide to the language, including ting functions that provides the ability to
a comprehensive tutorial is available online at quickly visualise data from NumPy arrays, and
http://python.org. produce publication-ready figures in a variety
of formats. It can be used interactively from
3 Python for Scientific Computing the Python command prompt, providing sim-
Section 3.1 provides an overview of three pack- ilar functionality to MATLAB or GNU Plot
ages that are widely used for performing ef- [Williams et al., 2011]. It can also be used in
ficient numerical calculations and data visu- Python scripts, web applications servers or in
alisation using Python. Example programs combination with several GUI toolkits.
3.2 SciPy Examples tion is used to compute a 1024 point Hanning
Listing 1 shows how SciPy can be used to read window, which is then applied to the first 1024
in the samples from a flute recording stored in flute samples in line 12. The FFT is computed
a file called flute.wav, and then plot them using in line 14, with the complex coefficients con-
Matplotlib. The call to the read function on line verted into polar form and the magnitude val-
5 returns a tuple containing the sampling rate ues stored in the variable mags. The magnitude
of the audio file as the first entry and the audio values are converted from a linear to a decibel
samples as the second entry. The samples are scale in line 16, then normalised to have a max-
stored in a variable called audio, with the first imum value of 0 dB in line 18. In lines 20-26
1024 samples being plotted in line 8. In lines the magnitude values are plotted and displayed.
10, 11 and 13 the axis labels and the plot title The resulting image is shown in Figure 2.
are set, and finally the plot is displayed in line 1 import scipy
15. The image produced by Listing 1 is shown 2 from scipy.io.wavfile import read
in Figure 1. 3 from scipy.signal import hann

4 from scipy.fftpack import rfft

1 from scipy.io.wavfile import read
5 import matplotlib.pyplot as plt
2 import matplotlib.pyplot as plt
6
3

4 # read audio samples 7 # read audio samples

5 input_data = read("flute.wav")
8 input_data = read("flute.wav")
9 audio = input_data[1]
6 audio = input_data[1]
10 # apply a Hanning window
7 # plot the first 1024 samples
11 window = hann(1024)
8 plt.plot(audio[0:1024])
12 audio = audio[0:1024] * window
9 # label the axes
13 # fft
10 plt.ylabel("Amplitude")
14 mags = abs(rfft(audio))
11 plt.xlabel("Time (samples)")
15 # convert to dB
12 # set the title
16 mags = 20 * scipy.log10(mags)
13 plt.title("Flute Sample")
17 # normalise to 0 dB max
14 # display the plot
18 mags -= max(mags)
15 plt.show()
19 # plot
Listing 1: Plotting Audio Files
20 plt.plot(mags)

21 # label the axes

22 plt.ylabel("Magnitude (dB)")

23 plt.xlabel("Frequency Bin")

24 # set the title

25 plt.title("Flute Spectrum")

26 plt.show()

Listing 2: Plotting a magnitude spectrum

4 Audio Signal Processing With

Python
This section gives an overview of how SciPy is
used in two software libraries that were created
by the authors. Section 4.1 gives an overview
of Simpl [Glover et al., 2009], while Section 4.2
introduces Modal, our new library for musical
Figure 1: Plot of audio samples, generated by
note onset detection.
the code given in Listing 1.
4.1 Simpl
Simpl 1 is an open source library for sinusoidal
In Listing 2, SciPy is used to perform a Fast modelling [Amatriain et al., 2002] written in
Fourier Transform (FFT) on a windowed frame C/C++ and Python. The aim of this project is
of audio samples then plot the resulting magni-
1
tude spectrum. In line 11, the SciPy hann func- Available at http://simplsound.sourceforge.net
 ples. Simpl also includes a module with plotting
functions that use Matplotlib to plot analysis
data from the peak detection and partial track-
ing analysis phases.
An example Python program that uses Simpl
is given in Listing 3. Lines 6-8 read in the first
4096 sample values of a recorded flute note. As
the default hop size is 512 samples, this will
produce 8 frames of analysis data. In line 10 a
SndObjPeakDetection object is created, which
detects sinusoidal peaks in each frame of audio
using the algorithm from The SndObj Library
[Lazzarini, 2001]. The maximum number of de-
tected peaks per frame is limited to 20 in line
Figure 2: Flute magnitude spectrum produced 11, before the peaks are detected and returned
from code in Listing 2. in line 12. In line 15 a MQPartialTracking ob-
ject is created, which links previously detected
to tie together many of the existing sinusoidal sinusoidal peaks together to form partials, us-
modelling implementations into a single unified ing the McAulay-Quatieri algorithm [McAulay
system with a consistent API, as well as provide and Quatieri, 1986]. The maximum number of
implementations of some recently published si- partials is limited to 20 in line 16 and the par-
nusoidal modelling algorithms. Simpl is primar- tials are detected and returned in line 17. Lines
ily intended as a tool for other researchers in 18-25 plot the partials, set the figure title, label
the field, allowing them to easily combine, com- the axes and display the final plot as shown in
pare and contrast many of the published analy- Figure 3.
sis/synthesis algorithms.
Simpl breaks the sinusoidal modelling pro- 1 import simpl
cess down into three distinct steps: peak de- 2 import matplotlib.pyplot as plt
tection, partial tracking and sound synthesis. 3 from scipy.io.wavfile import read
The supported sinusoidal modelling implemen- 4
tations have a Python module associated with 5 # read audio samples
every step which returns data in the same for- 6 audio = read("flute.wav")[1]
mat, irrespective of its underlying implementa- 7 # take just the first few frames
tion. This allows analysis/synthesis networks to 8 audio = audio[0:4096]
be created in which the algorithm that is used 9 # Peak detection with SndObj
for a particular step can be changed without 10 pd = simpl.SndObjPeakDetection()
effecting the rest of the network. Each object 11 pd.max_peaks = 20
has a method for real-time interaction as well as 12 pks = pd.find_peaks(audio)
non-real-time or batch mode processing, as long 13 # Partial Tracking with
as these modes are supported by the underlying 14 # the McAulay-Quatieri algorithm
algorithm. 15 pt = simpl.MQPartialTracking()
All audio in Simpl is stored in NumPy ar- 16 pt.max_partials = 20
rays. This means that SciPy functions can be 17 partls = pt.find_partials(pks)
used for basic tasks such as reading and writ- 18 # plot the detected partials
ing audio files, as well as more complex pro- 19 simpl.plot.plot_partials(partls)
cedures such as performing additional process- 20 # set title and label axes
ing, analysis or visualisation of the data. Audio 21 plt.title("Flute Partials")
samples are passed into a PeakDetection ob- 22 plt.ylabel("Frequency (Hz)")
ject for analysis, with detected peaks being re- 23 plt.xlabel("Frame Number")
turned as NumPy arrays that are used to build 24 plt.show()
a list of Peak objects. Peaks are then passed to
PartialTracking objects, which return partials Listing 3: A Simpl example
that can be transferred to Synthesis objects to
create a NumPy array of synthesised audio sam-
 Modal makes extensive use of SciPy, with
NumPy arrays being used to contain audio sam-
ples and analysis data from multiple stages of
the onset detection process including computed
onset detection functions, peak picking thresh-
olds and the detected onset locations, while
Matplotlib is used to plot the analysis results.
All of the onset detection algorithms were writ-
ten in Python and make use of SciPy’s signal
processing modules. The most computationally
expensive part of the onset detection process
is the calculation of the onset detection func-
tions, so Modal also includes C++ implemen-
tations of all onset detection function modules.
These are made into Python extension modules
Figure 3: Partials detected in the first 8 frames using SWIG [Beazley, 2003]. As SWIG exten-
of a flute sample, produced by the code in sion modules can manipulate NumPy arrays,
Listing 3. Darker colours indicate lower am- the C++ implementations can be seamlessly
plitude partials. interchanged with their pure Python counter-
parts. This allows Python to be used in ar-
4.2 Modal eas that it excels in such as rapid prototyping
Modal 2 is a new open source library for musi- and in “glueing” related components together,
cal onset detection, written in C++ and Python while languages such as C and C++ can be used
and released under the terms of the GNU later in the development cycle to optimise spe-
General Public License (GPL). Modal consists cific modules if necessary.
of two main components: a code library and a Listing 4 gives an example that uses Modal,
database of audio samples. The code library with the resulting plot shown in Figure 4. In
includes implementations of three widely used line 12 an audio file consisting of a sequence
onset detection algorithms from the literature of percussive notes is read in, with the sample
and four novel onset detection systems created values being converted to floating-point values
by the authors. The onset detection systems between -1 and 1 in line 14. The onset detection
can work in a real-time streaming situation as process in Modal consists of two steps, creating
well as in non-real-time. For more information a detection function from the source audio and
on onset detection in general, a good overview then finding onsets, which are peaks in this de-
is given in Bello et al. (2005). tection function that are above a given thresh-
The sample database contains a collection of old value. In line 16 a ComplexODF object is
audio samples that have creative commons li- created, which calculates a detection function
censing allowing for free reuse and redistribu- based on the complex domain phase and energy
tion, together with hand-annotated onset loca- approach described by Bello et al. (2004). This
tions for each sample. It also includes an appli- detection function is computed and saved in
cation that allows for the labelling of onset loca- line 17. Line 19 creates an OnsetDetection ob-
tions in audio files, which can then be added to ject which finds peaks in the detection function
the database. To the best of our knowledge, this that are above an adaptive median threshold
is the only freely distributable database of au- [Brossier et al., 2004]. The onset locations are
dio samples together with their onset locations calculated and saved on lines 21-22. Lines 24-42
that is currently available. The Sound Onset plot the results. The figure is divided into 2 sub-
Labellizer [Leveau et al., 2004] is a similar ref- plots, the first (upper) plot shows the original
erence collection, but was not available at the audio file (dark grey) with the detected onset lo-
time of publication. The sample set used by cations (vertical red dashed lines). The second
the Sound Onset Labellizer also makes use of (lower) plot shows the detection function (dark
files from the RWC database [Goto et al., 2002], grey) and the adaptive threshold value (green).
which although publicly available is not free and
1 from modal.onsetdetection \
does not allow free redistribution.
2 import OnsetDetection
2
Available at http://github.com/johnglover/modal 3 from modal.detectionfunctions \
 4 import ComplexODF
5 from modal.ui.plot import \
6 (plot_detection_function,
7 plot_onsets)
8 import matplotlib.pyplot as plt

9 from scipy.io.wavfile import read

10

11 # read audio file

12 audio = read("drums.wav")[1]
13 # values between -1 and 1

14 audio = audio / 32768.0

15 # create detection function

16 codf = ComplexODF()

17 odf = codf.process(audio)

18 # create onset detection object

19 od = OnsetDetection()

20 hop_size = codf.get_hop_size()

21 onsets = od.find_onsets(odf) * \

22 hop_size
23 # plot onset detection results

24 plt.subplot(2,1,1)

25 plt.title("Audio And Detected "

26 "Onsets")
27 plt.ylabel("Sample Value")

28 plt.xlabel("Sample Number")

29 plt.plot(audio, "0.4")
Figure 4: The upper plot shows an audio sam-
30 plot_onsets(onsets)
ple with detected onsets indicated by dashed
31 plt.subplot(2,1,2)
red lines. The lower plot shows the detection
32 plt.title("Detection Function "
function that was created from the audio file (in
33 "And Threshold") grey) and the peak picking threshold (in green).
34 plt.ylabel("Detection Function "

35 "Value") to and from objects in the library, allowing data

36 plt.xlabel("Sample Number")
to be easily exchanged between SndObj and
37 plot_detection_function(odf,
SciPy audio processing functions. An example
38 hop_size) of this is shown in Listing 5. An audio file is
39 thresh = od.threshold
loaded in line 8, then the scipy.signal module
40 plot_detection_function(thresh,
is used to low-pass filter it in lines 10-15. The
41 hop_size, filter cutoff frequency is given as 0.02, with 1.0
42 "green") being the Nyquist frequency. A SndObj called
43 plt.show()
obj is created in line 21 that will hold frames
of the output audio signal. In lines 24 and 25,
Listing 4: Modal example a SndRTIO object is created and set to write
the contents of obj to the default sound output.
5 Integration With Other Music Finally in lines 29-33, each frame of audio is
Applications taken, copied into obj and then written to the
This section provides examples of SciPy inte- output.
gration with two established tools for sound
design and composition. Section 5.1 shows 1 from sndobj import \
SciPy integration with The SndObj Library, 2 SndObj, SndRTIO, SND_OUTPUT
3 import scipy as sp
with Section 5.2 providing an example of using
4 from scipy.signal import firwin
SciPy in conjunction with Pure Data.
5 from scipy.io.wavfile import read
5.1 The SndObj Library 6

The most recent version of The SndObj Library 7 # read audio file
comes with support for passing NumPy arrays 8 audio = read("drums.wav")[1]
 9 # use SciPy to low pass filter 8 sampling_rate = 44100
10 order = 101 9 # open a Pure Data patch
11 cutoff = 0.02 10 m = pd.PdManager(num_chans,

12 filter = firwin(order, cutoff) 11 num_chans,

13 audio = sp.convolve(audio, 12 sampling_rate,
14 filter, 13 1)
15 "same") 14 p_name = "ring_mod.pd"

16 # convert to 32-bit floats 15 patch = \

17 audio = sp.asarray(audio, 16 pd.libpd_open_patch(p_name)

18 sp.float32) 17 # get the default frame size

19 # create a SndObj that will hold 18 f_size = pd.libpd_blocksize()

20 # frames of output audio 19 # read audio file

21 obj = SndObj() 20 audio = read("drums.wav")[1]

22 # create a SndObj that will 21 # process each frame

23 # output to the sound card 22 i = 0

24 outp = SndRTIO(1, SND_OUTPUT) 23 out = sp.array([], dtype=int16)

25 outp.SetOutput(1, obj) 24 while i < len(audio):

26 # get the default frame size 25 f = audio[i:i+f_size]

27 f_size = outp.GetVectorSize() 26 p = m.process(f)
28 # output each frame 27 p = sp.fromstring(p, int16)
29 i = 0 28 out = sp.hstack((out, p))
30 while i < len(audio): 29 i += f_size
31 obj.PushIn(audio[i:i+f_size]) 30 # close the patch

32 outp.Write() 31 pd.libpd_close_patch(patch)

33 i += f_size 32 # write the audio file to disk

Listing 5: The SndObj Library and SciPy 33 write("out.wav", 44100, out)

Listing 6: Pure Data and SciPy

5.2 Pure Data
The recently released libpd 3 allows Pure Data
to be embedded as a DSP library, and comes 6 Conclusions
with a SWIG wrapper enabling it to be loaded This paper highlighted just a few of the many
as a Python extension module. Listing 6 shows features that make Python an excellent choice
how SciPy can be used in conjunction with libpd for developing audio signal processing applica-
to process an audio file and save the result to tions. A clean, readable syntax combined with
disk. In lines 7-13 a PdManager object is cre- an extensive collection of libraries and an unre-
ated, that initialises libpd to work with a single strictive open source license make Python par-
channel of audio at a sampling rate of 44.1 KHz. ticularly well suited to rapid prototyping and
A Pure Data patch is opened in lines 14-16, fol- make it an invaluable tool for audio researchers.
lowed by an audio file being loaded in line 20. This was exemplified in the discussion of two
In lines 22-29, successive audio frames are pro- open source signal processing libraries created
cessed using the signal chain from the Pure Data by the authors that both make use of Python
patch, with the resulting data converted into an and SciPy: Simpl and Modal. Python is easy to
array of integer values and appended to the out extend and integrates well with other program-
array. Finally, the patch is closed in line 31 and ming languages and environments, as demon-
the processed audio is written to disk in line 33. strated by the ability to use Python and SciPy
1 import scipy as sp in conjunction with established tools for audio
2 from scipy import int16 signal processing such as The SndObj Library
3 from scipy.io.wavfile import \ and Pure Data.
4 read, write
5 import pylibpd as pd 7 Acknowledgements
6

7 num_chans = 1 The authors would like to acknowledge the gen-

erous support of An Foras Feasa, who funded
3
Available at http://gitorious.org/pdlib/libpd this research.
References John D. Hunter. 2007. Matplotlib: A 2D
J.B. Allen and L.R. Rabiner. 1977. A unified graphics environment. Computing In Science
approach to short-time Fourier analysis and & Engineering, 9(3):90–95, May-Jun.
synthesis. Proceedings of the IEEE, 65(11), Eric Jones, Travis Oliphant, Pearu Peterson,
November. et al. 2001. SciPy: Open source scientific
X. Amatriain, Jordi Bonada, A. Loscos, and tools for Python. http://www.scipy.org (last
Xavier Serra, 2002. DAFx - Digital Audio accessed 17-02-2011).
Effects, chapter Spectral Processing, pages Victor Lazzarini. 2001. Sound processing
373–438. John Wiley and Sons. with The SndObj Library: An overview. In
David M. Beazley. 2003. Automated Proceedings of the COST G-6 Conference on
scientific software scripting with SWIG. Digital Audio Effects (DAFX-01), University
Future Generation Computer Systems - Tools of Limerick, Ireland, December.
for Program Development and Analysis, Piere Leveau, Laurent Daudet, and Gael
19(5):599–609, July. Richard. 2004. Methodology and tools for
Juan Pablo Bello, Chris Duxbury, Mike the evaluation of automatic onset detec-
Davies, and Mark Sandler. 2004. On the use tion algorithms in music. In Proceedings of
of phase and energy for musical onset detec- the 5th International Conference on Music
tion in the complex domain. IEEE Signal Information Retrieval (ISMIR), Barcelona,
Processing Letters, 11(6):553–556, June. Spain, October.
Juan Pablo Bello, Laurent Daudet, Samer The MathWorks. 2010. MATLAB
Abdallah, Chris Duxbury, Mike Davies, Release R2010b. The MathWorks, Natick,
and Mark Sandler. 2005. A Tutorial Massachusetts.
on Onset Detection in Music Signals.
IEEE Transactions on Speech and Audio Robert McAulay and Thomas Quatieri. 1986.
Processing, 13(5):1035–1047, September. Speech analysis/synthesis based on a sinu-
soidal representation. IEEE Transactions
Paul Brossier, Juan Pablo Bello, and Mark on Acoustics, Speech and Signal Processing,
Plumbley. 2004. Real-time temporal segmen- ASSP-34(4), August.
tation of note objects in music signals. In
Proceedings of the International Computer Nokia. 2011. Qt - a cross-platform application
Music Conference (ICMC’04), pages 458– and UI framework. http://qt.nokia.com (last
461. accessed 17-02-2011).
John W. Eaton. 2002. GNU Octave Manual. Travis Oliphant. 2006. Guide To NumPy.
Network Theory Limited, Bristol, UK. Trelgol Publishing, USA.
M. Galassi, J. Davies, J. Theiler, B. Gough, Miller Puckette. 1996. Pure Data. In
G. Jungman, P. Alken, M. Booth, and Proceedings of the International Computer
F. Rossi. 2009. GNU Scientific Library Music Conference (ICMC’96), pages 224–
Reference Manual. Network Theory Limited, 227, San Francisco, USA.
Bristol, UK, 3 edition. Guido van Rossum and Fred L. Drake. 2006.
John Glover, Victor Lazzarini, and Joseph Python Language Reference Manual. Network
Timoney. 2009. Simpl: A Python library Theory Limited, Bristol, UK.
for sinusoidal modelling. In Proceedings
Barry Vercoe et al. 2011. The Csound
of the 12th International Conference on
Reference Manual. http://www.csounds.com
Digital Audio Effects (DAFx-09), Como,
(last accessed 17-02-2011).
Italy, September.
Masataka Goto, Hiroki Hashiguchi, Takuichi Thomas Williams, Colin Kelley, et al. 2011.
Nishimura, and Ryuichi Oka. 2002. RWC Gnuplot. http://www.gnuplot.info (last ac-
music database: Popular, classical, and cessed 17-02-2011).
jazz music databases. In Proceedings of
the 3rd International Conference on Music
Information Retrieval (ISMIR 2002), pages
287–288, October.