OFA Vamp Plugin

CXXFLAGS	:= -I../vamp-plugin-sdk -O3 -Wall -march=pentium4 -msse -msse2 -fomit-frame-pointer -ffast-math

ofa-vamp-plugin.so:	OfaVampPlugin.o protocol.o

	g++ -shared $^ -o $@ -L../vamp-plugin-sdk/vamp-sdk -Wl,-Bstatic -lvamp-sdk -Wl,-Bdynamic -lofa -lcurl -lexpat

clean:	

	rm *.o

OfaVampPlugin.o: OfaVampPlugin.h protocol.h

protocol.o: protocol.h

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

#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) :

    Plugin(inputSampleRate),

    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::getIdentifier() const

{

    return "ofa";

}

string

OfaVampPlugin::getName() const

{

    return "MusicIP OFA Audio Fingerprinter";

}

string

OfaVampPlugin::getDescription() const

{

    return "Calculates an audio fingerprint using the MusicIP fingerprinting library";

}

string

OfaVampPlugin::getMaker() const

{

    return "Chris Cannam";

}

int

OfaVampPlugin::getPluginVersion() const

{

    return 1;

}

string

OfaVampPlugin::getCopyright() const

{

    return ""; //!!!

}

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;

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

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

    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;

        Feature feature;

        feature.hasTimestamp = true;

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

        feature.label = m_print;

        fset[0].push_back(feature);

        return fset;

    }

    return FeatureSet();

}

OfaVampPlugin::FeatureSet

OfaVampPlugin::getRemainingFeatures()

{

    FeatureSet fset;

    if (m_print == "") 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[1].push_back(feature);

    }

    return fset;

}

static Vamp::PluginAdapter<OfaVampPlugin> ofaAdapter;

const VampPluginDescriptor *vampGetPluginDescriptor(unsigned int version,

                                                    unsigned int index)

{

    if (version < 1) return 0;

    switch (index) {

    case  0: return ofaAdapter.getDescriptor();

    default: return 0;

    }

}

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

#ifndef _OFA_VAMP_PLUGIN_H_

#define _OFA_VAMP_PLUGIN_H_

#include <vamp-sdk/Plugin.h>

#include <pthread.h>

class OfaVampPlugin : public Vamp::Plugin

{

public:

    OfaVampPlugin(float inputSampleRate);

    virtual ~OfaVampPlugin();

    bool initialise(size_t channels, size_t stepSize, size_t blockSize);

    void reset();

    InputDomain getInputDomain() const { return TimeDomain; }

    size_t getPreferredStepSize() const;

    size_t getPreferredBlockSize() const;

    size_t getMinChannelCount() const { return 1; }

    size_t getMaxChannelCount() const { return 2; }

    std::string getIdentifier() const;

    std::string getName() const;

    std::string getDescription() const;

    std::string getMaker() const;

    int getPluginVersion() const;

    std::string getCopyright() const;

    ParameterList getParameterDescriptors() const;

    float getParameter(std::string) const;

    void setParameter(std::string, float);

    OutputList getOutputDescriptors() const;

    FeatureSet process(const float *const *inputBuffers,

                       Vamp::RealTime timestamp);

    FeatureSet getRemainingFeatures();

protected:

    int16_t *m_buffer;

    size_t m_bufsiz;

    size_t m_bufidx;

    size_t m_channels;

    size_t m_blockSize;

    size_t m_totalCount;

    std::string m_print;

    bool m_enough;

};

#endif

vamp:ofa-vamp-plugin:ofa::Fingerprinting

/* ------------------------------------------------------------------

   libofa -- the Open Fingerprint Architecture library

   Public Domain (PD) 2006 MusicIP Corporation

   No rights reserved.

-------------------------------------------------------------------*/

#include <stdio.h>

#include <stdlib.h>

#include <string>

#include <map>

#include <expat.h>

#include <curl/curl.h>

#include <curl/types.h>

#include <curl/easy.h>

using namespace std;

#include "protocol.h"

const char *url = "http://ofa.musicdns.org/ofa/1/track"; 

const char *userAgent = "libofa_example";

const char *unknown = "unknown";

// Lookup by fingerprint

