BeatRoot Vamp Plugin

3a5840de4d5fae540d5f8302dd56a548fe21bb02 mirex2013

296404fd93c74f1ef065d74ffeb1b7d6d6ad166d v1.0

296404fd93c74f1ef065d74ffeb1b7d6d6ad166d v1.0

8d3716a5d7e775006ed13199c0d6890ca54ab4a8 v1.0

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

  Vamp feature extraction plugin for the BeatRoot beat tracker.

  Centre for Digital Music, Queen Mary, University of London.

  This file copyright 2011 Simon Dixon, Chris Cannam and QMUL.

  This program is free software; you can redistribute it and/or

  modify it under the terms of the GNU General Public License as

  published by the Free Software Foundation; either version 2 of the

  License, or (at your option) any later version.  See the file

  COPYING included with this distribution for more information.

*/

#include "Agent.h"

#include "BeatTracker.h"

const double AgentParameters::DEFAULT_POST_MARGIN_FACTOR = 0.3;

const double AgentParameters::DEFAULT_PRE_MARGIN_FACTOR = 0.15;

const double AgentParameters::DEFAULT_MAX_CHANGE = 0.2;

const double AgentParameters::DEFAULT_EXPIRY_TIME = 10.0;

const double Agent::INNER_MARGIN = 0.040;

const double Agent::CONF_FACTOR = 0.5;

const double Agent::DEFAULT_CORRECTION_FACTOR = 50.0;

int Agent::idCounter = 0;

void Agent::accept(Event e, double err, int beats) {

    beatTime = e.time;

    events.push_back(e);

    if (fabs(initialBeatInterval - beatInterval -

             err / correctionFactor) < maxChange * initialBeatInterval)

        beatInterval += err / correctionFactor;// Adjust tempo

    beatCount += beats;

    double conFactor = 1.0 - CONF_FACTOR * err /

        (err>0? postMargin: -preMargin);

    if (decayFactor > 0) {

        double memFactor = 1. - 1. / threshold((double)beatCount,1,decayFactor);

        phaseScore = memFactor * phaseScore +

            (1.0 - memFactor) * conFactor * e.salience;

    } else

        phaseScore += conFactor * e.salience;

#ifdef DEBUG_BEATROOT

    std::cerr << "Ag#" << idNumber << ": " << beatInterval << std::endl;

    std::cerr << "  Beat" << beatCount << "  Time=" << beatTime

              << "  Score=" << tempoScore << ":P" << phaseScore << ":"

              << topScoreTime << std::endl;

#endif

} // accept()

bool Agent::considerAsBeat(Event e, AgentList &a) {

    double err;

    if (beatTime < 0) {	// first event

#ifdef DEBUG_BEATROOT

        std::cerr << "Ag#" << idNumber << ": accepting first event trivially at " << e.time << std::endl;

#endif

	accept(e, 0, 1);

	return true;

    } else {			// subsequent events

        EventList::iterator last = events.end();

        --last;

	if (e.time - last->time > expiryTime) {

#ifdef DEBUG_BEATROOT

            std::cerr << "Ag#" << idNumber << ": time " << e.time 

                      << " too late relative to " << last->time << " (expiry "

                      << expiryTime << "), giving up" << std::endl;

#endif

	    phaseScore = -1.0;	// flag agent to be deleted

	    return false;

	}

	double beats = nearbyint((e.time - beatTime) / beatInterval);

	err = e.time - beatTime - beats * beatInterval;

#ifdef DEBUG_BEATROOT

        std::cerr << "Ag#" << idNumber << ": time " << e.time << ", err " << err << " for beats " << beats << std::endl;

#endif

	if ((beats > 0) && (-preMargin <= err) && (err <= postMargin)) {

	    if (fabs(err) > innerMargin) {

#ifdef DEBUG_BEATROOT

                std::cerr << "Ag#" << idNumber << ": creating another new agent" << std::endl;

#endif

                // Create new agent that skips this event (avoids

                // large phase jump)

		a.add(clone());

            }

	    accept(e, err, (int)beats);

	    return true;

	}

    }

    return false;

} // considerAsBeat()

void Agent::fillBeats(double start) {

    double prevBeat = 0, nextBeat, currentInterval, beats;

    EventList::iterator ei = events.begin();

    if (ei != events.end()) {

        EventList::iterator ni = ei;

        if (++ni != events.end()) {

            prevBeat = ni->time;

        }

    }

    while (ei != events.end()) {

        EventList::iterator ni = ei;

        if (ni == events.end() ||

            ++ni == events.end()) {

            break;

        }

	nextBeat = ni->time;

	beats = nearbyint((nextBeat - prevBeat) / beatInterval - 0.01); //prefer slow

	currentInterval = (nextBeat - prevBeat) / beats;

	for ( ; (nextBeat > start) && (beats > 1.5); beats--) {

	    prevBeat += currentInterval;

            events.insert(ni, BeatTracker::newBeat(prevBeat, 0));

	}

	prevBeat = nextBeat;

        ei = ni;

    }

} // fillBeats()

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

  Vamp feature extraction plugin for the BeatRoot beat tracker.

  Centre for Digital Music, Queen Mary, University of London.

  This file copyright 2011 Simon Dixon, Chris Cannam and QMUL.

  This program is free software; you can redistribute it and/or

  modify it under the terms of the GNU General Public License as

  published by the Free Software Foundation; either version 2 of the

  License, or (at your option) any later version.  See the file

  COPYING included with this distribution for more information.

*/

#ifndef _AGENT_H_

#define _AGENT_H_

#include "Event.h"

#include <cmath>

#ifdef DEBUG_BEATROOT

#include <iostream>

#endif

class AgentList;

class AgentParameters

{

public:

    static const double DEFAULT_POST_MARGIN_FACTOR;

    static const double DEFAULT_PRE_MARGIN_FACTOR;

