Hydrogen.h

Go to the documentation of this file.

/*
 * Hydrogen
 * Copyright(c) 2002-2008 by Alex >Comix< Cominu [comix@users.sourceforge.net]
 * Copyright(c) 2008-2024 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 HYDROGEN_H
#define HYDROGEN_H
 
#include <core/config.h>
#include <core/Basics/Drumkit.h>
#include <core/Basics/Song.h>
#include <core/Basics/Sample.h>
#include <core/Object.h>
#include <core/Timeline.h>
#include <core/IO/AudioOutput.h>
#include <core/IO/MidiCommon.h>
#include <core/IO/MidiInput.h>
#include <core/IO/MidiOutput.h>
#include <core/IO/JackAudioDriver.h>
#include <core/CoreActionController.h>
#include <core/Timehelper.h>
 
#include <stdint.h> // for uint32_t et al
#include <cassert>
#include <memory>
 
namespace H2Core
{
        class CoreActionController;
        class AudioEngine;
        class SoundLibraryDatabase;
 
 
class Hydrogen : public H2Core::Object<Hydrogen>
{
        H2_OBJECT(Hydrogen)
public:
        
        enum class Tempo {
                Song = 0,
                Timeline = 1,
                Jack = 2
        };
        static void             create_instance();
        static Hydrogen*        get_instance(){ return __instance; };
 
        ~Hydrogen();
 
        /*
         * return central instance of the audio engine
         */
        AudioEngine*            getAudioEngine() const;
        SoundLibraryDatabase* getSoundLibraryDatabase() const {
                return m_pSoundLibraryDatabase;
        }
 
// ***** SEQUENCER ********
        void                    sequencer_play();
 
        void                    sequencer_stop();
 
        void                    midi_noteOn( Note *note );
 
        MidiMessage::Event      getLastMidiEvent() const;
        void                            setLastMidiEvent( MidiMessage::Event event );
        int                                     getLastMidiEventParameter() const;
        void                            setLastMidiEventParameter( int nParam );
 
        void                    toggleNextPattern( int nPatternNumber );
        bool                    flushAndAddNextPattern( int nPatternNumber );
        
                std::shared_ptr<Song>                   getSong() const{ return __song; }
                void                    setSong ( std::shared_ptr<Song> newSong, bool bRelinking = true );
 
        int                     getColumnForTick( long nTick, bool bLoopMode, long* pPatternStartTick ) const;
        long                    getTickForColumn( int nColumn ) const;
 
        Song::Mode getMode() const;
        void setMode( Song::Mode mode );
        
        Song::ActionMode getActionMode() const;
        void setActionMode( Song::ActionMode mode );
 
        Song::PatternMode getPatternMode() const;
        void setPatternMode( Song::PatternMode mode );
 
        void setIsTimelineActivated( bool bEnabled );
 
        void                    removeSong();
 
        void updateSongSize();
 
                void                    addRealtimeNote ( int instrument,
                                                          float velocity,
                                                          float fPan = 0.0f,
                                                          bool noteoff=false,
                                                          int msg1=0 );
 
                void                    restartDrivers();
 
                AudioOutput*            getAudioOutput() const;
                MidiInput*              getMidiInput() const;
                MidiOutput*             getMidiOutput() const;
 
                bool                    instrumentHasNotes( std::shared_ptr<Instrument> pInst );
 
                void                    removeInstrument( int nInstrumentNumber );
 
                QString getLastLoadedDrumkitName() const;
                QString getLastLoadedDrumkitPath() const;
 
                void                    raiseError( unsigned nErrorCode );
 
 
void                    previewSample( Sample *pSample );
        void                    previewInstrument( std::shared_ptr<Instrument> pInstr );
 
        void recalculateRubberband( float fBpm );
        void setIsModified( bool bIsModified );
        bool getIsModified() const;
 
        enum ErrorMessages {
                UNKNOWN_DRIVER,
                ERROR_STARTING_DRIVER,
                JACK_SERVER_SHUTDOWN,
                JACK_CANNOT_ACTIVATE_CLIENT,
                JACK_CANNOT_CONNECT_OUTPUT_PORT,
                JACK_CANNOT_CLOSE_CLIENT,
                JACK_ERROR_IN_PORT_REGISTER,
                OSC_CANNOT_CONNECT_TO_PORT,
                PLAYBACK_TRACK_INVALID
        };
 
        void                    onTapTempoAccelEvent();
        void                    setTapTempo( float fInterval );
 
        void                    restartLadspaFX();
        int                             getSelectedPatternNumber() const;
        void                    setSelectedPatternNumber( int nPat,
                                                                                          bool bNeedsLock = true,
                                                                                          bool bForce = false );
 
        void updateSelectedPattern( bool bNeedsLock = true );
 
        int                             getSelectedInstrumentNumber() const;
        void                    setSelectedInstrumentNumber( int nInstrument, bool bTriggerEvent = true );
        std::shared_ptr<Instrument>             getSelectedInstrument() const;
 
        void                    renameJackPorts(std::shared_ptr<Song> pSong);
 
        void                    toggleOscServer( bool bEnable );
        void                    recreateOscServer();
        void                    startNsmClient();
 
        // beatconter
        void                    setbeatsToCount( int beatstocount);
        int                     getbeatsToCount();
        void                    setNoteLength( float notelength);
        float                   getNoteLength();
        int                     getBcStatus();
        bool                    handleBeatCounter();
        void                    setBcOffsetAdjust();
 
        void                    offJackMaster();
        void                    onJackMaster();
 
        void                    __panic();
        std::shared_ptr<Timeline>       getTimeline() const;
        void                    setTimeline( std::shared_ptr<Timeline> );
        
        //export management
        bool                    getIsExportSessionActive() const;
        bool                    startExportSession( int rate, int depth );
        void                    stopExportSession();
        void                    startExportSong( const QString& filename );
        void                    stopExportSong();
        
        CoreActionController*   getCoreActionController() const;
 
        /************************************************************/
        /********************** Playback track **********************/
        void                    mutePlaybackTrack( const bool bMuted );
        Song::PlaybackTrack             getPlaybackTrackState() const;
        void                    loadPlaybackTrack( QString sFilename );
        /************************************************************/
 
        enum class              GUIState {
                notReady = -1,
                unavailable = 0,
                ready = 1
        };
        
        GUIState                getGUIState() const;
        void                    setGUIState( const GUIState state );
        bool                    hasJackAudioDriver() const;
        bool                    hasJackTransport() const;
        float                   getMasterBpm() const;
 
        bool isTimelineEnabled() const;
 
        bool isPatternEditorLocked() const;
        void setIsPatternEditorLocked( bool bValue );
 
        Tempo getTempoSource() const;
        
        JackAudioDriver::Timebase               getJackTimebaseState() const;
        bool                    isUnderSessionManagement() const;
 
        void                    setSessionDrumkitNeedsRelinking( bool bNeedsRelinking );
        bool                    getSessionDrumkitNeedsRelinking() const;
        void                    setSessionIsExported( bool bIsExported );
        bool                    getSessionIsExported() const;
 
        int                     m_nInstrumentLookupTable[MAX_INSTRUMENTS];
 
        void addInstrumentToDeathRow( std::shared_ptr<Instrument> pInstr );
 
        void updateVirtualPatterns();
        
        QString toQString( const QString& sPrefix = "", bool bShort = true ) const override;
 