const char *request_format = 

    "cid=%s&"       // Client ID

    "cvr=%s&"       // Client Version

    "fpt=%s&"       // Fingerprint

    "rmd=%d&"       // m = 1: return metadata; m = 0: only return id 

    "brt=%d&"       // bitrate (kbps)

    "fmt=%s&"       // File extension (e.g. mp3, ogg, flac)

    "dur=%ld&"      // Length of track (milliseconds)

    "art=%s&"       // Artist name. If there is none, send "unknown"

    "ttl=%s&"       // Track title. If there is none, send "unknown"

    "alb=%s&"       // Album name. If there is none, send "unknown"

    "tnm=%d&"       // Track number in album. If there is none, send "0"

    "gnr=%s&"       // Genre. If there is none, send "unknown"

    "yrr=%s&"       // Year. If there is none, send "0"

    "enc=%s&"       // Encoding. e = true: ISO-8859-15; e = false: UTF-8 (default). Optional.

    "\r\n";

// Lookup by PUID (Most fields drop out)

const char *request_format2 =

    "cid=%s&"       // Client ID

    "cvr=%s&"       // Client Version

    "pid=%s&"       // PUID 

    "rmd=%d&"       // m = 1: return metadata; m = 0: only return id 

    "brt=%d&"       // bitrate (kbps)

    "fmt=%s&"       // File extension (e.g. mp3, ogg, flac)

    "dur=%ld&"      // Length of track (milliseconds)

    "art=%s&"       // Artist name. If there is none, send "unknown"

    "ttl=%s&"       // Track title. If there is none, send "unknown"

    "alb=%s&"       // Album name. If there is none, send "unknown"

    "tnm=%d&"       // Track number in album. If there is none, send "0"

    "gnr=%s&"       // Genre. If there is none, send "unknown"

    "yrr=%s&"       // Year. If there is none, send "0"

    "enc=%s&"       // Encoding. e = true: ISO-8859-15; e = false: UTF-8 (default). Optional.

    "\r\n";

// --------------------------------------------------------------------

// HTTP POST support using standard curl calls

// --------------------------------------------------------------------

size_t data_callback(void *ptr, size_t size, size_t num, void *arg)

{

    string *str = (string *)arg;

    (*str) += string((const char *)ptr, size * num);

    return size * num;

}

long http_post(const string &url, const string &userAgent, const string &postData, string &doc)

{

  CURL              *curl;

  long               ret = 0;

  struct curl_slist *headerlist=NULL;

  headerlist = curl_slist_append(headerlist, "Expect:"); 

  curl_global_init(CURL_GLOBAL_ALL);

  curl = curl_easy_init();

  curl_easy_setopt(curl, CURLOPT_URL, url.c_str());

  curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&doc);

  curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, data_callback);

  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);

  curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, postData.length());

  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postData.c_str());

  curl_easy_setopt(curl, CURLOPT_POST, 1);

  curl_easy_setopt(curl, CURLOPT_USERAGENT, userAgent.c_str());

  curl_easy_perform(curl);

  curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &ret);

  curl_easy_cleanup(curl);

  curl_slist_free_all (headerlist);

  return ret;

}

// --------------------------------------------------------------------

// XML Parsing support 

// --------------------------------------------------------------------

struct ParseInfo

{

    string path;

    string pcdata;

    TrackInformation *info;

};

void begin_element(void *data, const XML_Char *el, const XML_Char **attr)

{

    map<string, string> attrs;

    for(; *attr;) {

        string key = string((char *)*(attr++));

	string value = string((char *)*(attr++));

        attrs[key] = value;

    }

    ((ParseInfo *)data)->path += string("/") + string(el);

    if (((ParseInfo *)data)->path == "/metadata/track/puid-list/puid")

         ((ParseInfo *)data)->info->setPUID(attrs["id"]);

    ((ParseInfo *)data)->pcdata = "";

}

void end_element(void *data, const XML_Char *el)

{

    string::size_type pos;

    if (((ParseInfo *)data)->path == "/metadata/track/title")

         ((ParseInfo *)data)->info->setTrack(((ParseInfo *)data)->pcdata);

    if (((ParseInfo *)data)->path == "/metadata/track/artist/name")

         ((ParseInfo *)data)->info->setArtist(((ParseInfo *)data)->pcdata);

    pos = ((ParseInfo *)data)->path.rfind("/");

    if (pos != string::npos)

       ((ParseInfo *)data)->path = ((ParseInfo *)data)->path.substr(0, pos);

}