    static const double DEFAULT_MAX_CHANGE;

    static const double DEFAULT_EXPIRY_TIME;

    AgentParameters() :

        postMarginFactor(DEFAULT_POST_MARGIN_FACTOR),

        preMarginFactor(DEFAULT_PRE_MARGIN_FACTOR),

        maxChange(DEFAULT_MAX_CHANGE),

        expiryTime(DEFAULT_EXPIRY_TIME) { }

    /** The maximum amount by which a beat can be later than the

     *  predicted beat time, expressed as a fraction of the beat

     *  period. */

    double postMarginFactor;

    /** The maximum amount by which a beat can be earlier than the

     *  predicted beat time, expressed as a fraction of the beat

     *  period. */

    double preMarginFactor;

    /** The maximum allowed deviation from the initial tempo,

     * expressed as a fraction of the initial beat period. */

    double maxChange;

    /** The default value of expiryTime, which is the time (in

     *  seconds) after which an Agent that has no Event matching its

     *  beat predictions will be destroyed. */

    double expiryTime;

};

/** Agent is the central class for beat tracking.

 *  Each Agent object has a tempo hypothesis, a history of tracked beats, and

 *  a score evaluating the continuity, regularity and salience of its beat track.

 */

class Agent

{

public:

    /** The default value of innerMargin, which is the maximum time

     * 	(in seconds) that a beat can deviate from the predicted beat

     * 	time without a fork occurring. */

    static const double INNER_MARGIN;

    /** The slope of the penalty function for onsets which do not

     * coincide precisely with predicted beat times. */

    static const double CONF_FACTOR;

    /** The reactiveness/inertia balance, i.e. degree of change in the

     *  tempo, is controlled by the correctionFactor variable.  This

     *  constant defines its default value, which currently is not

     *  subsequently changed. The beat period is updated by the

     *  reciprocal of the correctionFactor multiplied by the

     *  difference between the predicted beat time and matching

     *  onset. */

    static const double DEFAULT_CORRECTION_FACTOR;

protected:

    /** The identity number of the next created Agent */

    static int idCounter;

    /** The maximum time (in seconds) that a beat can deviate from the

     *  predicted beat time without a fork occurring (i.e. a 2nd Agent

     *  being created). */

    double innerMargin;

    /** Controls the reactiveness/inertia balance, i.e. degree of

     *  change in the tempo.  The beat period is updated by the

     *  reciprocal of the correctionFactor multiplied by the

     *  difference between the predicted beat time and matching

     *  onset. */

    double correctionFactor;

    /** The time (in seconds) after which an Agent that has no Event

     *  matching its beat predictions will be destroyed. */

    double expiryTime;

    /** For scoring Agents in a (non-existent) real-time version

     * (otherwise not used). */

    double decayFactor;

public:

    /** The size of the outer half-window before the predicted beat time. */

    double preMargin;

    /** The size of the outer half-window after the predicted beat time. */

    double postMargin;

    /** The Agent's unique identity number. */

    int idNumber;

    /** To be used in real-time version?? */

    double tempoScore;

    /** Sum of salience values of the Events which have been

     *  interpreted as beats by this Agent, weighted by their nearness

     *  to the predicted beat times. */

    double phaseScore;

    /** How long has this agent been the best?  For real-time version;

     * otherwise not used. */

    double topScoreTime;

    /** The number of beats found by this Agent, including

     * interpolated beats. */

    int beatCount;

    /** The current tempo hypothesis of the Agent, expressed as the

     * beat period in seconds. */

    double beatInterval;

    /** The initial tempo hypothesis of the Agent, expressed as the

     * beat period in seconds. */

    double initialBeatInterval;

    /** The time of the most recent beat accepted by this Agent. */

    double beatTime;

    /** The maximum allowed deviation from the initial tempo,

     * expressed as a fraction of the initial beat period. */

    double maxChange;

    /** The list of Events (onsets) accepted by this Agent as beats,

     * plus interpolated beats. */

    EventList events;

    /** Constructor: the work is performed by init()

     *  @param ibi The beat period (inter-beat interval) of the Agent's tempo hypothesis.

     */

    Agent(AgentParameters params, double ibi) :

	innerMargin(INNER_MARGIN),

	correctionFactor(DEFAULT_CORRECTION_FACTOR),

	expiryTime(params.expiryTime),

	decayFactor(0),

	preMargin(ibi * params.preMarginFactor),

	postMargin(ibi * params.postMarginFactor),

	idNumber(idCounter++),

	tempoScore(0.0),

	phaseScore(0.0),

	topScoreTime(0.0),

	beatCount(0),

	beatInterval(ibi),

	initialBeatInterval(ibi),

	beatTime(-1.0),

        maxChange(params.maxChange) {

    } // constructor

    Agent *clone() const {

        Agent *a = new Agent(*this);

        a->idNumber = idCounter++;

        return a;

    }

protected:

    double threshold(double value, double min, double max) {

	if (value < min)

	    return min;

	if (value > max)

	    return max;

	return value;

    }

public:

    /** Accept a new Event as a beat time, and update the state of the Agent accordingly.

     *  @param e The Event which is accepted as being on the beat.

     *  @param err The difference between the predicted and actual beat times.

     *  @param beats The number of beats since the last beat that matched an Event.

     */

    void accept(Event e, double err, int beats);

    /** The given Event is tested for a possible beat time. The following situations can occur:

     *  1) The Agent has no beats yet; the Event is accepted as the first beat.

     *  2) The Event is beyond expiryTime seconds after the Agent's last 'confirming' beat; the Agent is terminated.

     *  3) The Event is within the innerMargin of the beat prediction; it is accepted as a beat.

     *  4) The Event is within the postMargin's of the beat prediction; it is accepted as a beat by this Agent,

     *     and a new Agent is created which doesn't accept it as a beat.

     *  5) The Event is ignored because it is outside the windows around the Agent's predicted beat time.

     * @param e The Event to be tested

     * @param a The list of all agents, which is updated if a new agent is created.

     * @return Indicate whether the given Event was accepted as a beat by this Agent.

     */

