~ Axoloti: a digital audio platform for makers

Currently, there is a crowd-funding campaign ongoing about Axoloti . Axoloti is a very cool project by Johannes Taelman. It is a stand alone audio processing unit that can be used as a synthesizer, groovebox, guitar effect pedal, as a part of a sound installation, or for about any other audio application you can think of.

Axeloti is controlled by a patcher environment and once it is programmed it operates as a stand alone unit. For more information, visit the Axoloti Website, watch the video below and and fund Axoloti.

Update: Good news everyone! Axoloti has been funded!

UGent

~ Using the Advantech USB-4716 Data Acquisition Module on a Linux System

Below some notes on installing and using the drivers for the Avandtech USB-4716 on Linux can be found. Since I was unable to find these instructions elsewhere and it took me some time to figure things out, it is perhaps of use to someone else. A similar approach should work for the following devices as well: pci1715, pci1724, pci1734, pci1752, pci1758, pcigpdc, usb4711a, usb4750, pci1711, pci1716, pci1727, pci1747, pci1753_mic3753_pcm3753i, pci1761_pcm3761i, pcm3810i, usb4716, usb4761, pci1714_pcie1744, pci1721, pci1730_pcm3730i, pci1750, pci1756, pci1762, usb4702_usb4704, usb4718

Download the linux driver for the Avandtech USB-4716 DAQ. If you are on a system that can install either deb or rpm use the driver_package. Unzip the package. The driver is split into two parts. A base driver biokernbase and a driver specific for the USB-4716 device, bio4716. The drivers are Linux kernel modules that need to installed. First the base driver needs to be installed, the order is important. After the base driver install the device specific deb kernel module. After a reboot or perhaps immediately this should be the result of executing lsmod | grep bio:

  




  
bio4716 23724 0
biokernbase 17983 1 bio4716
usbcore 128741 9 ehci_hcd,uhci_hcd,usbhid,usb_storage,snd_usbmidi_lib,snd_usb_audio,biokernbase,bio4716

A library to interface with the hardware is provided as a deb package as well. Install this library on your system.

Next download the the examples for the Avandtech USB-4716 DAQ. With the kernel modules installed the system is ready to test the examples in the provided examples directory. If you are using the Java code, make sure to set the java.library.path correctly.

UGent and Code

~ Audio Fingerprinting - Opportunities for digital musicology

The 27th of November, 2014 a lecture on audio fingerprinting and its applications for digital musicology will be given at IPEM. The lecture introduces audio fingerprinting, explains an audio fingerprinting technique and then goes on to explain how such algorithm offers opportunities for large scale digital musicological applications. Here you can download the slides about audio fingerprinting and its opportunities for digital musicology.

With the explained audio fingerprinting technique a specific form of very reliable musical structure analysis can be done. Below, in the figure section, an example of repetitive structure in the song Ribs Out is shown. Another example is comparing edits or versions of songs. Below, also in the figure section, the radio edit of Daft Punk’s Get Lucky is compared with the original version. Audio synchronization using fingerprinting is another application that is actively used in the field of digital musicology to align audio with extracted features.

Since acoustic fingerprinting makes structure analysis very efficiently it can be applied on a large scale (20k songs). The figure below shows that identical repetition is something that has been used more and more since the mid 1970’s. The trend probably aligns with the amount of technical knowledge needed to ‘copy and paste’ a snippet of music.

\
Fig: How much identical repetition is used in music, over the years.

The Panako audio fingerprinting system was used to generate data for these case studies. The lecture and this post are partly inspired by a blog post by Paul Brossier.

Music Information Retrieval, Computational musicology, UGent, and Presentation

get_lucky_radio_vs_original.ods, music_structure_analysis_ribs_out.ods, repetition_over_time.ods, and 2014.11.27.aucoustic_fingerprinting.pdf

~ ISMIR 2014 - Panako - A Scalable Acoustic Fingerprinting System Handling Time-Scale and Pitch Modification

At ISMIR 2014 i will present a paper on a fingerprinting system. ISMIR is the annual conference of the International Society for Music Information Retrieval is the world’s leading interdisciplinary forum on accessing, analyzing, and organizing digital music of all sorts. This years instalment takes place in Taipei, Taiwan. My contribution is a paper titled Panako - A Scalable Acoustic Fingerprinting System Handling Time-Scale and Pitch Modification, it will be presented during a poster session the 27th of October.

This paper presents a scalable granular acoustic fingerprinting system. An acoustic fingerprinting system uses condensed representation of audio signals, acoustic fingerprints, to identify short audio fragments in large audio databases. A robust fingerprinting system generates similar fingerprints for perceptually similar audio signals. The system presented here is designed to handle time-scale and pitch modifications. The open source implementation of the system is called Panako and is evaluated on commodity hardware using a freely available reference database with fingerprints of over 30,000 songs. The results show that the system responds quickly and reliably on queries, while handling time-scale and pitch modifications of up to ten percent.

