SoundFileAnalysis | SuperCollider 3.13.1 Help

Description

This class provides a relatively simple way to do custom non realtime signal analysis. Using live recorded buffers, it can do the processing in the background while the recording continues. Its input is a soundfile, its output is a dataset formatted as an event.

(be aware that by default sound files are only analysed for n*serverOptions.blockSize<SoundFile.duration please look at the trimDuration argument for details.)

A simple example:( a = SoundFileAnalysis.new; // add some custom sound analysis method a.add(\amplitude, \trig, { |sig| var amp = Amplitude.kr(sig); var trig = amp > 0.6; // amp exceeds threshold var avg = TrigAvg.kr(amp, trig); [trig, avg] // records always the average before the peak }); x = a.analyzeFile(Platform.resourceDir +/+ "sounds/a11wlk01.wav", callback: { "analysis completed".postln; }); ) x[\amplitude].plot; // plot the average amplitudes

Class Methods

.verbose

Post what's going on (default: false).

.new

Return a new SoundFileAnalysis Object

.initAnalysisMethods

Return a function with a dictionary of basic analysis methods (trig, average, direct).

.basicAnalysisMethods

A dictionary with the tree keys: \trig, \average, \direct. This dictionary (basicAnalysisMethods) can be extended.

trig: Write a value on receiveing a trigger
average: Average all values in the file
direct: Write a value on each frame

Instance Methods

.add

Add a new analysis method

Arguments:

name

Name for the method (a Symbol)

type

One of currently three types:

trig: Write one or more values on receiveing a trigger
direct: Write a value on each frame
average: Average all values in the file

ugenFunc

A function that returns a UGen graph. It takes the sound signal and the soundfile object as arguments.

.analysisMethods

Returns a dictionary of functions of currently defined methods.

.analyzeFile

Analyze a sound file, using the defined analysis methods. This method returns an Event with the following information:

~fileName, ~path, ~fileNumChannels: path and sound file information
~analysisStart, ~analysisDuration: What part of the file was analyzed
~dataDimensions: The results, each resulting from an analysis method (an Event)
~dataTable: The above results ordered as a multidimensional array

Arguments:

path	Path to the soundfile
start	Start frame index for analysis
duration	Analysis duration in seconds
which	Which methods to use (an array of names as symbols). If none is given, use all.
callback	A function that is called when analysis is completed. It takes the result (an event) as argument.
maxDataPoints	A limit on the number of points added to the data.
trimDuration	When `trimDuration` is unspecified, the duration is no longer than the length of the file. Because only full blocks are written to the buffer, usually the last samples of a file are not analysed. Setting `trimDuration` allows you to specify what is supposed to happen with the last block or leaves the duration be as specified in the argument. (see example below) \roundDown analyses the file until the full last block. \roundUp analyses the file and adds silence to fill the last block. nil leaves the duration as given in the argument.
serverOptions	ServerOptions for the NRT server. A way to deal with the last half block problem is to set the blockSize to 1. (see example below)

.analyzeAll

Analyze all files given, returning a List of Events.

Arguments:

paths

A list of paths

Examples

s.boot;

// record a sound into a buffer
b = Buffer.alloc(s, s.sampleRate * 3, 1, bufnum: 1000);

(
SynthDef(\record, {|out|
    var in, rec;
    in = RLPF.ar(LFSaw.ar(300 * SinOsc.kr(0.4).range(0.5, 5)), Line.kr(12000, 100, 3));
    rec = RecordBuf.ar(in, b.bufnum, loop: 0, doneAction: 2);
    Out.ar(out, in);
};
).add
)

Synth(\record);

// write the file to analyze later
b.write("~/soundFileAnalysisExample.aiff".standardizePath,"aiff", "int24");

b.play; // maybe check if something is there

// initialize analysis
(
a = SoundFileAnalysis.new;

a.add(\centroid, \trig, {|sig|
    var fft = FFT(LocalBuf(2048, 1), sig);
    var x = SpecCentroid.kr(fft);
    [Impulse.kr(5), x]
});
a.add(\crest, \average, {|sig, soundfile| Crest.kr(sig, soundfile.numFrames) });
a.add(\amplitude, \direct, {|sig| Amplitude.kr(sig); });
)

// analyze the sound

x = a.analyzeFile("~/soundFileAnalysisExample.aiff".standardizePath, duration: 3, maxDataPoints: 3000, callback: {"done!".postln;});

// look at the data
x[\centroid].postcs;
x[\crest].postcs;
x[\amplitude].postcs;

// BONUS: how to tweak the analysis methods
(
Ndef(\centroid, {
    var sig = RLPF.ar( LFSaw.ar(300 * SinOsc.kr(0.4).range(0.5, 5)), Line.kr(12000, 300, 3));
    var fft = FFT(LocalBuf(2048, 1), sig);
    var x = SpecCentroid.kr(fft);
    x.poll(10);
    sig;
}).play;
)

Live audio analysis

(

~sfa = SoundFileAnalysis.new;

~sfa.add(\onsets, \trig, {|sig|
    var fft = FFT(LocalBuf(2048, 1), sig);
    var x = Onsets.kr(fft); // if needed, adjust analysis
    var currentTime = Sweep.kr(1, 1); // time in seconds
    [x, currentTime]
});

~analyzed = (); // a dictionary to keep several analysis data sets
~dur = 4;

SynthDef(\playchunk, { |out, bufnum, sustain = 1, amp = 0.1, rate = 1, onset = 0|
    var startPos = onset * BufSampleRate.kr(bufnum); // convert from seconds to frames
    var env = EnvGen.kr(Env.linen(0.001, sustain / rate, 0.02), doneAction:2);
    Out.ar(out,
        PlayBuf.ar(2, bufnum, rate, startPos:startPos)
    )
}).add;

~liveBuffer = Buffer.alloc(s, s.sampleRate * ~dur, 2);

~analyze = { |name = 0|
    var path;
    fork {
        path = "~/analysis_%.aiff".format(name).standardizePath;
        ~liveBuffer.write(path); // write soundfile as a copy
        s.sync;
        x = ~sfa.analyzeFile(path, callback: { "analysed buffer, saved in index %".format(name).postln;});
        x[\buffer] = Buffer.read(s, path); // read soundfile
        ~analyzed[name] = x;

};
};

~makeEvents = { |name, func|
    var analysis = ~analyzed[name], buffer, onsets, durations, events;
    if(analysis.isNil) { "analysis file not found".postln } {
        buffer = analysis[\buffer];
        onsets = analysis[\onsets];
        durations = onsets.differentiate.drop(1);
        durations = durations.add(buffer.duration - onsets.last);
        events = onsets.collect { |time, i|
            (
                onset:time,
                bufnum: buffer,
                dur: durations[i],
                sustain: durations[i],
                rate: 1,
                instrument:\playchunk
            )
        };
    };

};
~freeAllBuffers = {
    ~analyzed.do { |x| x[\buffer].free };
};
~writeToFiles = { |name, path|
    ~makeEvents.value(name).do { |x, i|
        var buffer = x[\bufnum];
        var filepath = format("%_%_%.aiff", path, name, i).standardizePath;
        buffer.write(filepath, numFrames:x[\sustain] * buffer.sampleRate, startFrame:x[\onset] * buffer.sampleRate)
    }
};
)

// record into a 4 second live buffer
Ndef(\rec, { RecordBuf.ar(SoundIn.ar([0, 1]), ~liveBuffer, loop:1) });

// hit cmd-period to stop recording, or Ndef(\rec).free;
// for restarting the recording, call Ndef(\rec).send;

~analyze.value;

~analyzed[0].buffer.play; // something there?
~analyzed[0][\onsets]; // post onsets
~events = ~makeEvents.(0); // generate events
~events.size; // how many?
~events.choose.play; // play a random one

// play back as a pattern
Pbindf(Pseq(~events.copy.scramble, inf), \rate, 1).play;
Pbindf(Pseq(~events.copy.scramble, inf), \rate, 2, \dur, 1.4).play;

// if you need, write to files
~writeToFiles.(0, "~/test");

// free all
~freeAllBuffers.value;

Tests

Example of three ways about how to deal with the last block problem.

In the following example the number of zerocrossing in a file is written in the last block of the calculation.( p = Platform.resourceDir +/+ "sounds/a11wlk01.wav"; f = SoundFile.openRead(p); n = f.numFrames; f.close; a=SoundFileAnalysis(); a.add(\pn, \trig, { |sig| var zc = (sig > 0) & (Delay1.ar(sig) <= 0); var count = PulseCount.ar(zc); var trig = Phasor.ar(0,1,0,n) - n + 2; [trig, count]}); )

With the default values the result will be empty:x=a.analyzeFile(p, callback: {x.pn.postln});

Only if the last block is included by setting the trimDuration to \roundUp the result is printed:x=a.analyzeFile(p, callback: {x.pn.postln}, trimDuration: \roundUp);

It is not enough to provide a duration that is the amount of samples longer to fill the last block. because by default the duration is trimmed to the sample length:x=a.analyzeFile(p, duration: (n/44100).roundUp(64 / 44100), callback: {x.pn.postln});

One can freely set the duration if one set trimDuration to nil:x=a.analyzeFile(p, duration: (n/44100).roundUp(64 / 44100), callback: {x.pn.postln}, trimDuration: nil);

Or one can use a server with the blockSize of 1. But this is less efficient.x=a.analyzeFile(p, callback: {x.pn.postln}, serverOptions: ServerOptions().blockSize_(1).verbosity_(-1));

helpfile source: HelpSource/Classes/SoundFileAnalysis.schelp
link::SoundFileAnalysis/Classes/SoundFileAnalysis::

SoundFileAnalysisExtension

Description

Class Methods

.verbose

.new

.initAnalysisMethods

.basicAnalysisMethods

Instance Methods

.add

Arguments:

.analysisMethods

.analyzeFile

Arguments:

.analyzeAll

Arguments:

Examples

Live audio analysis

Tests

SoundFileAnalysis
Extension