    bool considerAsBeat(Event e, AgentList &a);

    /** Interpolates missing beats in the Agent's beat track, starting from the beginning of the piece. */

    void fillBeats() {

	fillBeats(-1.0);

    } // fillBeats()/0

    /** Interpolates missing beats in the Agent's beat track.

     *  @param start Ignore beats earlier than this start time 

     */

    void fillBeats(double start);

}; // class Agent

#endif

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

  Vamp feature extraction plugin for the BeatRoot beat tracker.

  Centre for Digital Music, Queen Mary, University of London.

  This file copyright 2011 Simon Dixon, Chris Cannam and QMUL.

  This program is free software; you can redistribute it and/or

  modify it under the terms of the GNU General Public License as

  published by the Free Software Foundation; either version 2 of the

  License, or (at your option) any later version.  See the file

  COPYING included with this distribution for more information.

*/

#include "AgentList.h"

bool AgentList::useAverageSalience = false;

const double AgentList::DEFAULT_BI = 0.02;

const double AgentList::DEFAULT_BT = 0.04;

void AgentList::removeDuplicates() 

{

    sort();

    for (iterator itr = begin(); itr != end(); ++itr) {

#ifdef DEBUG_BEATROOT

        std::cerr << "removeDuplicates: considering agent " << (*itr)->idNumber << std::endl;

#endif

        if ((*itr)->phaseScore < 0.0) // already flagged for deletion

            continue;

        iterator itr2 = itr;

        for (++itr2; itr2 != end(); ++itr2) {

            if ((*itr2)->beatInterval - (*itr)->beatInterval > DEFAULT_BI)

                break;

            if (fabs((*itr)->beatTime - (*itr2)->beatTime) > DEFAULT_BT)

                continue;

            if ((*itr)->phaseScore < (*itr2)->phaseScore) {

#ifdef DEBUG_BEATROOT

                std::cerr << "agent " << (*itr)->idNumber << " is similar to but lower-scoring than agent " << (*itr2)->idNumber << ", marking for deletion" << std::endl;

#endif

                (*itr)->phaseScore = -1.0;	// flag for deletion

                if ((*itr2)->topScoreTime < (*itr)->topScoreTime)

                    (*itr2)->topScoreTime = (*itr)->topScoreTime;

                break;

            } else {

#ifdef DEBUG_BEATROOT

                std::cerr << "agent " << (*itr2)->idNumber << " is similar to but lower-scoring than agent " << (*itr)->idNumber << ", marking for deletion" << std::endl;

#endif

                (*itr2)->phaseScore = -1.0;	// flag for deletion

                if ((*itr)->topScoreTime < (*itr2)->topScoreTime)

                    (*itr)->topScoreTime = (*itr2)->topScoreTime;

            }

        }

    }

    int removed = 0;

    for (iterator itr = begin(); itr != end(); ) {

        if ((*itr)->phaseScore < 0.0) {

            ++removed;

            delete *itr;

            list.erase(itr);

        } else {

            ++itr;

        }

    }

#ifdef DEBUG_BEATROOT

    if (removed > 0) {

        std::cerr << "removeDuplicates: removed " << removed << ", have "

                  << list.size() << " agent(s) remaining" << std::endl;

    }

    int n = 0;

    for (Container::iterator i = list.begin(); i != list.end(); ++i) {

        std::cerr << "agent " << n++ << ": time " << (*i)->beatTime << std::endl;

    }

#endif

} // removeDuplicates()

void AgentList::beatTrack(EventList el, AgentParameters params, double stop)

{

    EventList::iterator ei = el.begin();

    bool phaseGiven = !empty() && ((*begin())->beatTime >= 0); // if given for one, assume given for others

    while (ei != el.end()) {

        Event ev = *ei;

        ++ei;

        if ((stop > 0) && (ev.time > stop))

            break;

        bool created = phaseGiven;

        double prevBeatInterval = -1.0;

        // cc: Duplicate our list of agents, and scan through the

        // copy.  This means we can safely add agents to our own

        // list while scanning without disrupting our scan.  Each

        // agent needs to be re-added to our own list explicitly

        // (since it is modified by e.g. considerAsBeat)

        Container currentAgents = list;

        list.clear();

        for (Container::iterator ai = currentAgents.begin();

             ai != currentAgents.end(); ++ai) {

            Agent *currentAgent = *ai;

            if (currentAgent->beatInterval != prevBeatInterval) {

                if ((prevBeatInterval>=0) && !created && (ev.time<5.0)) {

#ifdef DEBUG_BEATROOT

                    std::cerr << "Creating a new agent" << std::endl;

#endif

                    // Create new agent with different phase

                    Agent *newAgent = new Agent(params, prevBeatInterval);

                    // This may add another agent to our list as well

                    newAgent->considerAsBeat(ev, *this);

                    add(newAgent);

                }

                prevBeatInterval = currentAgent->beatInterval;

                created = phaseGiven;

            }

            if (currentAgent->considerAsBeat(ev, *this))

                created = true;

            add(currentAgent);

        } // loop for each agent

        removeDuplicates();

    } // loop for each event

} // beatTrack()

Agent *AgentList::bestAgent()

