BeatRoot Vamp Plugin

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::CONF_FACTOR = 0.5;

             err / correctionFactor) < maxChange * initialBeatInterval)

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;

};

    /** 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. */

    /** 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. */

    /** 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;

    /** 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. */

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

     * otherwise not used. */

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

     * interpolated beats. */

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

     * beat period in seconds. */

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

     * beat period in seconds. */

    /** 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. */

    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) {

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

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

    void beatTrack(EventList el, AgentParameters params) {

	beatTrack(el, params, -1.0);

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

    return BeatTracker::beatTrack(agentParameters, onsetList);

    /** User-specifiable processing parameters. */

    AgentParameters agentParameters;

    BeatRootProcessor(float sr, AgentParameters parameters) :

        sampleRate(sr),

        hopSize(0),

        fftSize(0),

        hopTime(0.010),

        fftTime(0.04644),

        agentParameters(parameters)

    {

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

    ParameterDescriptor desc;

    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. */

    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;

    }

    // 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);

#include "Agent.h"

    AgentParameters m_parameters;

EventList BeatTracker::beatTrack(AgentParameters params,

                                 EventList events, EventList beats)

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

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

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

    static EventList beatTrack(AgentParameters params, EventList events) {

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

    static EventList beatTrack(AgentParameters params,

                               EventList events, EventList beats);

AgentList Induction::beatInduction(AgentParameters params, EventList events) {

            a.push_back(new Agent(params, beat));

    static AgentList beatInduction(AgentParameters params, EventList events);