AudioEngine.h

Go to the documentation of this file.

/*
 * Hydrogen
 * Copyright(c) 2002-2008 by Alex >Comix< Cominu [comix@users.sourceforge.net]
 * Copyright(c) 2008-2025 The hydrogen development team [hydrogen-devel@lists.sourceforge.net]
 *
 * http://www.hydrogen-music.org
 *
 * 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 2 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 https://www.gnu.org/licenses
 *
 */
 
#ifndef AUDIO_ENGINE_H
#define AUDIO_ENGINE_H
 
#include <core/AudioEngine/AudioEngineTests.h>
 
#include <core/config.h>
#include <core/Object.h>
#include <core/Hydrogen.h>
#include <core/Sampler/Sampler.h>
#include <core/Synth/Synth.h>
#include <core/Basics/Note.h>
#include <core/CoreActionController.h>
#include <core/Preferences/Preferences.h>
 
#include <core/IO/AudioOutput.h>
#include <core/IO/JackAudioDriver.h>
#include <core/IO/DiskWriterDriver.h>
#include <core/IO/FakeDriver.h>
 
#include <memory>
#include <string>
#include <cassert>
#include <mutex>
#include <thread>
#include <chrono>
#include <deque>
#include <queue>
#include <QString>

#ifndef RIGHT_HERE
#define RIGHT_HERE __FILE__, __LINE__, __PRETTY_FUNCTION__
#endif
 
typedef int  ( *audioProcessCallback )( uint32_t, void * );
 
namespace H2Core
{
        class MidiOutput;
        class MidiInput;
        class EventQueue;
        class PatternList;
        class Drumkit;
        class Song;
        class TransportPosition;
         
class AudioEngine : public H2Core::Object<AudioEngine>
{
        H2_OBJECT(AudioEngine)
public:
 
        enum class State {
                Uninitialized =    1,
                Initialized = 2,
                Prepared = 3,
                Ready = 4,
                Playing = 5,
                Testing = 6
        };
                static QString StateToQString( const State& state );

        static constexpr float fHumanizeVelocitySD = 0.2;
        static constexpr float fHumanizePitchSD = 0.4;
        static constexpr float fHumanizeTimingSD = 0.3;
        static constexpr int nMaxTimeHumanize = 2000;
 
        AudioEngine();
 
        ~AudioEngine();

        void                    lock( const char* file, unsigned int line, const char* function );

        bool                    tryLock( const char* file, 
                                                   unsigned int line, 
                                                   const char* function );

        bool                    tryLockFor( std::chrono::microseconds duration, 
                                                                  const char* file, 
                                                                  unsigned int line, 
                                                                  const char* function );

        void                    unlock();

        void                    assertLocked( const QString& sClass, const char* sFunction,
                                                                  const QString& sMsg );
        void                    noteOn( Note *note );

        static int                      audioEngine_process( uint32_t nframes, void *arg );

        static float    computeTickSize( const int nSampleRate, const float fBpm, const int nResolution);
        static double computeDoubleTickSize(const int nSampleRate, const float fBpm, const int nResolution);
 
        Sampler*         getSampler() const;
        Synth*                     getSynth() const;

        float                   getElapsedTime() const;   

        void                    startAudioDrivers();
        void                    stopAudioDrivers();
        AudioOutput* getAudioDriver() const;
        AudioOutput* createAudioDriver( const Preferences::AudioDriver& driver );
                                        
        void                    restartAudioDrivers();
                                        
        void                    setupLadspaFX();
        
        void                    renameJackPorts(std::shared_ptr<Song> pSong);
 
        MidiInput*             getMidiDriver() const;
        MidiOutput*           getMidiOutDriver() const;
        
        std::shared_ptr<Instrument> getMetronomeInstrument() const;
                
        
        void raiseError( unsigned nErrorCode );
        
        State                      getState() const;
 
        void                    setMasterPeak_L( float value );
        float                   getMasterPeak_L() const;
 
        void                    setMasterPeak_R( float value );
        float                   getMasterPeak_R() const;
 
        float                   getProcessTime() const;
        float                   getMaxProcessTime() const;
 
        const std::shared_ptr<TransportPosition> getTransportPosition() const;
 
        const PatternList*   getNextPatterns() const;
        const PatternList*   getPlayingPatterns() const;
        
