soundanalyser.h

/*
 * This file is part of Copiste.
 *
 * Copiste 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 3 of the License, or
 * (at your option) any later version.
 *
 *  Copiste is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Copiste.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef INCLUDED_SOUNDANALYSERH
#define INCLUDED_SOUNDANALYSERH

class SoundAnalyser;

// Libraries
#include <vector>
#include <utility>
#include <string>

// Stream handling
#include "core/streamplayer.h"
#include "features/extractor.h"

// Features
#include "features/spectrum.h"
#include "features/zcr.h"
#include "features/hzcrr.h"
#include "features/ste.h"
#include "features/lster.h"

// Storage
#include "algo/corpus.h"

// Filters
#include "filters/average.h"
#include "filters/flux.h"
#include "filters/range.h"
#include "filters/highlowratio.h"
#include "filters/centroid.h"
#include "filters/memory.h"
#include "filters/compare.h"
#include "filters/mel.h"
#include "filters/distance.h"

using namespace std;


class SoundAnalyser : protected StreamPlayer
{
    public:
        SoundAnalyser(bool live = false);
        ~SoundAnalyser();


        void resetExtractors();
        void cleanExtractors();
        void registerExtractor(string name, FeatureExtractor* extr, bool used = true, bool drawLines = true);
        FeatureExtractor* getExtractor(string name);


        bool setupPipeline(string filename);
        void setNormalization(float min, float max);
        bool compute(string url);
        void waitComputed();


        unsigned int nbFeatures() { return mExtr.size(); }
        unsigned int nbElems(unsigned int n);
        unsigned int nbSamples() { return mFeatures.size(); }
        unsigned int dimension() { return mDimension; }
        unsigned int realDimension() { return mRealDimension; }

        // Features management : data

        double** features(unsigned int n);
        void clearFeatures();
        void cleanOldFeatures(unsigned int newestCount);


        bool isUsed(unsigned int index);
        bool isDrawnWithLines(unsigned int index);
        string name(unsigned int n);
        int getFeatureByName(string name);


        void useBuffer();
        void sequenceEnds();
        virtual void useFeatures() { ; }


        unsigned int samplingFrequency() { return mFrequency; }

    private:
        vector<pair<string, FeatureExtractor* > > mExtr; // TODO : it could be an hashtable
        vector<bool> mUsed;
        vector<bool> mDrawLines;
        vector<double**> mFeatures;

        int mDimension;
        int mRealDimension;
        int mUsedExtractors;

        bool mNormalize;
        float mOverlapping;
        float mMinFeature;
        float mMaxFeature;

        boost::mutex mSwitchLock;
        bool mComputed;
        libvlc_time_t mLastUpdateTime;
};

#endif