The system is also shown to handle GSM-compression, several audio effects and band-pass filtering. After a query, the system returns the start time in the reference audio and how much the query has been pitch-shifted or time-stretched with respect to the reference audio. The design of the system that offers this combination of features is the main contribution of this paper.

The system is available, together with documentation and information on how to reproduce the results from the ISMIR paper, on the Panako website. Also available for download is the Panako poster (pdf), Panako ISMIR paper and the Panako poster (inkscape SVG).

ISMIR, Presentation, Research papers, UGent, Computational musicology, and Music Information Retrieval

panako_poster_portrait.svg, panako_poster.pdf, panako_poster.png, and ismir_2014_panako_fingerprinter.pdf

~ TarsosDSP PureData or MAX MSP external

It makes sense to connect TarsosDSP, a real-time audio processing library written in Java, with patcher environments such as Pure Data and Max/MSP. Both Pure Data and Max/MSP offer the capability to code object, or externals using Java. In Pure Data this is done using the pdj~ object, which should be compatible with the Max/MSP implementation. This post demonstrates a patch that connects an oscillator with a pitch tracking algorithm implemented in TarsosDSP.

To the left you can see the finished patch. When it is working an audio stream is generated using an oscillator. The frequency of the oscillator can be controlled. Subsequently the stream is send to the Java environment with the pdj bridge. The Java environment receives an array of floats, representing the audio. A pitch estimation algorithm tries to find the pitch of the audio represented by the buffer. The detected pitch is returned to the pd environment by means of outlet. In pd, the detected pitch is shown and used for auditory feedback.

  




  
PitchDetectionResult result = yin.getPitch(audioBuffer);
pitch = result.getPitch();
outlet(0, Atom.newAtom(pitch));

Please note that the pitch detection algorithm can handle any audio stream, not only pure sines. The example here demonstrates the most straightforward case. Using this method all algorithms implemented in TarsosDSP can be used in Pure Data. These range from onset detection to filtering, from audio effects to wavelet compression. For a list of features, please see the TarsosDSP github page. Here, the source for this patch implementing pitch tracking in pd can be downloaded. To run it, extract it to a directory and simply run the pitch.pd patch. Pure Data should load pdj~ automatically together with the classes present in the classes directory.

UGent and TarsosDSP

pd_tarsosdsp.png and tarsosdsp_pd_external.zip

~ TarsosDSP on Android - Audio Processing in Java on Android

This post explains how to get TarsosDSP running on Android. TarsosDSP is a Java library for audio processing. Its aim is to provide an easy-to-use interface to practical music processing algorithms implemented, as simply as possible, in pure Java and without any other external dependencies.

Since version 2.0 there are no more references to javax.sound.* in the TarsosDSP core codebase. This makes it easy to run TarsosDSP on Android. Audio Input/Output operations that depend on either the JVM or Dalvik runtime have been abstracted and removed from the core. For each runtime target a Jar file is provided in the TarsosDSP release directory.

The source code for the audio I/O on the JVM and the audio I/O on Android can be found on GitHub. To get an audio processing algorithm working on Android the only thing that is needed is to place TarsosDSP-Android-2.0.jar in the lib directory of your project.

The following example connects an AudioDispatcher to the microphone of an Android device. Subsequently, a real-time pitch detection algorithm is added to the processing chain. The detected pitch in Hertz is printed on a TextView element, if no pitch is present in the incoming sound, –1 is printed. To test the application download and install the /files/attachments/420/TarsosDSPAndroid.apk(/files/attachments/420/TarsosDSPAndroid.apk) application on your Android device. The source code is available as well.

  


















  
AudioDispatcher dispatcher = AudioDispatcherFactory.fromDefaultMicrophone(22050, 1024, 0);
PitchDetectionHandler pdh = new PitchDetectionHandler() {
    @Override
    public void handlePitch(PitchDetectionResult result, AudioEvent e) {
        final float pitchInHz = result.getPitch();
        runOnUiThread(new Runnable() {
            @Override
            public void run() {
                TextView text = (TextView) findViewById(R.id.textView1);
                text.setText("" + pitchInHz);
            }
        });
    }
};
AudioProcessor p = new PitchProcessor(PitchEstimationAlgorithm.FFT_YIN, 22050, 1024, pdh);
dispatcher.addAudioProcessor(p);
new Thread(dispatcher, "Audio Dispatcher").start();

Thanks to these changes, the fork of TarsosDSP kindly provided by GitHub user srubin, created for a programming assignment at UC Berkley, is not needed any more.

Have fun hacking audio on Android!

UGent and TarsosDSP