void pc_data(void *data, const XML_Char *charData, int len)

{

    char *temp;

    temp = new char[len + 1];

    strncpy(temp, (char *)charData, len);

    temp[len] = 0;

    ((ParseInfo *)data)->pcdata += string(temp);

    delete temp;

}

bool parse_xml(const string &doc, TrackInformation *info, string &err) 

{

    ParseInfo pinfo;

    err = "";

    pinfo.info = info;

    XML_Parser parser = XML_ParserCreate(NULL);

    XML_SetUserData(parser, (void *)&pinfo);

    XML_SetElementHandler(parser, ::begin_element, ::end_element);

    XML_SetCharacterDataHandler(parser, ::pc_data);

    int ret = XML_Parse(parser, doc.c_str(), doc.length(), 1);

    if (ret)

    {

        XML_ParserFree(parser);

        return true;

    }

    err = string(XML_ErrorString(XML_GetErrorCode(parser)));

    char num[10];

    sprintf(num, "%d", XML_GetCurrentLineNumber(parser));

    err += string(" on line ") + string(num);

    XML_ParserFree(parser);

    return false;

}

// --------------------------------------------------------------------

// Retrieve metadata for fingerprint

// --------------------------------------------------------------------

// Returns true on success

bool retrieve_metadata(string client_key, string client_version,

	TrackInformation *info, bool getMetadata) 

{

    if (!info)

	return false;

    // All metadata fields must be provided before this call if the

    // information is available, as part of the Terms of Service.

    // This helps create a better database for all users of the system.

    //

    // If the fields are not available, you can use default values.

    // Here we check for fields which have no default values.

    if (client_key.length() == 0)

	return false;

    if (client_version.length() == 0)

	return false;

    bool lookupByPrint = false;

    if (info->getPUID().length() == 0) {

	// Lookup by fingerprint

	if (info->getPrint().length() == 0)

	    return false;

	if (info->getFormat().length() == 0)

	    return false;

	if (info->getLengthInMS() == 0)

	    return false;

        lookupByPrint = true;

    }

    // Sloppily estimate the size of the resultant URL. Err on the side of making the string too big.

    int bufSize = strlen(lookupByPrint ? request_format : request_format2) +

            client_key.length() + client_version.length() +

            (lookupByPrint ? info->getPrint().length() : info->getPUID().length()) + 

            16 + // getMetadata ? 1 : 0, 

            16 + // info->getBitrate(),

            16 + //info->getFormat().c_str(), 

            16 + //info->getLengthInMS(), 

            ((info->getArtist().c_str() == 0) ? strlen(unknown) : info->getArtist().length()) +

            ((info->getTrack().c_str() == 0) ?  strlen(unknown) : info->getTrack().length()) +

            ((info->getAlbum().c_str() == 0) ?  strlen(unknown) : info->getAlbum().length()) +

            16 + // info->getTrackNum() + 

            ((info->getGenre().c_str() == 0) ?  strlen(unknown) : info->getGenre().length()) +

            ((info->getYear().c_str() == 0) ? 1 : info->getYear().length()) +

            info->getEncoding().length();

    char *buf = new char[bufSize];

    sprintf(buf, lookupByPrint ? request_format : request_format2, 

            client_key.c_str(), 

            client_version.c_str(),

            lookupByPrint ? info->getPrint().c_str() : info->getPUID().c_str(), 

            getMetadata ? 1 : 0, 

            info->getBitrate(),

            info->getFormat().c_str(), 

            info->getLengthInMS(), 

            (info->getArtist().length() == 0) ? unknown : info->getArtist().c_str(),

            (info->getTrack().length() == 0) ? unknown : info->getTrack().c_str(),

            (info->getAlbum().length() == 0) ? unknown : info->getAlbum().c_str(),

            info->getTrackNum(), 

            (info->getGenre().length() == 0) ? unknown : info->getGenre().c_str(),

            (info->getYear().length() == 0) ? "0" : info->getYear().c_str(),

            info->getEncoding().c_str());

    string response;

//    printf("request: '%s'\n", buf);

    long ret = http_post(url, userAgent, buf, response);

    delete [] buf;

    if (ret != 200)

    {

//	     printf("Error: %ld\n", ret);

//	     printf("response: %s\n\n", response.c_str());

        return false;

    }

//    printf("response: %s\n\n", response.c_str());

    unsigned int q = response.find("<?xml");

    if (q != string::npos) {

        response = response.substr(q);

    }

    string err;

    if (!parse_xml(response, info, err)) {

        // Clears title if it wasn't returned

        info->setTrack("");

        // Clears artists if it wasn't returned

        info->setArtist("");

    }

    return true;

}