{

    double best = -1.0;

    Agent *bestAg = 0;

    for (iterator itr = begin(); itr != end(); ++itr) {

        if ((*itr)->events.empty()) continue;

        double conf = ((*itr)->phaseScore + (*itr)->tempoScore) /

            (useAverageSalience? (double)(*itr)->beatCount: 1.0);

        if (conf > best) {

            bestAg = *itr;

            best = conf;

        }

    }

#ifdef DEBUG_BEATROOT

    if (bestAg) {

        std::cerr << "Best agent: Ag#" << bestAg->idNumber << std::endl;

        std::cerr << "  Av-salience = " << best << std::endl;

    } else {

        std::cerr << "No surviving agent - beat tracking failed" << std::endl;

    }

#endif

    return bestAg;

} // bestAgent()

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

  Vamp feature extraction plugin for the BeatRoot beat tracker.

  Centre for Digital Music, Queen Mary, University of London.

  This file copyright 2011 Simon Dixon, Chris Cannam and QMUL.

  This program is free software; you can redistribute it and/or

  modify it under the terms of the GNU General Public License as

  published by the Free Software Foundation; either version 2 of the

  License, or (at your option) any later version.  See the file

  COPYING included with this distribution for more information.

*/

#ifndef _AGENT_LIST_H_

#define _AGENT_LIST_H_

#include "Agent.h"

#include "Event.h"

#include <vector>

#include <algorithm>

#ifdef DEBUG_BEATROOT

#include <iostream>

#endif

/** Class for maintaining the set of all Agents involved in beat tracking a piece of music.

 */

class AgentList

{

public:

    typedef std::vector<Agent *> Container;

    typedef Container::iterator iterator;

protected:

    Container list;

    static bool agentComparator(const Agent *a, const Agent *b) {

        if (a->beatInterval == b->beatInterval) {

            return a->idNumber < b->idNumber; // ensure stable ordering

        } else {

            return a->beatInterval < b->beatInterval;

        }

    }

public:

    // expose some vector methods

    //!!! can we remove these again once the rest of AgentList is implemented?

    bool empty() const { return list.empty(); }

    Container::iterator begin() { return list.begin(); }

    Container::iterator end() { return list.end(); }

    size_t size() { return list.size(); }

    void push_back(Agent *a) {

        list.push_back(a);

#ifdef DEBUG_BEATROOT

        std::cerr << "  Added Ag#" << a->idNumber << ", have " << list.size() << " agent(s)" << std::endl;

#endif

    }

    /** Flag for choice between sum and average beat salience values for Agent scores.

     *  The use of summed saliences favours faster tempi or lower metrical levels. */

    static bool useAverageSalience;

    /** For the purpose of removing duplicate agents, the default JND of IBI */

    static const double DEFAULT_BI;

    /** For the purpose of removing duplicate agents, the default JND of phase */

    static const double DEFAULT_BT;

    /** Inserts newAgent into the list in ascending order of beatInterval */

    void add(Agent *a) {

	add(a, true);

    } // add()/1

    /** Appends newAgent to list (sort==false), or inserts newAgent into the list

     *  in ascending order of beatInterval

     *  @param newAgent The agent to be added to the list

     *  @param sort Flag indicating whether the list is sorted or not

     */

    void add(Agent *newAgent, bool sort){

        push_back(newAgent);

	if (sort) this->sort();

    } // add()/2

    /** Sorts the AgentList by increasing beatInterval. */

    void sort() {

#ifdef DEBUG_BEATROOT

        std::cerr << "sort: before: ";

        for (iterator i = list.begin(); i != list.end(); ++i) {

            std::cerr << (*i)->idNumber << " ";

        }

        std::cerr << std::endl;

#endif

	std::sort(list.begin(), list.end(), agentComparator);

#ifdef DEBUG_BEATROOT

        std::cerr << "sort: after: ";

        for (iterator i = list.begin(); i != list.end(); ++i) {

            std::cerr << (*i)->idNumber << " ";

        }

        std::cerr << std::endl;

#endif

    } // sort()

    /** Removes the given item from the list.

     *  @param ptr Points to the Agent which is removed from the list

     */

    void remove(iterator itr) {

	list.erase(itr);

    } // remove()

protected:

    /** Removes Agents from the list which are duplicates of other Agents.

     *  A duplicate is defined by the tempo and phase thresholds

     *  thresholdBI and thresholdBT respectively.

     */

    void removeDuplicates();

public:

    /** Perform beat tracking on a list of events (onsets).

     *  @param el The list of onsets (or events or peaks) to beat track

     */

    void beatTrack(EventList el, AgentParameters params) {

	beatTrack(el, params, -1.0);

    } // beatTrack()/1

    /** Perform beat tracking on a list of events (onsets).

     *  @param el The list of onsets (or events or peaks) to beat track.

     *  @param stop Do not find beats after <code>stop</code> seconds.

     */

    void beatTrack(EventList el, AgentParameters params, double stop);

    /** Finds the Agent with the highest score in the list, or NULL if beat tracking has failed.

     *  @return The Agent with the highest score

     */

    Agent *bestAgent();

}; // class AgentList

#endif

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

    Vamp feature extraction plugin for the BeatRoot beat tracker.

    Centre for Digital Music, Queen Mary, University of London.

    This file copyright 2011 Simon Dixon, Chris Cannam and QMUL.

    This program is free software; you can redistribute it and/or

    modify it under the terms of the GNU General Public License as

    published by the Free Software Foundation; either version 2 of the

    License, or (at your option) any later version.  See the file

    COPYING included with this distribution for more information.

*/

#include "BeatRootProcessor.h"

bool

BeatRootProcessor::silent = true;

void BeatRootProcessor::processFrame(const float *const *inputBuffers) {

    double flux = 0;

    for (int i = 0; i <= fftSize/2; i++) {

        double mag = sqrt(inputBuffers[0][i*2] * inputBuffers[0][i*2] +

                          inputBuffers[0][i*2+1] * inputBuffers[0][i*2+1]);

        if (mag > prevFrame[i]) flux += mag - prevFrame[i];

        prevFrame[i] = mag;

    }

    spectralFlux.push_back(flux);

} // processFrame()