TarsosDSPAndroid.zip, android-audio.jpg, and TarsosDSPAndroid.apk

~ Haar Wavlet Transform in TarsosDSP

The TarsosDSP Java library for audio processing now contains an implementation of the Haar Wavelet Transform. A discrete wavelet transform based on the Haar wavelet (depicted at the right). This reversible transform has some interesting properties and is practical in signal compression and for analyzing sudden transitions in a file. It can e.g. be used to detect edges in an image.

As an example use case of the Haar transform, a simple lossy audio compression algorithm is implemented in TarsosDSP. It compresses audio by dividing audio into bloks of 32 samples, transforming them using the Haar wavelet Transform and subsequently removing samples with the least difference between them. The last step is to reverse the transform and play the audio. The amount of compressed samples can be chosen between 0 (no compression) and 31 (no signal left). This crude lossy audio compression technique can save at least a tenth of samples without any noticeable effect. A way to store the audio and read it from disk is included as well.

The algorithm works in real time and an example application has been implemented which operates on an mp3 stream. To make this work immediately, the avconv tool needs to be on your system’s path. Also implemented is a bit depth compressor, which shows the effect of (extreme) bit depth compression.

The example is available at the TarsosDSP release directory, the code can be found on the TarsosDSP github page.

UGent and TarsosDSP

~ TarsosDSP Spectral Peak extraction

The TarsosDSP Java library for audio processing now contains a module for spectral peak extraction. It calculates a short time Fourier transform and subsequently finds the frequency bins with most energy present using a median filter. The frequency estimation for each identified bin is significantly improved by taking phase information into account. A method described in “Sethares et al. 2009 - Spectral Tools for Dynamic Tonality and Audio Morphing”.

The noise floor, determined by the median filter, the spectral information itself and the estimated peak locations are returned for each FFT-frame. Below a visualization of a flute can be found. As expected, the peaks are harmonically spread over the complete spectrum up until the Nyquist frequency.

UGent and TarsosDSP

~ International School on Systematic Musicology and Sound and Music Computing (ISSSM) 2014, Genova

From 9 to 20 March 2014 I was a student at the International School on Systematic Musicology and Sound and Music Computing. The aim of the course was to:

Give students an intensive course in the most advanced and current topics in the research fields of systematic musicology and sound and music computing. Give students the opportunity to discuss their research proposals/project with an international staff of teachers representing a variety of expertise in different domains of systematic musicology and sound and music computing. Teach students the most recent knowledge and basic skills needed to start a PhD. Give students the opportunity to join the research communities on systematic musicology, on sound and music computing.

Next to the lectures, the informal meetings with the professors was very interesting. I got to add some things to my ‘to read’ list:

• Rolf Bader, Calculation of Helmholtz frequency of a Renaissance vihuela string instrument with five tone hole
• Schneider, A. & Frieler, K. (2009) __Perception of harmonic and inharmonic sounds: Results from\ ear models. In S. Ystad, R. Kronland-Martinet & K. Jensen (Eds.), Computer music modeling and retrieval. Genesis of meaning in sound and music (pp. 18–44). Berlin: Springer.
• Rolf Bader, Sound - Perception - Performance

UGent

~ Power Socket Control with Arduino

This post contains some info on how do some basic home automation: it shows how cheap remote controlled power sockets can be managed using a computer. The aim is to power on or power off lights, a stereo or other devices remotely from a command shell.

The solution here uses an Arduino connected to a 433.33MHz transmitter. Via a Ruby script installed on the computer a command is send over serial to the Arduino. Subsequently the Arduino sends the command over the air to the power socket(s). If all goes well the power socket reacts by switching the connecting device on or off.

In the video below the process is shown. The command line interface controls the light via the Arduino. It should show the general idea.

The following Ruby script simply sends the binary control codes to the Arduino. For this type of power socket the code consist of a five bit group code and five bit device code. The Arduino is connected to /dev/tty.usbmodem411.

```ruby\ require ‘rubygems’\ require ‘serialport’

group = “11111”;

lamp = “01000” #B\ kerstboom = “00100” #C\ stereo = “00010” #D

port = “/dev/tty.usbmodem411”\ baud_rate = 9600\ data_bits = 8\ stop_bits = 1\ parity = SerialPort::NONE

command = ARGV[1] == “on”

device_string = ARGV[0]\ device = if device_string "kerstboom" kerstboom elsif device_string “lamp”\ lamp\ elsif device_string == “stereo”\ stereo\ end

def send(sp,group,device,deviceOn)\ command = deviceOn ? “1” : “0”\ command.each_char{|c| sp.write©}\ group.each_char{|c| sp.write©}\ device.each_char{|c| sp.write©}\ sp.flush\ read_response sp\ read_response sp\ end

def read_response(sp)\ response = sp.readline\ puts response.chomp\ end

SerialPort.open(port, baud_rate, data_bits, stop_bits, parity) do |sp|\ read_response sp\ send(sp,group,device,command)\ end\ ```

