LASTAR Code

/**************************************************************************
   Copyright (C) 2020 Arnaud Champenois arthelion@free.fr

    This program 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.

    This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
**************************************************************************/
#ifndef LASTARPROCESSOR_H
#define LASTARPROCESSOR_H

#include<QObject>

#include "processparameters.h"
#include "algo/sound_stat_reference.h"

Q_DECLARE_METATYPE(SoundTools::Status)

class LASTARProcessor : public QObject
{
    Q_OBJECT
public:
    LASTARProcessor();
    virtual ~LASTARProcessor();

    void InitProcessing();
    SoundTools::Status Open(FileNameString inputFileName);
    SoundTools::Status Amplify(FileNameString outputFileName, SoundIDTag defaultTags, bool aJustPlay = false, double startPoint = 0.0);
    void Stop();
    void Close();
    void ResetStats();
    void RecomputeStats();
    void stopPlaying();
    bool StopAndClosePlayer();
    void RestartPlayer();

    bool isOpened();
    bool isClosed();
    bool isPlaying();
    bool HasEqualizer();


    bool getTags(SoundIDTag &aTags);
    double getLength();

    void SetAmpDebugFileName(const QString&value) {
        mAmpDebugFileName = value;
    }

    bool hasStepDetector() const {
        return (mStepDetectorPt!=nullptr);
    }

    void readEQCatalog(QString path);
    QStringList getEQNameList() const {
        return mAutoEqCatalog.getNameList();
    }
    void PrintAutoEqStats();

    void setCurrentParam(ProcessParameters* param) {
        mCurrentParamPt = param;
    }

public slots:
    void LowEq(int aValue);
    void MidEq(int aValue);
    void MidFreq(double aValue);
    void MidWidth(double aValue);
    void HighEq(int aValue);
    void AmpValue(int aValue);


signals:
    void logError(QString);
    void logInfo(QString);
    void logMessage(QString);
    void logWarning(QString);
    void displayStatus(QString);
    void progress(int percent);
    void closed();
    void processingBegins();
    void playerHasStopped();
    void stopRequested();
    void ampliLoaded();

protected:
    void DeleteStats();
    SoundAlgoFilter *BuildAutoEq();
    SoundStatReference GetAutoEqReference();

    SoundTools::Status ComputeStats();
    SoundAlgoFilterBiquad *AddEqualizer(SoundAlgoComposite &aComp);

    void LogError(QString message) {
        emit logError(message);
    }

    void LogWarning(QString message) {
        emit logWarning(message);
    }

    void LogInfo(QString message) {
        emit logInfo(message);
    }

    void LogMessage(QString message) {
        emit logMessage(message);
    }

private slots:
    void notifyBegin(unsigned);
    void notifyInProgress(unsigned,unsigned);
    void notifyEnd(int aStatus, unsigned);
    void playerInProgress(double time);
    void playerBegins();
    void playerHasStopped(bool);

private slots:
    void loadingFinished();

private:
    void connectAlgo(SoundAlgo*algoPt);

    ProcessParameters*mCurrentParamPt;
    int mSegmentNumber;
    SoundReader::Ptr mSoundReaderPt;

    bool mStatsWeighted;
    SoundAlgoStats* mStatsAlgoPt;
    RMSStepDetector* mStepDetectorPt;
    SoundStatFile* mStatFile;
    SoundPlayer* mSoundPlayerPt;

    // For playing
    SoundAlgo*mAlgoPt = nullptr;
    SoundAlgoAmpliInterface*mAmpliPt = nullptr;
    SoundAlgoNoiseGate *mGatePt = nullptr;

    SoundStatReferenceCatalog mAutoEqCatalog;

    int mPassNb;
    int mCurPass;

    QString mAmpDebugFileName;
};

#endif // LASTARPROCESSOR_H