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-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 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();
 
                bool                    addRealtimeNote ( int instrument,
                                                          float velocity,
                                                          bool noteoff=false,
                                                          int msg1=0 );
 
                int getHihatOpenness() const;
                void setHihatOpenness( int nValue );
 
                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                    releaseJackTimebaseControl();
        void                    initJackTimebaseControl();
 
        void                    __panic();
        std::shared_ptr<Timeline>       getTimeline() const;
        void                    setTimeline( std::shared_ptr<Timeline> );
        
        //export management
        bool                    getIsExportSessionActive() const;
        bool                    startExportSession( int nSampleRate, int nSampleDepth,
                                                                                double fCompressionLevel = 0.0 );
        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                   getJackTimebaseControllerBpm() 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;

                int m_nHihatOpenness;

        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;
}
inline int Hydrogen::getHihatOpenness() const {
        return m_nHihatOpenness;
}
inline void Hydrogen::setHihatOpenness( int nValue ) {
        m_nHihatOpenness = std::clamp( nValue, 0, 127 );
}
};
 
#endif