OFA Vamp Plugin

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

/*

    Vamp feature extraction plugin using MusicIP OFA library.

    See README for more information and licensing terms.

*/

#include "OfaVampPlugin.h"

#include <vamp/vamp.h>

#include <vamp-sdk/PluginAdapter.h>

#include <vamp-sdk/RealTime.h>

#include <cstdlib>

#include <cmath>

#include <ofa1/ofa.h>

#include <endian.h>

#include "protocol.h"

using std::string;

OfaVampPlugin::OfaVampPlugin(float inputSampleRate, Type type) :

    Plugin(inputSampleRate),

    m_type(type),

    m_buffer(0),

    m_bufsiz(0),

    m_bufidx(0),

    m_channels(0),

    m_blockSize(0),

    m_totalCount(0),

    m_enough(false)

{

}

OfaVampPlugin::~OfaVampPlugin()

{

    if (m_buffer) free(m_buffer);

}

string

OfaVampPlugin::getMaker() const

{

    return "Chris Cannam, using MusicIP OFA library";

}

int

OfaVampPlugin::getPluginVersion() const

{

    return 1;

}

string

OfaVampPlugin::getCopyright() const

{

    return "GPL";

}

OfaVampPlugin::ParameterList

OfaVampPlugin::getParameterDescriptors() const

{

    ParameterList list;

    return list;

}

float

OfaVampPlugin::getParameter(std::string name) const

{

    return 0.0;

}

void

OfaVampPlugin::setParameter(std::string name, float value)

{

}

size_t

OfaVampPlugin::getPreferredStepSize() const

{

    return 0;

}

size_t

OfaVampPlugin::getPreferredBlockSize() const

{

    return 0;

}

bool

OfaVampPlugin::initialise(size_t channels, size_t stepSize, size_t blockSize)

{

    if (stepSize != blockSize) {

        std::cerr << "ERROR: OfaVampPlugin::initialise: stepSize must be equal to blockSize (" << stepSize << " != " << blockSize << ")" << std::endl;

        return false;

    }

    m_bufsiz = 1048576;

    m_buffer = (int16_t *)malloc(m_bufsiz * sizeof(int16_t));

    m_bufidx = 0;

    m_channels = channels;

    m_blockSize = blockSize;

    m_totalCount = 0;

    m_enough = false;

    return true;

}

void

OfaVampPlugin::reset()

{

    m_bufidx = 0;

    m_totalCount = 0;

    m_print = "";

    m_enough = false;

}

OfaVampPlugin::OutputList

OfaVampPlugin::getOutputDescriptors() const

{

    OutputList list;

    OutputDescriptor desc;

    m_fingerprintResultIndex = -1;

    m_puidResultIndex = -1;

    int index = 0;

    if (m_type == TypeFingerprint || m_type == TypeBoth) {

        desc.identifier = "fingerprint";

        desc.name = "Fingerprint";

        desc.description = "Single result containing the audio fingerprint as its label";

        desc.unit = "";

        desc.hasFixedBinCount = true;

        desc.binCount = 0;

        desc.hasKnownExtents = false;

        desc.isQuantized = false;

        desc.sampleType = OutputDescriptor::VariableSampleRate;

        desc.sampleRate = m_inputSampleRate;

        list.push_back(desc);

        m_fingerprintResultIndex = index;

        ++index;

    }

    if (m_type == TypePUID || m_type == TypeBoth) {

        desc.identifier = "puid";

        desc.name = "PUID";

        desc.description = "Single result containing the MusicIP online PUID for this audio track, if available";

        desc.unit = "";

        desc.hasFixedBinCount = true;

        desc.binCount = 0;

        desc.hasKnownExtents = false;

        desc.isQuantized = false;

        desc.sampleType = OutputDescriptor::VariableSampleRate;

        desc.sampleRate = m_inputSampleRate;

        list.push_back(desc);

        m_puidResultIndex = index;

        ++index;

    }

    return list;

}

// client id: a008bd70c9d3c681e2ff336e3ceaa6dc (limited)

OfaVampPlugin::FeatureSet

