Config.h

Go to the documentation of this file.

/*
        This file is part of ALIZE which is an open-source tool for 
        speaker recognition.

    ALIZE is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as 
    published by the Free Software Foundation, either version 3 of 
    the License, or any later version.

    ALIZE 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 Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public 
    License along with ALIZE.
    If not, see <http://www.gnu.org/licenses/>.
        
        ALIZE is a development project initiated by the ELISA consortium
        [alize.univ-avignon.fr/] and funded by the French Research 
        Ministry in the framework of the TECHNOLANGUE program 
        [www.technolangue.net]

        The ALIZE project team wants to highlight the limits of voice
        authentication in a forensic context.
        The "Person  Authentification by Voice: A Need of Caution" paper 
        proposes a good overview of this point (cf. "Person  
        Authentification by Voice: A Need of Caution", Bonastre J.F., 
        Bimbot F., Boe L.J., Campbell J.P., Douglas D.A., Magrin-
        chagnolleau I., Eurospeech 2003, Genova].
        The conclusion of the paper of the paper is proposed bellow:
        [Currently, it is not possible to completely determine whether the 
        similarity between two recordings is due to the speaker or to other 
        factors, especially when: (a) the speaker does not cooperate, (b) there 
        is no control over recording equipment, (c) recording conditions are not 
        known, (d) one does not know whether the voice was disguised and, to a 
        lesser extent, (e) the linguistic content of the message is not 
        controlled. Caution and judgment must be exercised when applying speaker 
        recognition techniques, whether human or automatic, to account for these 
        uncontrolled factors. Under more constrained or calibrated situations, 
        or as an aid for investigative purposes, judicious application of these 
        techniques may be suitable, provided they are not considered as infallible.
        At the present time, there is no scientific process that enables one to 
        uniquely characterize a person=92s voice or to identify with absolute 
        certainty an individual from his or her voice.]
        Contact Jean-Francois Bonastre for more information about the licence or
        the use of ALIZE

        Copyright (C) 2003-2010
        Laboratoire d'informatique d'Avignon [lia.univ-avignon.fr]
        ALIZE admin [alize@univ-avignon.fr]
        Jean-Francois Bonastre [jean-francois.bonastre@univ-avignon.fr]
*/

#if !defined(ALIZE_Config_h)
#define ALIZE_Config_h

#if defined(_WIN32)
#if defined(ALIZE_EXPORTS)
#define ALIZE_API __declspec(dllexport)
#else
#define ALIZE_API __declspec(dllimport)
#endif
#else
#define ALIZE_API
#endif

#include "Object.h"
#include "FeatureFlags.h"
#include "XList.h"

namespace alize
{
  class ALIZE_API Config : public Object
  {
    friend class TestConfig;

  public :

    Config();

    explicit Config(const FileName& f);

    Config(const Config&);
    const Config& operator=(const Config& c);
    bool operator==(const Config& c) const;
    bool operator!=(const Config& c) const;
    virtual ~Config();
    
    void save(const FileName& f) const;

    void load(const FileName& f);

    void reset();

    unsigned long getParamCount() const;

    const String& getParamName(unsigned long) const;

    const String& getParamContent(unsigned long) const;

    void setParam(const String& name, const String& content);

    void setParam(const Config& c);

    const String& getParam(const String& name) const;

    long getIntegerParam(const String& name) const;

    double getFloatParam(const String& name) const;

    bool getBooleanParam(const String& name) const;

    bool existsParam(const String& name) const;

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

    real_t getParam_minCov() const;

    unsigned long getParam_vectSize() const;

    bool getParam_computeLLKWithTopDistribs() const;

    bool getParam_debug() const;

    unsigned long getParam_topDistribsCount() const;

    unsigned long getParam_mixtureDistribCount() const;

    lk_t getParam_minLLK() const;

    lk_t getParam_maxLLK() const;

    DistribType getParam_distribType() const;

    MixtureFileWriterFormat getParam_saveMixtureFileFormat() const;

    MixtureServerFileWriterFormat getParam_saveMixtureServerFileFormat() const;

    SegServerFileWriterFormat getParam_saveSegServerFileFormat() const;


    //------------------------------------------------------------------
    // Features
    //------------------------------------------------------------------


    const FeatureFlags& getParam_featureFlags() const;
    
    const String& getParam_featureServerBufferSize() const;
    
    const String& getParam_featureServerMask() const;

    const String& getParam_featureFilesPath() const;

    const String& getParam_audioFilesPath() const;

    unsigned long getParam_loadFeatureFileMemAlloc() const;

    unsigned long getParam_featureServerMemAlloc() const;

    FeatureFileReaderFormat getParam_loadFeatureFileFormat() const;

    unsigned long getParam_loadFeatureFileVectSize() const;

    unsigned long getParam_loadAudioFileChannel() const;

    const String& getParam_loadFeatureFileExtension() const;

    const String& getParam_loadAudioFileExtension() const;

    bool getParam_loadFeatureFileBigEndian() const;

    bool getParam_loadAudioFileBigEndian() const;

    const String& getParam_featureServerMode() const;

    bool getParam_loadMixtureFileBigEndian() const;

    FeatureFileWriterFormat getParam_saveFeatureFileFormat() const;

    const String& getParam_saveFeatureFileExtension() const;