EventList BeatRootProcessor::beatTrack(EventList *unfilledReturn) {

#ifdef DEBUG_BEATROOT

    std::cerr << "Spectral flux:" << std::endl;

    for (int i = 0; i < spectralFlux.size(); ++i) {

        if ((i % 8) == 0) std::cerr << "\n";

        std::cerr << spectralFlux[i] << " ";

    }

#endif

    double hop = hopTime;

    Peaks::normalise(spectralFlux);

    vector<int> peaks = Peaks::findPeaks(spectralFlux, (int)lrint(0.06 / hop), 0.35, 0.84, true);

    onsets.clear();

    onsets.resize(peaks.size(), 0);

    vector<int>::iterator it = peaks.begin();

    onsetList.clear();

    double minSalience = Peaks::min(spectralFlux);

    for (int i = 0; i < (int)onsets.size(); i++) {

        int index = *it;

        ++it;

        onsets[i] = index * hop;

        Event e = BeatTracker::newBeat(onsets[i], 0);

//			if (debug)

//				System.err.printf("Onset: %8.3f  %8.3f  %8.3f\n",

//						onsets[i], energy[index], slope[index]);

//			e.salience = slope[index];	// or combination of energy + slope??

        // Note that salience must be non-negative or the beat tracking system fails!

        e.salience = spectralFlux[index] - minSalience;

        onsetList.push_back(e);

    }

#ifdef DEBUG_BEATROOT

    std::cerr << "Onsets: " << onsetList.size() << std::endl;

#endif

    return BeatTracker::beatTrack(agentParameters, onsetList, unfilledReturn);

} // processFile()

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

  Vamp feature extraction plugin for the BeatRoot beat tracker.

  Centre for Digital Music, Queen Mary, University of London.

  This file copyright 2011 Simon Dixon, Chris Cannam and QMUL.

  This program is free software; you can redistribute it and/or

  modify it under the terms of the GNU General Public License as

  published by the Free Software Foundation; either version 2 of the

  License, or (at your option) any later version.  See the file

  COPYING included with this distribution for more information.

*/

#ifndef _BEATROOT_PROCESSOR_H_

#define _BEATROOT_PROCESSOR_H_

#include "Peaks.h"

#include "Event.h"

#include "BeatTracker.h"

#include <vector>

#include <cmath>

#ifdef DEBUG_BEATROOT

#include <iostream>

#endif

using std::vector;

class BeatRootProcessor

{

public:

    int getFFTSize() const { return fftSize; }

    int getHopSize() const { return hopSize; }

protected:

    /** Sample rate of audio */

    float sampleRate;

    /** Spacing of audio frames (determines the amount of overlap or

     *  skip between frames). This value is expressed in

     *  seconds. (Default = 0.020s) */

    double hopTime;

    /** The approximate size of an FFT frame in seconds. (Default =

     *  0.04644s).  The value is adjusted so that <code>fftSize</code>

     *  is always power of 2. */

    double fftTime;

    /** Spacing of audio frames in samples (see <code>hopTime</code>) */

    int hopSize;

    /** The size of an FFT frame in samples (see <code>fftTime</code>) */

    int fftSize;

    /** Spectral flux onset detection function, indexed by frame. */

    vector<double> spectralFlux;

    /** A mapping function for mapping FFT bins to final frequency bins.

     *  The mapping is linear (1-1) until the resolution reaches 2 points per

     *  semitone, then logarithmic with a semitone resolution.  e.g. for

     *  44.1kHz sampling rate and fftSize of 2048 (46ms), bin spacing is

     *  21.5Hz, which is mapped linearly for bins 0-34 (0 to 732Hz), and

     *  logarithmically for the remaining bins (midi notes 79 to 127, bins 35 to

     *  83), where all energy above note 127 is mapped into the final bin. */

    vector<int> freqMap;

    /** The number of entries in <code>freqMap</code>. Note that the length of

     *  the array is greater, because its size is not known at creation time. */

    int freqMapSize;

    /** The magnitude spectrum of the most recent frame.  Used for

     *  calculating the spectral flux. */

    vector<double> prevFrame;

    /** The estimated onset times from peak-picking the onset

     * detection function(s). */

    vector<double> onsets;

    /** The estimated onset times and their saliences. */	

    EventList onsetList;

    /** User-specifiable processing parameters. */

    AgentParameters agentParameters;

    /** Flag for suppressing all standard output messages except results. */

    static bool silent;

public:

    /** Constructor: note that streams are not opened until the input

     *  file is set (see <code>setInputFile()</code>). */

    BeatRootProcessor(float sr, AgentParameters parameters) :

        sampleRate(sr),

        hopTime(0.010),

        fftTime(0.04644),

        hopSize(0),

        fftSize(0),

        agentParameters(parameters)

    {

        hopSize = lrint(sampleRate * hopTime);

        fftSize = lrint(pow(2, lrint( log(fftTime * sampleRate) / log(2))));

        init();

    } // constructor

    void reset() {

        init();

    }

    /** Processes a frame of frequency-domain audio data by mapping

     *  the frequency bins into a part-linear part-logarithmic array,

     *  then computing the spectral flux then (optionally) normalising

     *  and calculating onsets.

     */

    void processFrame(const float *const *inputBuffers);

    /** Tracks beats once all frames have been processed by processFrame

     */

    EventList beatTrack(EventList *optionalUnfilledBeatReturn);

protected:

    /** Allocates or re-allocates memory for arrays, based on parameter settings */

    void init() {

#ifdef DEBUG_BEATROOT

        std::cerr << "BeatRootProcessor::init()" << std::endl;

#endif

        makeFreqMap(fftSize, sampleRate);

        prevFrame.clear();

        for (int i = 0; i <= fftSize/2; i++) prevFrame.push_back(0);

        spectralFlux.clear();

        onsets.clear();

        onsetList.clear();

    } // init()