The code below is the complete Arduino sketch. It uses the RCSwich library, which makes the implementation very simple. Essentially it waits for a complete command and transmits it through the connected transmitter. The transmitter connected is a tx433n

```ruby\ #include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch();

char command[12];//2x5 for device and group + command\ int index = 0;\ char currentChar = –1;

//the led pin in use\ int ledPin = 12;

void setup() {\ //start the serial communication\ Serial.begin(9600);\ // 433MHZ Transmitter is connected to Arduino Pin #10\ mySwitch.enableTransmit(10);\ //Led connected to led pin\ pinMode(ledPin, OUTPUT);\ Serial.println(“Started the power command center! Mwoehahaha!”);\ }

void readCommand(){\ //read a command\ while (Serial.available() > 0){\ if(index < 11){\ currentChar = Serial.read(); // Read a character\ command[index] = currentChar; // Store it\ index; // Increment where to write next\ command[index] = ‘\0’; // append termination char\ }\ }\ }

void loop() {\ //read a command\ readCommand();\ //if a command is complete\ if(index == 11){\ Serial.print(“Recieved command: “);\ Serial.println(command);\ char operation = command[0];\ char* group = &command[1];\ //group is 5 bits, as is device\ char* device = &command[6];

//execute the operation\ doSwitch(operation,group,device);\ //reset the index to read a new command\ index=0;\ }\ }

void doSwitch(char operation, char* group, char* device){\ digitalWrite(ledPin, HIGH);\ if(operation == ‘1’){\ mySwitch.switchOn(group, device);\ Serial.print(“Switched on device “);\ } else {\ mySwitch.switchOff(group, device);\ Serial.print(“Switched off device “);\ }\ Serial.println(device);\ digitalWrite(ledPin, LOW);\ }\ ```

Harde waren, Projecten, Code, and Hackerspace Ghent

~ TarsosDSP Paper and Presentation at AES 53rd International conference on Semantic Audio

TarsosDSP will be presented at the AES 53rd International conference on Semantic Audio in London . During the conference both a presentation and demonstration of the paper “TarsosDSP, a Real-Time Audio Processing Framework in Java”:[aes53_tarsos_dsp.pdf], by Joren Six, Olmo Cornelis and Marc Leman, in Proceedings of the 53rd AES Conference (AES 53rd), 2014. From their website:

Semantic Audio is concerned with content-based management of digital audio recordings. The rapid evolution of digital audio technologies, e.g. audio data compression and streaming, the availability of large audio libraries online and offline, and recent developments in content-based audio retrieval have significantly changed the way digital audio is created, processed, and consumed. New audio content can be produced at lower cost, while also large audio archives at libraries or record labels are opening to the public. Thus the sheer amount of available audio data grows more and more each day. Semantic analysis of audio resulting in high-level metadata descriptors such as musical chords and tempo, or the identification of speakers facilitate content-based management of audio recordings. Aside from audio retrieval and recommendation technologies, the semantics of audio signals are also becoming increasingly important, for instance, in object-based audio coding, as well as intelligent audio editing, and processing. Recent product releases already demonstrate this to a great extent, however, more innovative functionalities relying on semantic audio analysis and management are imminent. These functionalities may utilise, for instance, (informed) audio source separation, speaker segmentation and identification, structural music segmentation, or social and Semantic Web technologies, including ontologies and linked open data.

This conference will give a broad overview of the state of the art and address many of the new scientific disciplines involved in this still-emerging field. Our purpose is to continue fostering this line of interdisciplinary research. This is reflected by the wide variety of invited speakers presenting at the conference.

The paper presents TarsosDSP, a framework for real-time audio analysis and processing. Most libraries and frameworks offer either audio analysis and feature extraction or audio synthesis and processing. TarsosDSP is one of a only a few frameworks that offers both analysis, processing and feature extraction in real-time, a unique feature in the Java ecosystem. The framework contains practical audio processing algorithms, it can be extended easily, and has no external dependencies. Each algorithm is implemented as simple as possible thanks to a straightforward processing pipeline. TarsosDSP’s features include a resampling algorithm, onset detectors, a number of pitch estimation algorithms, a time stretch algorithm, a pitch shifting algorithm, and an algorithm to calculate the Constant-Q. The framework also allows simple audio synthesis, some audio effects, and several filters. The Open Source framework is a valuable contribution to the MIR-Community and ideal fit for interactive MIR-applications on Android. The full paper can be downloaded “TarsosDSP, a Real-Time Audio Processing Framework in Java”:[aes53_tarsos_dsp.pdf]

A BibTeX entry for the paper can be found below.