    SPRO3DataKind getParam_saveFeatureFileSPro3DataKind() const;

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


    MixtureFileReaderFormat getParam_loadMixtureFileFormat() const;

    SegServerFileReaderFormat getParam_loadSegServerFileFormat() const;

    const String& getParam_loadMixtureFileExtension() const;

    const String& getParam_loadSegServerFileExtension() const;

    const String& getParam_saveMixtureFileExtension() const;

    const String& getParam_saveMixtureServerFileExtension() const;

    const String& getParam_saveSegServerFileExtension() const;

    const String& getParam_mixtureFilesPath() const;

    const String& getParam_segServerFilesPath() const;

    bool getParam_bigEndian() const;

    real_t getParam_sampleRate() const;

    virtual String getClassName() const;
    virtual String toString() const;

    bool  existsParam_minCov;
    bool  existsParam_vectSize;
    bool  existsParam_loadFeatureFileMemAlloc;
    bool  existsParam_featureServerMemAlloc;
    bool  existsParam_computeLLKWithTopDistribs;
    bool  existsParam_debug;
    bool  existsParam_topDistribsCount;
    bool  existsParam_featureServerBufferSize;
    bool  existsParam_featureServerMask;
    bool  existsParam_featureFlags;
    bool  existsParam_mixtureDistribCount;
    bool  existsParam_minLLK;
    bool  existsParam_maxLLK;
    bool  existsParam_distribType;

    bool  existsParam_saveMixtureFileFormat;
    bool  existsParam_saveMixtureServerFileFormat;
    bool  existsParam_saveSegServerFileFormat;
    bool  existsParam_saveFeatureFileFormat;
    bool  existsParam_saveFeatureFileSPro3DataKind;
    bool  existsParam_loadFeatureFileFormat;
    bool  existsParam_loadFeatureFileVectSize;
    bool  existsParam_loadAudioFileChannel;
    bool  existsParam_loadMixtureFileFormat;
    bool  existsParam_loadSegServerFileFormat;
    bool  existsParam_saveMixtureFileExtension;
    bool  existsParam_saveMixtureServerFileExtension;
    bool  existsParam_saveSegServerFileExtension;
    bool  existsParam_saveFeatureFileExtension;
    bool  existsParam_loadFeatureFileExtension;
    bool  existsParam_loadAudioFileExtension;
    bool  existsParam_loadFeatureFileBigEndian;
    bool  existsParam_loadAudioFileBigEndian;
    bool  existsParam_featureServerMode;
    bool  existsParam_loadMixtureFileBigEndian;
    bool  existsParam_loadMixtureFileExtension;
    bool  existsParam_loadSegServerFileExtension;
    bool  existsParam_bigEndian;
    bool  existsParam_sampleRate;
    bool  existsParam_featureFilesPath;
    bool  existsParam_audioFilesPath;
    bool  existsParam_segServerFilesPath;
    bool  existsParam_mixtureFilesPath;

  private :
    real_t              _param_minCov;
    unsigned long       _param_vectSize;
    unsigned long       _param_loadFeatureFileMemAlloc;
    unsigned long       _param_featureServerMemAlloc;
    bool                _param_computeLLKWithTopDistribs;
    bool                _param_debug;
    unsigned long       _param_topDistribsCount;
    String              _param_featureServerBufferSize; // can be a number
                               // or "ALL_FEATURES"
    String              _param_featureServerMask;
    FeatureFlags        _param_featureFlags;
    unsigned long       _param_mixtureDistribCount;
    MixtureFileWriterFormat _param_saveMixtureFileFormat;
    MixtureServerFileWriterFormat _param_saveMixtureServerFileFormat;
    SegServerFileWriterFormat _param_saveSegServerFileFormat;
    String              _param_saveMixtureFileExtension;
    String              _param_saveMixtureServerFileExtension;
    String              _param_saveSegServerFileExtension;
    MixtureFileReaderFormat _param_loadMixtureFileFormat;
    SegServerFileReaderFormat _param_loadSegServerFileFormat;
    String              _param_loadMixtureFileExtension;
    String              _param_loadSegServerFileExtension;
    String              _param_mixtureFilesPath;
    FeatureFileWriterFormat _param_saveFeatureFileFormat;
    SPRO3DataKind       _param_saveFeatureFileSPro3DataKind;
    String              _param_saveFeatureFileExtension;
    FeatureFileReaderFormat _param_loadFeatureFileFormat;
    unsigned long _param_loadFeatureFileVectSize;
    unsigned long _param_loadAudioFileChannel;
    String              _param_loadFeatureFileExtension;
    String              _param_loadAudioFileExtension;
    bool                _param_loadFeatureFileBigEndian;
    bool                _param_loadAudioFileBigEndian;
    String              _param_featureServerMode;
    bool                _param_loadMixtureFileBigEndian;
    String              _param_featureFilesPath;
    String              _param_audioFilesPath;
    String              _param_segServerFilesPath;
    lk_t         _param_minLLK;
    lk_t         _param_maxLLK;
    DistribType  _param_distribType;
    bool         _param_bigEndian;
    real_t       _param_sampleRate;

    XList        _set;

    void assign(const Config&);
    void err(const String&) const;
  };

} // end namespace alize

#endif // !defined(ALIZE_Config_h)