        long long               getRealtimeFrame() const;

        static double   getLeadLagInTicks();
        
        long long               getLeadLagInFrames( double fTick );
 
        double getSongSizeInTicks() const;

        void play();
        void stop();

        void setNextBpm( float fNextBpm );
        float getNextBpm() const;
 
        static float    getBpmAtColumn( int nColumn );

        void updateSongSize();
 
        void removePlayingPattern( Pattern* pPattern );
        void updatePlayingPatterns();
        void clearNextPatterns();
        void toggleNextPattern( int nPatternNumber );
        void flushAndAddNextPattern( int nPatternNumber );
 
        void updateVirtualPatterns();

        int getEnqueuedNotesNumber() const;
 
        bool                    isEndOfSongReached( std::shared_ptr<TransportPosition> pPos ) const;
 
                void makeTrackPorts( std::shared_ptr<Song> pSong );

        QString toQString( const QString& sPrefix = "", bool bShort = true ) const override;

        friend void Hydrogen::setSong( std::shared_ptr<Song> pSong, bool bRelinking );
        friend void Hydrogen::removeSong();
        friend void Hydrogen::updateSelectedPattern( bool );
        friend void Hydrogen::setIsTimelineActivated( bool );
        friend bool CoreActionController::addTempoMarker( int, float );
        friend bool CoreActionController::deleteTempoMarker( int );
        friend bool CoreActionController::locateToTick( long nTick, bool );
        friend bool CoreActionController::activateSongMode( bool );
        friend bool CoreActionController::activateLoopMode( bool );
        friend int FakeDriver::connect();
 
        friend class AudioEngineTests;
                friend class JackAudioDriver;
private:

        void handleSelectedPattern();
        
        inline void                     processPlayNotes( unsigned long nframes );
 
        void reset(  bool bWithJackBroadcast = true );
 
        void resetOffsets();

        double coarseGrainTick( double fTick );
 
        void                    clearNoteQueues();
        void                    clearAudioBuffers( uint32_t nFrames );
        void                    updateNoteQueue( unsigned nIntervalLengthInFrames );
        void                    processAudio( uint32_t nFrames );
        long long               computeTickInterval( double* fTickStart, double* fTickEnd, unsigned nIntervalLengthInFrames );
        void                    updateBpmAndTickSize( std::shared_ptr<TransportPosition> pTransportPosition );
        void                    calculateTransportOffsetOnBpmChange( std::shared_ptr<TransportPosition> pTransportPosition );
    
        void                    setRealtimeFrame( long long nFrame );
        void updatePlayingPatternsPos( std::shared_ptr<TransportPosition> pPos );
        
        void                    setSong( std::shared_ptr<Song>pNewSong );
        void                    removeSong();
        void                    setState( State state );
        void                    setNextState( State state );
        State                      getNextState() const;
 
        void                            startPlayback();
        
        void                    stopPlayback();
        
        void                    locate( const double fTick, bool bWithJackBroadcast = true );
        void                    locateToFrame( const long long nFrame );
        void                    incrementTransportPosition( uint32_t nFrames );
        void                    updateTransportPosition( double fTick, long long nFrame,
                                                                                         std::shared_ptr<TransportPosition> pPos );
        void                    updateSongTransportPosition( double fTick, long long nFrame,
                                                                                                 std::shared_ptr<TransportPosition> pPos );
        void                    updatePatternTransportPosition( double fTick, long long nFrame,
                                                                                                        std::shared_ptr<TransportPosition> pPos );

        void handleTempoChange();

        void handleTimelineChange();
        
        void handleSongSizeChange();

        void handleDriverChange();

        void handleLoopModeChanged();

        void handleSongModeChanged();
 
        QString getDriverNames() const;
 
        Sampler*                         m_pSampler;
        Synth*                             m_pSynth;
        AudioOutput *                m_pAudioDriver;
        MidiInput *                    m_pMidiDriver;
        MidiOutput *          m_pMidiDriverOut;
        EventQueue*           m_pEventQueue;
 
        #if defined(H2CORE_HAVE_LADSPA) || _DOXYGEN_
        float                           m_fFXPeak_L[MAX_FX];
        float                           m_fFXPeak_R[MAX_FX];
        #endif
 
        //Master peak (left channel)
        float                           m_fMasterPeak_L;
 