```ruby\ \@inproceedings{six2014tarsosdsp,\ author = {Joren Six and Olmo Cornelis and Marc Leman},\ title = {{TarsosDSP, a Real-Time Audio Processing Framework in Java}},\ booktitle = {{Proceedings of the 53rd AES Conference (AES 53rd)}},\ year = 2014\ }\ ```

Research papers, UGent, Presentation, and TarsosDSP

aes53_tarsos_dsp.pdf

~ Doctoral defense Olmo Cornelis - Exploring the Symbiosis of Western and non-Western Music

Woensdag 18 december 2013 organiseerde Olmo Cornelis een concert in het kader van zijn doctoraat. De dag erna volgde zijn verdediging. Nogmaals proficiat Olmo met het mooie eeh mbirapunt. Hieronder staat kort wat uitleg over het project en het concert.

bq.. In zijn onderzoeksproject ‘Exploring the symbiosis of Western and non-Western Music’ stelde Olmo Cornelis de beschrijving van Centraal-Afrikaanse muziek centraal. Deze werd verkend via computationele technieken die de klank als signaal\ benaderden. De verkregen informatie zorgde voor beïnvloeding van het artistieke oeuvre waarin steeds een mengeling van impliciete en expliciete etnische invloeden spelen.

In het kader van de afronding van dit doctoraal onderzoek spelen het HERMESensemble, het Nadar Ensemble, Maja Jantar en Françoise Vanhecke op 18 december werk van Olmo Cornelis dat tijdens dit project geschreven werd. Het onderzoeksproject Exploring the symbiosis of Western and non-Western Music werd in 2008 geïnitieerd aan het Conservatorium / School of Arts van de HoGent en werd gefinancierd door het onderzoeksfonds Hogeschool Gent.

Beeld: Noel Cornelis, Reality of Possibilities, 2012

Dutch, Computational musicology, HoGent, and UGent

~ IPEM D-Jogger featured on RTBF

Yesterday, December 4th 2013, the RTBF (Radio Télévision Belge Francophone) was at IPEM (Institute for Psychoacoustics and Electronic Music) to do a small feature on research currently going on at the institue. The RTBF is the public broadcasting organization of the French Community of Belgium, the southern, French-speaking part of Belgium. The clip shows the D-Jogger in action, with me using it. The fragment is available on the RTBF website and is embedded below.

UGent

~ Evaluation and Recommendation of Pulse and Tempo Annotation in Ethnic Music - In Journal Of New Music Research

The journal paper Evaluation and Recommendation of Pulse and Tempo Annotation in Ethnic Music - In Journal Of New Music Research by Cornelis, Six, Holzapfel and Leman was published in a special issue about Computational Ethnomusicology of the Journal of New Music Research (JNMR) on the 20th of august 2013. Below you can find the abstract for the article, and the full text author version of the article itself.

Abstract: Large digital archives of ethnic music require automatic tools to provide musical content descriptions. While various automatic approaches are available, they are to a wide extent developed for Western popular music. This paper aims to analyze how automated tempo estimation approaches perform in the context of Central-African music. To this end we collect human beat annotations for a set of musical fragments, and compare them with automatic beat tracking sequences. We first analyze the tempo estimations derived from annotations and beat tracking results. Then we examine an approach, based on mutual agreement between automatic and human annotations, to automate such analysis, which can serve to detect musical fragments with high tempo ambiguity.

To read the full text you can either download “Evaluation and Recommendation of Pulse ant Tempo Annotation in Ethnic Music, Author version”:[2013.10.09.Tempo_annotation_in_ethnic_music-JNMR-Author_Version.pdf]. Or obtain the published version of Evaluation and Recommendation of Pulse ant Tempo Annotation in Ethnic Music, published version

Below the BibTex entry for the article is embedded.

```ruby\ \@article{cornelis2013tempo_jnmr,\ author = {Olmo Cornelis, Joren Six, Andre Holzapfel, and Marc Leman},\ title = {{Evaluation and Recommendation of Pulse ant Tempo Annotation in Ethnic Music}},\ journal = {{Journal of New Music Research}},\ volume = {42},\ number = {2},\ pages = {131-149},\ year = {2013},\ doi = {10.1080/09298215.2013.812123}\ }\ ```

HoGent, Research papers, featured, and JNMR

2013.10.09.Tempo_annotation_in_ethnic_music-JNMR-Author_Version.pdf and jnmr.cover.jpg

~ Constant-Q Transform in Java with TarsosDSP

The DSP library for Taros, aptly named TarsosDSP, now includes an implementation of a Constant-Q Transform (as of version 1.6). The Constant-Q transform does essentially the same thing as an FFT, but has the advantage that each octave has the same amount of bins. This makes the Constant-Q transform practical for applications processing music. If, for example, 12 bins per octave are chosen, these can correspond with the western musical scale.