    /** Creates a map of FFT frequency bins to comparison bins.

     *  Where the spacing of FFT bins is less than 0.5 semitones, the mapping is

     *  one to one. Where the spacing is greater than 0.5 semitones, the FFT

     *  energy is mapped into semitone-wide bins. No scaling is performed; that

     *  is the energy is summed into the comparison bins. See also

     *  processFrame()

     */

    void makeFreqMap(int fftSize, float sampleRate) {

        freqMap.resize(fftSize/2+1);

        double binWidth = sampleRate / fftSize;

        int crossoverBin = (int)(2 / (pow(2, 1/12.0) - 1));

        int crossoverMidi = (int)lrint(log(crossoverBin*binWidth/440)/

                                       log(2) * 12 + 69);

        int i = 0;

        while (i <= crossoverBin && i <= fftSize/2) {

            freqMap[i] = i;

            ++i;

        }

        while (i <= fftSize/2) {

            double midi = log(i*binWidth/440) / log(2) * 12 + 69;

            if (midi > 127)

                midi = 127;

            freqMap[i] = crossoverBin + (int)lrint(midi) - crossoverMidi;

            ++i;

        }

        freqMapSize = freqMap[i-1] + 1;

    } // makeFreqMap()

}; // class AudioProcessor

#endif

#include "BeatRootProcessor.h"

#include "Event.h"

#include <vamp-sdk/RealTime.h>

#include <vamp-sdk/PluginAdapter.h>

    Plugin(inputSampleRate),

    m_firstFrame(true)

    m_processor = new BeatRootProcessor(inputSampleRate, AgentParameters());

    ParameterDescriptor desc;

    desc.identifier = "preMarginFactor";

    desc.name = "Pre-Margin Factor";

    desc.description = "The maximum amount by which a beat can be earlier than the predicted beat time, expressed as a fraction of the beat period.";

    desc.minValue = 0;

    desc.maxValue = 1;

    desc.defaultValue = AgentParameters::DEFAULT_PRE_MARGIN_FACTOR;

    desc.isQuantized = false;

    list.push_back(desc);

    desc.identifier = "postMarginFactor";

    desc.name = "Post-Margin Factor";

    desc.description = "The maximum amount by which a beat can be later than the predicted beat time, expressed as a fraction of the beat period.";

    desc.minValue = 0;

    desc.maxValue = 1;

    desc.defaultValue = AgentParameters::DEFAULT_POST_MARGIN_FACTOR;

    desc.isQuantized = false;

    list.push_back(desc);

    desc.identifier = "maxChange";

    desc.name = "Maximum Change";

    desc.description = "The maximum allowed deviation from the initial tempo, expressed as a fraction of the initial beat period.";

    desc.minValue = 0;

    desc.maxValue = 1;

    desc.defaultValue = AgentParameters::DEFAULT_MAX_CHANGE;

    desc.isQuantized = false;

    list.push_back(desc);

    desc.identifier = "expiryTime";

    desc.name = "Expiry Time";

    desc.description = "The default value of expiryTime, which is the time (in seconds) after which an Agent that has no Event matching its beat predictions will be destroyed.";

    desc.minValue = 2;

    desc.maxValue = 120;

    desc.defaultValue = AgentParameters::DEFAULT_EXPIRY_TIME;

    desc.isQuantized = false;

    list.push_back(desc);

    // Simon says...

    // These are the parameters that should be exposed (Agent.cpp):

    // If Pop, both margins should be lower (0.1).  If classical

    // music, post margin can be increased

    //

    // double Agent::POST_MARGIN_FACTOR = 0.3;

    // double Agent::PRE_MARGIN_FACTOR = 0.15;

    //

    // Max Change tells us how much tempo can change - so for

    // classical we should make it higher

    // 

    // double Agent::MAX_CHANGE = 0.2;

    // 

    // The EXPIRY TIME default should be defaulted to 100 (usual cause

    // of agents dying....)  it should also be exposed in order to

    // troubleshoot eventual problems in songs with big silences in

    // the beggining/end.

    // 

    // const double Agent::DEFAULT_EXPIRY_TIME = 10.0;

    if (identifier == "preMarginFactor") {

        return m_parameters.preMarginFactor;

    } else if (identifier == "postMarginFactor") {

        return m_parameters.postMarginFactor;

    } else if (identifier == "maxChange") {

        return m_parameters.maxChange;

    } else if (identifier == "expiryTime") {

        return m_parameters.expiryTime;

    }

    if (identifier == "preMarginFactor") {

        m_parameters.preMarginFactor = value;

    } else if (identifier == "postMarginFactor") {

        m_parameters.postMarginFactor = value;

    } else if (identifier == "maxChange") {

        m_parameters.maxChange = value;

    } else if (identifier == "expiryTime") {

        m_parameters.expiryTime = value;

    }

    d.sampleRate = m_inputSampleRate;

    d.identifier = "unfilled";

    d.name = "Un-interpolated beats";

    d.description = "Locations of detected beats, before agent interpolation occurs";

    list.push_back(d);

    // Delete the processor that was created with default parameters

    // and used to determine the expected step and block size; replace

    // with one using the actual parameters we have

    delete m_processor;

    m_processor = new BeatRootProcessor(m_inputSampleRate, m_parameters);

    m_firstFrame = true;

    m_origin = Vamp::RealTime::zeroTime;

    if (m_firstFrame) {

        m_origin = timestamp;

        m_firstFrame = false;

    }

    m_processor->processFrame(inputBuffers);

    EventList unfilled;

    EventList el = m_processor->beatTrack(&unfilled);

    Feature f;

    f.hasTimestamp = true;

    f.hasDuration = false;

    f.label = "";

    f.values.clear();

    FeatureSet fs;

    for (EventList::const_iterator i = el.begin(); i != el.end(); ++i) {

        f.timestamp = m_origin + Vamp::RealTime::fromSeconds(i->time);

        fs[0].push_back(f);

    }

    for (EventList::const_iterator i = unfilled.begin(); 

         i != unfilled.end(); ++i) {

        f.timestamp = m_origin + Vamp::RealTime::fromSeconds(i->time);

        fs[1].push_back(f);

    }

    return fs;