        //Master peak (right channel)
        float                           m_fMasterPeak_R;

        std::timed_mutex        m_EngineMutex;
        
        QMutex                          m_MutexOutputPointer;

        std::thread::id         m_LockingThread;
 
        struct _locker_struct {
                const char* file;
                unsigned int line;
                const char* function;
        } m_pLocker;
 
        float                           m_fProcessTime;
        float                           m_fMaxProcessTime;
        float                           m_fLadspaTime;
 
        std::shared_ptr<TransportPosition> m_pTransportPosition;
        std::shared_ptr<TransportPosition> m_pQueuingPosition;

        double                          m_fSongSizeInTicks;

        long long               m_nRealtimeFrame;
     
        State                              m_state;
        State                              m_nextState;
        
        audioProcessCallback m_AudioProcessCallback;
        
        // overload the > operator of Note objects for priority_queue
        struct compare_pNotes {
                bool operator() (Note* pNote1, Note* pNote2);
        };
 
        std::priority_queue<Note*, std::deque<Note*>, compare_pNotes > m_songNoteQueue;
        std::deque<Note*>       m_midiNoteQueue; 
        
        std::shared_ptr<Instrument>             m_pMetronomeInstrument;
 
        float                   m_fNextBpm;
        double m_fLastTickEnd;
        bool m_bLookaheadApplied;

        int m_nLoopsDone;
};
 
#ifdef H2CORE_HAVE_DEBUG
  #define ASSERT_AUDIO_ENGINE_LOCKED(x) assertAudioEngineLocked( _class_name(), __FUNCTION__, QString( "%1" ).arg( x ) );
#else
  #define ASSERT_AUDIO_ENGINE_LOCKED(x)
#endif

class AudioEngineLocking {
 
        bool m_bNeedsLock;
 
protected:
        void assertAudioEngineLocked( const QString& sClass,
                                                                  const char* sFunction,
                                                                  const QString& sMsg ) const;
 
 
public:

        void setNeedsLock( bool bNeedsLock ) {
                m_bNeedsLock = bNeedsLock;
        }
 
        AudioEngineLocking() {
                m_bNeedsLock = false;
        }
};
 
inline void     AudioEngine::setMasterPeak_L( float value ) {
        m_fMasterPeak_L = value;
}
 
inline float AudioEngine::getMasterPeak_L() const {
        return m_fMasterPeak_L;
}
 
inline void     AudioEngine::setMasterPeak_R( float value ) {
        m_fMasterPeak_R = value;
}
 
inline float AudioEngine::getMasterPeak_R() const {
        return m_fMasterPeak_R;
}
 
inline float AudioEngine::getProcessTime() const {
        return m_fProcessTime;
}
 
inline float AudioEngine::getMaxProcessTime() const {
        return m_fMaxProcessTime;
}
 
inline AudioEngine::State AudioEngine::getState() const {
        return m_state;
}
 
inline AudioEngine::State AudioEngine::getNextState() const {
        return m_nextState;
}
inline void AudioEngine::setNextState( AudioEngine::State state) {
        m_nextState = state;
}
 
inline AudioOutput*  AudioEngine::getAudioDriver() const {
        return m_pAudioDriver;
}
 
inline  MidiInput*     AudioEngine::getMidiDriver() const {
        return m_pMidiDriver;
}
 
inline MidiOutput*    AudioEngine::getMidiOutDriver() const {
        return m_pMidiDriverOut;
}
 
inline long long AudioEngine::getRealtimeFrame() const {
        return m_nRealtimeFrame;
}
 
inline void AudioEngine::setRealtimeFrame( long long nFrame ) {
        m_nRealtimeFrame = nFrame;
}
 
inline float AudioEngine::getNextBpm() const {
        return m_fNextBpm;
}
inline const std::shared_ptr<TransportPosition> AudioEngine::getTransportPosition() const {
        return m_pTransportPosition;
}
inline double AudioEngine::getSongSizeInTicks() const {
        return m_fSongSizeInTicks;
}
inline std::shared_ptr<Instrument> AudioEngine::getMetronomeInstrument() const {
        return m_pMetronomeInstrument;
}
inline int AudioEngine::getEnqueuedNotesNumber() const {
        return m_songNoteQueue.size();
}
};
 
#endif