Also included in the newest release (version 1.7) is a way to visualize the transform, or other musical features. The visualization implementation is done together with Thomas Stubbe.

The example application below shows the Constant-Q transform with an overlay of pitch estimations. The corresponding waveform is also shown.

Find your oven fresh baked binaries at the TarsosDSP Release Repository.\ The source code can be found at the TarsosDSP GitHub repository.

TarsosDSP, Java, HoGent, Music Information Retrieval, Code, and Computational musicology

constantq-visualization-java.png

~ Tarsos, a Modular Platform for Precise Pitch Analysis of Western and Non-Western Music - In Journal Of New Music Research

The journal paper Tarsos, a Modular Platform for Precise Pitch Analysis of Western and Non-Western Music by Six, Cornelis, and Leman was published in a special issue about Computational Ethnomusicology of the Journal of New Music Research (JNMR) on the 20th of august 2013. Below you can find the abstract for the article, and pointers to audio examples, the Tarsos software, and the author version of the article itself.

Abstract: This paper presents Tarsos, a modular software platform used to extract and analyze pitch organization in music. With Tarsos pitch estimations are generated from an audio signal and those estimations are processed in order to form musicologically meaningful representations. Tarsos aims to offer a flexible system for pitch analysis through the combination of an interactive user interface, several pitch estimation algorithms, filtering options, immediate auditory feedback and data output modalities for every step. To study the most frequently used pitches, a fine-grained histogram that allows up to 1200 values per octave is constructed. This allows Tarsos to analyze deviations in Western music, or to analyze specific tone scales that differ from the 12 tone equal temperament, common in many non-Western musics. Tarsos has a graphical user interface or can be launched using an API - as a batch script. Therefore, it is fit for both the analysis of individual songs and the analysis of large music corpora. The interface allows several visual representations, and can indicate the scale of the piece under analysis. The extracted scale can be used immediately to tune a MIDI keyboard that can be played in the discovered scale. These features make Tarsos an interesting tool that can be used for musicological analysis, teaching and even artistic productions.

To read the full text you can either download “Tarsos, a Modular Platform for Precise Pitch Analysis of Western and Non-Western Music, Author version”:[2013.08.20.tarsos_jnmr_author_version.pdf]. Or obtain the published version of Tarsos, a Modular Platform for Precise Pitch Analysis of Western and Non-Western Music, published version

Ladrang Kandamanyura (slendro pathet manyura), is the name of the piece used in the article throughout section 2. The album on which the piece can be found is available at wergo. Below a thirty second fragment is embedded. You can also “download”:[08._Ladrang_Kandamanyura_10s-20s_up.wav] the thirty second fragment to analyse it yourself.

Below the BibTex entry for the article is embedded.

```ruby\ \@article{six2013tarsos_jnmr,\ author = {Six, Joren and Cornelis, Olmo and Leman, Marc},\ title = {Tarsos, a Modular Platform for Precise Pitch Analysis\ of Western and Non-Western Music},\ journal = {Journal of New Music Research},\ volume = {42},\ number = {2},\ pages = {113-129},\ year = {2013},\ doi = {10.1080/09298215.2013.797999},\ URL = {http://www.tandfonline.com/doi/abs/10.1080/09298215.2013.797999}\ }\ ```

Research papers, HoGent, JNMR, Tarsos, featured, Java, Music Information Retrieval, and Computational ethnomusicology

08._Ladrang_Kandamanyura_10s-20s_up.wav, 2013.08.20.tarsos_jnmr_author_version.pdf, and jnmr.cover.jpg

~ FMA 2013 - Computer Assisted Transcripton of Ethnic Music

At the third international workshop on Folk Music Analysis (FMA2013) we presented a poster titled “Computer Assisted Transcription of Ethnic Music”:[A0-Poster.png]. The workshop took place in Amsterdam, Netherlands, June 6 and 7, 2013.

In the extended abstract, also titled “Computer Assisted Transcription of Ethnic Music”:[FMA_2013.computer_assisted_transcription.pdf], it is described how the Tarsos software program now has features aiding transcription. Tarsos is especially practical for ethnic music of which the tone scale is not known beforehand. The proceedings of FMA 2013 are available as well.

"":\[A0-Poster.jpg\]

During the conference there also was an interesting panel on transcription. The following people participated: John Ashley Burgoyne, moderator (University of Amsterdam), Kofi Agawu (Princeton University), Dániel P. Biró (University of Victoria), Olmo Cornelis (University College Ghent, Belgium), Emilia Gómez (Universitat Pompeu Fabra, Barcelona), and Barbara Titus (Utrecht University). Some pictures can be found below.