#include "Agent.h"

class BeatRootProcessor;

    AgentParameters m_parameters;

    Vamp::RealTime m_origin;

    bool m_firstFrame;

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

  Vamp feature extraction plugin for the BeatRoot beat tracker.

  Centre for Digital Music, Queen Mary, University of London.

  This file copyright 2011 Simon Dixon, Chris Cannam and QMUL.

  This program is free software; you can redistribute it and/or

  modify it under the terms of the GNU General Public License as

  published by the Free Software Foundation; either version 2 of the

  License, or (at your option) any later version.  See the file

  COPYING included with this distribution for more information.

*/

#include "BeatTracker.h"

EventList BeatTracker::beatTrack(AgentParameters params,

                                 EventList events, EventList beats,

                                 EventList *unfilledReturn)

{

    AgentList agents;

    int count = 0;

    double beatTime = -1;

    if (!beats.empty()) {

	count = beats.size() - 1;

	EventList::iterator itr = beats.end();

	--itr;

	beatTime = itr->time;

    }

    if (count > 0) { // tempo given by mean of initial beats

	double ioi = (beatTime - beats.begin()->time) / count;

	agents.push_back(new Agent(params, ioi));

    } else // tempo not given; use tempo induction

	agents = Induction::beatInduction(params, events);

    if (!beats.empty())

	for (AgentList::iterator itr = agents.begin(); itr != agents.end();

	     ++itr) {

	    (*itr)->beatTime = beatTime;

	    (*itr)->beatCount = count;

	    (*itr)->events = beats;

	}

    agents.beatTrack(events, params, -1);

    Agent *best = agents.bestAgent();

    EventList results;

    if (best) {

        if (unfilledReturn) *unfilledReturn = best->events;

	best->fillBeats(beatTime);

	results = best->events;

    }

    for (AgentList::iterator ai = agents.begin(); ai != agents.end(); ++ai) {

	delete *ai;

    }

    return results;

} // beatTrack()/1

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */

/*

  Vamp feature extraction plugin for the BeatRoot beat tracker.

  Centre for Digital Music, Queen Mary, University of London.

  This file copyright 2011 Simon Dixon, Chris Cannam and QMUL.

  This program is free software; you can redistribute it and/or

  modify it under the terms of the GNU General Public License as

  published by the Free Software Foundation; either version 2 of the

  License, or (at your option) any later version.  See the file

  COPYING included with this distribution for more information.

*/

#ifndef _BEAT_TRACKER_H_

#define _BEAT_TRACKER_H_

#include "Event.h"

#include "Agent.h"

#include "AgentList.h"

#include "Induction.h"

using std::vector;

class BeatTracker

{

protected:

    /** beat data encoded as a list of Events */

    EventList beats;

    /** a list of onset events for passing to the tempo induction and beat tracking methods */

    EventList onsetList;

    /** the times of onsets (in seconds) */

    vector<double> onsets;

public:

    /** Constructor:

     *  @param b The list of beats

     */

    BeatTracker(EventList b) {

	beats = b;

    } // BeatTracker constructor

    /** Creates a new Event object representing a beat.

     *  @param time The time of the beat in seconds

     *  @param beatNum The index of the beat

     *  @return The Event object representing the beat

     */

    static Event newBeat(double time, int beatNum) {

	return Event(time, beatNum, 0);

    } // newBeat()

    /** Perform beat tracking.

     *  @param events The onsets or peaks in a feature list

     *  @param unfilledReturn Pointer to list in which to return 

     *     un-interpolated beats, or NULL

     *  @return The list of beats, or an empty list if beat tracking fails

     */

    static EventList beatTrack(AgentParameters params, EventList events,

                               EventList *unfilledReturn) {

	return beatTrack(params, events, EventList(), unfilledReturn);

    }

    /** Perform beat tracking.

     *  @param events The onsets or peaks in a feature list

     *  @param beats The initial beats which are given, if any

     *  @param unfilledReturn Pointer to list in which to return

     *     un-interpolated beats, or NULL

     *  @return The list of beats, or an empty list if beat tracking fails

     */

    static EventList beatTrack(AgentParameters params,

                               EventList events, EventList beats,

                               EventList *unfilledReturn);

    // Various get and set methods

    /** @return the list of beats */

    EventList getBeats() {

	return beats;

    } // getBeats()

    /** @return the array of onset times */

    vector<double> getOnsets() {

	return onsets;

    } // getOnsets()

    /** Sets the onset times as a list of Events, for use by the beat tracking methods. 

     *  @param on The times of onsets in seconds

     */

    void setOnsetList(EventList on) {

	onsetList = on;

    } // setOnsetList()

    /** Sets the array of onset times, for displaying MIDI or audio input data.

     *  @param on The times of onsets in seconds

     */

    void setOnsets(vector<double> on) {

	onsets = on;

    } // setOnsets()

    /** Sets the list of beats.

     * @param b The list of beats

     */

    void setBeats(EventList b) {

	beats = b;

    } // setBeats()

}; // class BeatTrackDisplay

#endif

@article{simon2001a,

  author = {Simon Dixon},

  title = {Automatic Extraction of Tempo and Beat from Expressive Performances},

  journal = {Journal of New Music Research},

  number = {1},

  pages = {39-58},

  volume = {30},

  year = {2001}

} 