OfaVampPlugin::process(const float *const *inputBuffers,

                       Vamp::RealTime timestamp)

{

    m_totalCount += m_blockSize;

    if (m_enough) return FeatureSet();

    // libofa requires the first 135 seconds of audio (where available)

    size_t reqd = lrintf(ceil(135.f * m_inputSampleRate));

    size_t effectiveChannels = m_channels;

    if (effectiveChannels > 2) effectiveChannels = 2;

    if (m_bufidx + m_blockSize * effectiveChannels > m_bufsiz) {

        m_bufsiz *= 2;

        m_buffer = (int16_t *)realloc(m_buffer, m_bufsiz * sizeof(int16_t));

        std::cerr << "realloc " << m_bufsiz/2 << " -> " << m_bufsiz << std::endl;

    }

    for (size_t i = 0; i < m_blockSize; ++i) {

        for (size_t c = 0; c < effectiveChannels; ++c) {

            m_buffer[m_bufidx + i * effectiveChannels + c] = 

                int16_t(inputBuffers[c][i] * 32767.0);

        }

    }

    m_bufidx += m_blockSize * effectiveChannels;

    if (m_bufidx >= reqd * effectiveChannels) {

        m_enough = true;

        FeatureSet fset;

        int endian = OFA_LITTLE_ENDIAN;

#ifdef __BYTE_ORDER

#if __BYTE_ORDER == _BIG_ENDIAN

        endian = OFA_BIG_ENDIAN;

#endif

#endif

        const char *print = ofa_create_print

            ((unsigned char *)m_buffer,

             endian,

             m_bufidx,

             lrintf(m_inputSampleRate),

             m_channels > 1);

        if (!print) {

            std::cerr << "OfaVampPlugin: ERROR from libofa" << std::endl;

            return fset;

        }

        m_print = print;

        if (m_fingerprintResultIndex >= 0) {

            Feature feature;

            feature.hasTimestamp = true;

            feature.timestamp = Vamp::RealTime::zeroTime;

            feature.label = m_print;

            fset[m_fingerprintResultIndex].push_back(feature);

            return fset;

        }

    }

    return FeatureSet();

}

OfaVampPlugin::FeatureSet

OfaVampPlugin::getRemainingFeatures()

{

    FeatureSet fset;

    if (m_print == "" || m_puidResultIndex < 0) return fset;

    Feature feature;

    feature.hasTimestamp = true;

    feature.timestamp = Vamp::RealTime::zeroTime;

    int endian = OFA_LITTLE_ENDIAN;

#ifdef __BYTE_ORDER

#if __BYTE_ORDER == _BIG_ENDIAN

        endian = OFA_BIG_ENDIAN;

#endif

#endif

    AudioData data;

    data.setData

        (0, 

         endian,

         m_bufidx,

         lrintf(m_inputSampleRate),

         m_channels > 1,

         lrintf((m_totalCount * 1000.f) / m_inputSampleRate), //!!! approx

         "wav"); //!!!

    data.info.setPrint(m_print);

    TrackInformation *info = data.getMetadata

        ("a008bd70c9d3c681e2ff336e3ceaa6dc",

         "1",

         false);

    if (!info) {

        std::cerr << "OfaVampPlugin: ERROR from ofa/protocol, unable to retrieve PUID for fingerprint" << std::endl;

        std::cerr << "Fingerprint was: " << m_print << std::endl;

    } else {

        feature.label = info->getPUID();

        fset[m_puidResultIndex].push_back(feature);

    }

    return fset;

}

static Vamp::PluginAdapter<OfaFingerprintPlugin> ofaFingerprintAdapter;

static Vamp::PluginAdapter<OfaPUIDPlugin> ofaPUIDAdapter;

const VampPluginDescriptor *vampGetPluginDescriptor(unsigned int version,

                                                    unsigned int index)

{

    if (version < 1) return 0;

    switch (index) {

    case  0: return ofaFingerprintAdapter.getDescriptor();

    case  1: return ofaPUIDAdapter.getDescriptor();

    default: return 0;

    }

}