Tarsos, Research papers, Java, featured, Computational musicology, HoGent, Folk Music Analysis (FMA) conference, and Computational ethnomusicology

A0-Poster.pdf, FMA_2013.computer_assisted_transcription.pdf, A0-Poster.jpg, FMA_2013.computer_assisted_transcription.pdf, IMG_20130607_140442.jpg, and IMG_20130607_152620.jpg

~ TarsosLSH - Locality Sensitive Hashing (LSH) in Java

TarsosLSH is a Java library implementing Locality-sensitive Hashing (LSH), a practical nearest neighbour search algorithm for multidimensional vectors that operates in sublinear time. It supports several Locality Sensitive Hashing (LSH) families: the Euclidean hash family (L<sub>2</sub>), city block hash family (L<sub>1</sub>) and cosine hash family. The library tries to hit the sweet spot between being capable enough to get real tasks done, and compact enough to serve as a demonstration on how LSH works. It relates to the Tarsos project because it is a practical way to search for and compare musical features.

Quickly Getting Started with TarsosLSH

Head over to the TarsosLSH release repository and download the latest TarsosLSH library. Consult the TarsosLSH API documentation. If you, for some reason, want to build from source, you need Apache Ant and git installed on your system. The following commands fetch the source and build the library and example jars:

<code>git clone https://JorenSix@github.com/JorenSix/TarsosLSH.git
cd TarsosLSH/build
ant  #Builds the core TarsosLSH library
ant javadoc #build the API documentation
</code>

\ When everything runs correctly you should be able to run the command line application, and have the latest version of the TarsosLSH library for inclusion in your projects. Also, the Javadoc documentation for the API should be available in TarsosLSH/doc. Drop me a line if you use TarsosLSH in your project. Always nice to hear how this software is used.

The fastest way to get something on your screen is executing this on your command line: java - jar TarsosLSH.jar this lets LSH run on a random data set. The full reference of the command line application is included below:

Name
    TarsosLSH: finds the nearest neighbours in a data set quickly, using LSH.
Synopsis    
    java - jar TarsosLSH.jar [options] dataset.txt queries.txt 
Description
    Tries to find nearest neighbours for each vector in the 
    query file, using Euclidean (L2) distance by default.

    Both dataset.txt and queries.txt have a similar format: 
    an optional identifier for the vector and a list of N 
    coordinates (which should be doubles).

    [Identifier] coord1 coord2 ... coordN
    [Identifier] coord1 coord2 ... coordN

    For an example data set with two elements and 4 dimensions:

    Hans 12 24 18.5 -45.6
    Jane 13 19 -12.0 49.8

    Options are:

    -f cos|l1|l2 
        Defines the hash family to use:
            l1  City block hash family (L1)
            l2  Euclidean hash family(L2)
            cos Cosine distance hash family
    -r radius 
        Defines the radius in which near neighbours should
        be found. Should be a double. By default a reasonable
        radius is determined automatically.
    -h n_hashes
        An integer that determines the number of hashes to 
        use. By default 4, 32 for the cosine hash family.
    -t n_tables
        An integer that determines the number of hash tables,
        each with n_hashes, to use. By default 4.
    -n n_neighbours
        Number of neighbours in the neighbourhood, defaults to 3.
    -b 
        Benchmark the settings. 
    --help 
        Prints this helpful message.
Examples
    Search for nearest neighbours using the l2 hash family with a radius of 500
    and utilizing 5 hash tables, each with 3 hashes.

    java - jar TarsosLSH.jar -f l2 -r 500 -h 3 -t 5 dataset.txt queries.txt

Source Code Organization

The source tree is divided in three directories:

• src contains the source files of the core DSP libraries.

• test contains unit tests for some of the DSP functionality.

• build contains ANT build files. Either to build Java documentation or runnable JAR-files for the example applications.

Further Reading

This section includes a links to resources used to implement this library.

• The LSH-page maintained by Alexandr Andoni contains pointers to good resources:
  • Locality-Sensitive Hashing Scheme Based on p-Stable Distributions a chapter by Alexandr Andoni, Mayur Datar, Nicole Immorlica, Piotr Indyk, and Vahab Mirrokni which appeared in the book Nearest Neighbor Methods in Learning and Vision: Theory and Practice, by T. Darrell and P. Indyk and G. Shakhnarovich (eds.), MIT Press, 2006.
  • Similarity Search in High Dimensions via Hashing The original LSH Paper for hamming distance by Gionis, Aristides and Indyk, Piotr and Motwani, Rajeev.

• Locality-Sensitive Hashing for Finding Nearest Neighbors a good introduction of LSH by Malcom Slaney & Michael Casey

• Finding Similar Items, Chapter Three of “Mining of Massive Datasets” by Anand Rajaraman and Jeff Ullman is a textbook introducing the LSH concept.