/* ------------------------------------------------------------------

   libofa -- the Open Fingerprint Architecture library

   Public Domain (PD) 2006 MusicIP Corporation

   No rights reserved.

-------------------------------------------------------------------*/

#ifndef __PROTOCOL_H__

#define __PROTOCOL_H__

#include <string>

#include "ofa1/ofa.h"

using namespace std;

// This object must be filled out completely prior to making any

// calls to the server.  On return, some fields will be filled out.

class TrackInformation {

private:

    string puid;

    string print;

    string encoding;        // All other strings must honor this encoding

    int    bitrate;         // i.e. "192kbps", use 0 for VBR or freeformat

    string format;          // File extension

    long   length_in_ms;    // In milliseconds

    string artist;

    string track;

    string album;

    int    trackNum;        // use 0 if not known

    string genre;

    string year;

public:

    TrackInformation() :

	bitrate(0), length_in_ms(0), trackNum(0) {}

    ~TrackInformation() {}

    void setPrint(string p) { print = p; }

    string getPrint() const { return print; }

    // Only supported encodings are UTF-8 (default) and ISO-8859-15

    void setEncoding(string e) { encoding = e; }

    string getEncoding() const { return encoding; }

    void setBitrate(int b) { bitrate = b; }

    int getBitrate() const { return bitrate; }

    void setFormat(string fmt) { format = fmt; }

    string getFormat() const { return format; }

    void setLengthInMS(long ms) { length_in_ms = ms; }

    long getLengthInMS() const { return length_in_ms; }

    void setArtist(string name) { artist = name; }

    string getArtist() const { return artist; }

    void setTrack(string name) { track = name; }

    string getTrack() const { return track; }

    void setAlbum(string name) { album = name; }

    string getAlbum() const { return album; }

    void setTrackNum(int t) { trackNum = t; }

    int getTrackNum() const { return trackNum; }

    void setGenre(string g) { genre = g; }

    string getGenre() const { return genre; }

    void setYear(string y) { year = y; }

    string getYear() const { return year; }

    void setPUID(string id)  { puid = id; }

    string getPUID() const { return puid; }

};

// Get your unique key at http://www.musicdns.org

bool retrieve_metadata(string client_key, string client_verstion,

	TrackInformation *info, bool getMetadata);

class AudioData {

private:

    unsigned char *samples;

    int byteOrder;

    long size;

    int sRate;

    bool stereo;

public:

    TrackInformation info;

    AudioData() : samples(0), size(0), sRate(0), stereo(false) {}

    ~AudioData() {

	delete[] samples;

    }

    // size is number of samples (half the number of bytes)

    void setData(unsigned char*_samples, int _byteOrder, long _size,

	   	 int _sRate, bool _stereo, int _ms, string _fmt) {

	samples = _samples;

	byteOrder = _byteOrder;

	size = _size;

	sRate = _sRate;

	stereo = _stereo;

	// These two fields are used later for the protocol layer

	info.setLengthInMS(_ms);

	info.setFormat(_fmt);

    }

    int getByteOrder() const { return byteOrder; }

    long getSize() const { return size; }

    int getSRate() const { return sRate; }

    bool getStereo() const { return stereo; }

    bool createPrint() {

	const char *print = ofa_create_print(samples, byteOrder, size, sRate, stereo);

	if (!print)

	    return false;

	info.setPrint(print);

	return true;

    }

    // Get your unique key at http://www.musicdns.org

    TrackInformation *getMetadata(string client_key, string client_version, 

	    bool metadataFlag)

    {

	if (!retrieve_metadata(client_key, client_version, &info, metadataFlag))

	    return 0;

	return &info;

    }

};

#endif