@misc{chris2013a,

  author = {Chris Cannam and Matthias Mauch and Matthew E. P. Davies and Dixon, Simon and Christian Landone and Katy C. Noland and Mark Levy and Massimiliano Zanoni and Dan Stowell and Luís A. Figueira},

  title = {MIREX 2013 Entry: Vamp Plugins from the Centre for Digital Music},

  year = {2013}

} 

		    GNU GENERAL PUBLIC LICENSE

		       Version 2, June 1991

 Copyright (C) 1989, 1991 Free Software Foundation, Inc.,

 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

 Everyone is permitted to copy and distribute verbatim copies

 of this license document, but changing it is not allowed.

			    Preamble

  The licenses for most software are designed to take away your

freedom to share and change it.  By contrast, the GNU General Public

License is intended to guarantee your freedom to share and change free

software--to make sure the software is free for all its users.  This

General Public License applies to most of the Free Software

Foundation's software and to any other program whose authors commit to

using it.  (Some other Free Software Foundation software is covered by

the GNU Lesser General Public License instead.)  You can apply it to

your programs, too.

  When we speak of free software, we are referring to freedom, not

price.  Our General Public Licenses are designed to make sure that you

have the freedom to distribute copies of free software (and charge for

this service if you wish), that you receive source code or can get it

if you want it, that you can change the software or use pieces of it

in new free programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid

anyone to deny you these rights or to ask you to surrender the rights.

These restrictions translate to certain responsibilities for you if you

distribute copies of the software, or if you modify it.

  For example, if you distribute copies of such a program, whether

gratis or for a fee, you must give the recipients all the rights that

you have.  You must make sure that they, too, receive or can get the

source code.  And you must show them these terms so they know their

rights.

  We protect your rights with two steps: (1) copyright the software, and

(2) offer you this license which gives you legal permission to copy,

distribute and/or modify the software.

  Also, for each author's protection and ours, we want to make certain

that everyone understands that there is no warranty for this free

software.  If the software is modified by someone else and passed on, we

want its recipients to know that what they have is not the original, so

that any problems introduced by others will not reflect on the original

authors' reputations.

  Finally, any free program is threatened constantly by software

patents.  We wish to avoid the danger that redistributors of a free

program will individually obtain patent licenses, in effect making the

program proprietary.  To prevent this, we have made it clear that any

patent must be licensed for everyone's free use or not licensed at all.

  The precise terms and conditions for copying, distribution and

modification follow.

		    GNU GENERAL PUBLIC LICENSE

   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License applies to any program or other work which contains

a notice placed by the copyright holder saying it may be distributed

under the terms of this General Public License.  The "Program", below,

refers to any such program or work, and a "work based on the Program"

means either the Program or any derivative work under copyright law:

that is to say, a work containing the Program or a portion of it,

either verbatim or with modifications and/or translated into another

language.  (Hereinafter, translation is included without limitation in

the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not

covered by this License; they are outside its scope.  The act of

running the Program is not restricted, and the output from the Program

is covered only if its contents constitute a work based on the

Program (independent of having been made by running the Program).

Whether that is true depends on what the Program does.

  1. You may copy and distribute verbatim copies of the Program's

source code as you receive it, in any medium, provided that you

conspicuously and appropriately publish on each copy an appropriate

copyright notice and disclaimer of warranty; keep intact all the

notices that refer to this License and to the absence of any warranty;

and give any other recipients of the Program a copy of this License

along with the Program.

You may charge a fee for the physical act of transferring a copy, and

you may at your option offer warranty protection in exchange for a fee.

  2. You may modify your copy or copies of the Program or any portion

of it, thus forming a work based on the Program, and copy and

distribute such modifications or work under the terms of Section 1

above, provided that you also meet all of these conditions:

    a) You must cause the modified files to carry prominent notices

    stating that you changed the files and the date of any change.

    b) You must cause any work that you distribute or publish, that in

    whole or in part contains or is derived from the Program or any

    part thereof, to be licensed as a whole at no charge to all third

    parties under the terms of this License.

    c) If the modified program normally reads commands interactively

    when run, you must cause it, when started running for such

    interactive use in the most ordinary way, to print or display an

    announcement including an appropriate copyright notice and a

    notice that there is no warranty (or else, saying that you provide

    a warranty) and that users may redistribute the program under

    these conditions, and telling the user how to view a copy of this

    License.  (Exception: if the Program itself is interactive but

    does not normally print such an announcement, your work based on

    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If

identifiable sections of that work are not derived from the Program,

and can be reasonably considered independent and separate works in

themselves, then this License, and its terms, do not apply to those

sections when you distribute them as separate works.  But when you

distribute the same sections as part of a whole which is a work based

on the Program, the distribution of the whole must be on the terms of

this License, whose permissions for other licensees extend to the

entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest

your rights to work written entirely by you; rather, the intent is to

exercise the right to control the distribution of derivative or

collective works based on the Program.

In addition, mere aggregation of another work not based on the Program

with the Program (or with a work based on the Program) on a volume of

a storage or distribution medium does not bring the other work under

the scope of this License.

  3. You may copy and distribute the Program (or a work based on it,

under Section 2) in object code or executable form under the terms of

Sections 1 and 2 above provided that you also do one of the following:

    a) Accompany it with the complete corresponding machine-readable

    source code, which must be distributed under the terms of Sections

    1 and 2 above on a medium customarily used for software interchange; or,

    b) Accompany it with a written offer, valid for at least three

    years, to give any third party, for a charge no more than your

    cost of physically performing source distribution, a complete

    machine-readable copy of the corresponding source code, to be

    distributed under the terms of Sections 1 and 2 above on a medium

    customarily used for software interchange; or,

    c) Accompany it with the information you received as to the offer

    to distribute corresponding source code.  (This alternative is

    allowed only for noncommercial distribution and only if you

    received the program in object code or executable form with such

    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for

making modifications to it.  For an executable work, complete source

code means all the source code for all modules it contains, plus any

associated interface definition files, plus the scripts used to

control compilation and installation of the executable.  However, as a

special exception, the source code distributed need not include

anything that is normally distributed (in either source or binary