private:
        static Hydrogen*        __instance;
 
        std::shared_ptr<Song>                   __song;
 
        void initBeatcounter();
 
        // beatcounter
        float                   m_ntaktoMeterCompute;   
        int                     m_nbeatsToCount;        
        int                     m_nEventCount;          
        int                     m_nTempoChangeCounter;  
        int                     m_nBeatCount;           
        double                  m_nBeatDiffs[16];       
        timeval                 m_CurrentTime;          
        int                     m_nCoutOffset;          
        int                     m_nStartOffset;         
        // ~ beatcounter
 
 
        // used for song export
        Song::Mode              m_oldEngineMode;
        bool                    m_bOldLoopEnabled;
        bool                    m_bExportSessionIsActive;
        
        GUIState                m_GUIState;
        
        std::shared_ptr<Timeline>       m_pTimeline;
        CoreActionController*   m_pCoreActionController;
        
        std::list<std::shared_ptr<Instrument>>  __instrument_death_row; 
        
        int                             m_nSelectedInstrumentNumber;
        int                             m_nSelectedPatternNumber;
 
        bool                    m_bSessionDrumkitNeedsRelinking;
        bool                    m_bSessionIsExported;
 
        int                             m_nLastRecordedMIDINoteTick;
        AudioEngine*    m_pAudioEngine;
 
        SoundLibraryDatabase* m_pSoundLibraryDatabase;
 
        Hydrogen();
 
        void __kill_instruments();
 
        MidiMessage::Event m_lastMidiEvent;
        int                                     m_nLastMidiEventParameter;
 
};
 
 
/*
 * inline methods
 */
inline std::shared_ptr<Timeline> Hydrogen::getTimeline() const
{
        return m_pTimeline;
}
inline void Hydrogen::setTimeline( std::shared_ptr<Timeline> pTimeline )
{
        m_pTimeline = pTimeline;
}
 
inline CoreActionController* Hydrogen::getCoreActionController() const
{
        return m_pCoreActionController;
}
 
inline bool Hydrogen::getIsExportSessionActive() const
{
        return m_bExportSessionIsActive;
}
 
inline AudioEngine* Hydrogen::getAudioEngine() const {
        return m_pAudioEngine;
}
 
inline Hydrogen::GUIState Hydrogen::getGUIState() const {
        return m_GUIState;
}
 
inline void Hydrogen::setGUIState( const Hydrogen::GUIState state ) {
        m_GUIState = state;
}
inline int Hydrogen::getSelectedPatternNumber() const
{
        return m_nSelectedPatternNumber;
}
inline int Hydrogen::getSelectedInstrumentNumber() const
{
        return m_nSelectedInstrumentNumber;
}
 
inline void Hydrogen::setSessionDrumkitNeedsRelinking( bool bNeedsRelinking ) {
        m_bSessionDrumkitNeedsRelinking = bNeedsRelinking;
}
inline bool Hydrogen::getSessionDrumkitNeedsRelinking() const {
        return m_bSessionDrumkitNeedsRelinking;
}
inline void Hydrogen::setSessionIsExported( bool bSessionIsExported ) {
        m_bSessionIsExported = bSessionIsExported;
}
inline bool Hydrogen::getSessionIsExported() const {
        return m_bSessionIsExported;
}
inline MidiMessage::Event Hydrogen::getLastMidiEvent() const {
        return m_lastMidiEvent;
}
inline void Hydrogen::setLastMidiEvent( MidiMessage::Event event ) {
        m_lastMidiEvent = event;
}
inline int Hydrogen::getLastMidiEventParameter() const {
        return m_nLastMidiEventParameter;
}
inline void     Hydrogen::setLastMidiEventParameter( int nParam ) {
        m_nLastMidiEventParameter = nParam;
}
};
 
#endif