• Szudzik pairing functions by Matthew Szudzik. Explains how integer hashes can be combined deterministically to form a reversible, unique new hash.

Code, Java, and HoGent

~ Spotify Music Quiz - With a Big Red Button

This post documents how to implement a simple music quiz with the meta data provided by Spotify and a big red button.

During my last birthday party, organized at Hackerspace Ghent ,there was an ongoing Spotify music quiz. The concept was rather simple: If music that was playing was created in the same year as I was born, the guests could press a big red button and win a price! If they guessed incorrectly, they were publicly shamed with a sad trombone. Only one guess for each\ song was allowed.

Below you can find a small videograph which shows the whole thing in action. The music quiz is simple: press the button if the song is created in 1984. In the video, at first a wrong answer is given, then a couple of invalid answers follow. Finally a good answer is given, the song “The Killing Moon by Echo & the Bunnymen” is from 1984! Woohoo!

Allright, what did I use to to implement the spotify music quiz:

• A big red Arduino button, attatched by USB to a laptop.

• A system with Spotify.

• A way to access the meta data of the currently playing song in Spotify.

• A Ruby script to connect al the parts and checks answers.

The Red Button

A nice big red button, which main features are that it is red and big, serves as the main input device for the quiz. To be able to connect the salvaged safety button to a computer via USB, an Arduino Nano is used. The Arduino is loaded with the code from the debounce tutorial, basically unchanged. Unfortunately, I could not fit the the FTDI-chip, which provides the USB connection, in the original enclosure. An additional enclosure, the white one seen in the pictures below, was added.

When pressed, the button sends a signal over the serial line. See below how the Ruby Quiz script waits for, and handles such event.

Get Meta Data from the Currently Playing Song in Spotify

Another requirement for the quiz to work is the ability to get information about the song currently playing in Spotify. On Linux this can be done with the dbus interface for Spotify. The script included below returns information about the artist, album and title of the song. It also detects if Spotify is running or not. Find it, fork it, use it, on github

On Mac OS X, Spotify can be controlled using AppleScript. A script on github shows how to get meta data about the currently playing song in Spotify, on Mac OS X.

```ruby\ #!/usr/bin/python\ #

1. now_playing.py

3. Python script to fetch the meta data of the currently playing

4. track in Spotify. This is tested on Ubuntu.

import dbus\ bus = dbus.SessionBus()\ try:\ spotify = bus.get_object(‘com.spotify.qt’, ‘/’)\ iface = dbus.Interface(spotify, ‘org.freedesktop.MediaPlayer2’)\ meta_data = iface.GetMetadata()\ artistname = “,”.join(meta_data[‘xesam:artist’])\ trackname = meta_data[‘xesam:title’]\ albumname = meta_data[‘xesam:album’]\ #Other fields are:\ # ‘xesam:trackNumber’, ‘xesam:discNumber’,’mpris:trackid’,\ # ‘mpris:length’,’mpris:artUrl’,’xesam:autoRating’,’xesam:contentCreated’,’xesam:url’\ print str(trackname + “ | “ + artistname + “ | “ + albumname + “ | Unknown”)\ except dbus.exceptions.DBusException:\ print “Spotify is not running.”\ ```

The Quiz Ruby Script

With the individual part in order, we now need Ruby glue to paste it all together. The complete music quiz script can be found on github. The main loop, below, waits for a button press. If it is pressed the “sad trombone”:[sad_trombone.wav], “invalid answer”:[cheater.wav] or “winner”:[winner.wav] sound is played. The sounds are attached to this post.

```ruby\ while true do\ # Wait for a button press\ data = sp.readline\ # Fetch meta data about the currently\ # playing song\ result = `#{now_playing_command}`\ # Parse the meta data\ title,artist,album = parse_result(result)\ #Title is hash key, should be unique within playlist\ key = title\ if responded_to.has_key? key\ puts “Already answered: you cheater”\ play cheater\ elsif correct_answers.has_key? key\ puts “Correct answers: woohoo”\ responded_to[key]=true\ play winner\ else\ puts “Incorrect answer: sad trombone”\ responded_to[key]=true\ play sad_trombone\ end\ end\ ```

Projecten and 0110.be

cheater.wav, sad_trombone.wav, and winner.wav

~ Flanger Audio Effect in Java

The DSP library for Taros, aptly named TarsosDSP, now includes an example demonstrating the flanging audio effect. Flanging, essentialy mixing the signal with a varying delay of itself, produces an interesting interference pattern.

The flanging example works on wav-files or on input from microphone. Try it yourself, download\ Flanging.jar, the executable jar file. Below you can check what flanging sounds like with various parameters.

The source code of the Java implementation can be found on the TarsosDSP github page.

TarsosDSP, Java, and HoGent

Flanger_Effect_in_Java.png