Instrument.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 H2C_INSTRUMENT_H
#define H2C_INSTRUMENT_H
 
#include <cassert>
#include <memory>
 
#include <core/Object.h>
#include <core/Basics/Adsr.h>
#include <core/Helpers/Filesystem.h>
#include <core/License.h>
 
#define EMPTY_INSTR_ID          -1
#define METRONOME_INSTR_ID      -2
#define PLAYBACK_INSTR_ID       -3
 
namespace H2Core
{
 
class XMLNode;
class ADSR;
class Drumkit;
class DrumkitComponent;
class InstrumentLayer;
class InstrumentComponent;
 

class Instrument : public H2Core::Object<Instrument>
{
                H2_OBJECT(Instrument)
        public:
                enum SampleSelectionAlgo {
                        VELOCITY,
                        ROUND_ROBIN,
                        RANDOM
                };

                Instrument( const int id=EMPTY_INSTR_ID, const QString& name="Empty Instrument", std::shared_ptr<ADSR> adsr=nullptr );
                Instrument( std::shared_ptr<Instrument> other );
                ~Instrument();

                static std::shared_ptr<Instrument> load_instrument( const QString& drumkit_path, const QString& instrument_name );

                void load_from( const QString& drumkit_path, const QString& instrument_name );

                void load_from( std::shared_ptr<Drumkit> drumkit, std::shared_ptr<Instrument> instrument );

                void load_samples( float fBpm = 120 );
                void unload_samples();

        void save_to( XMLNode* node, int component_id, bool bRecentVersion = true, bool bFull = false );
                static std::shared_ptr<Instrument> load_from( XMLNode* pNode,
                                                                                                          const QString& sDrumkitPath = "",
                                                                                                          const QString& sDrumkitName = "",
                                                                                                          const License& license = License(),
                                                                                                          bool* pLegacyFormatEncountered = nullptr,
                                                                                                          bool bSilent = false );

                void set_name( const QString& name );
                const QString& get_name() const;

                void set_id( const int id );
                int get_id() const;

                void set_adsr( std::shared_ptr<ADSR> adsr );
                std::shared_ptr<ADSR> get_adsr() const;
                std::shared_ptr<ADSR> copy_adsr() const;

                void set_mute_group( int group );
                int get_mute_group() const;

                void set_midi_out_channel( int channel );
                int get_midi_out_channel() const;

                void set_midi_out_note( int note );
                int get_midi_out_note() const;

                void set_muted( bool muted );
                bool is_muted() const;

                void setPan( float val );
                void setPanWithRangeFrom0To1( float fVal ) {
                        this->setPan( -1.f + 2.f * fVal ); // scale and translate into [-1;1]
                };

                float getPan() const;
                float getPanWithRangeFrom0To1() const {
                        return 0.5f * ( 1.f + m_fPan );
                }
 

                void set_gain( float gain );
                float get_gain() const;
                void set_volume( float volume );
                float get_volume() const;

                void set_filter_active( bool active );
                bool is_filter_active() const;

                void set_filter_resonance( float val );
                float get_filter_resonance() const;

                void set_filter_cutoff( float val );
                float get_filter_cutoff() const;

                void set_peak_l( float val );
                float get_peak_l() const;
                void set_peak_r( float val );
                float get_peak_r() const;

                void set_fx_level( float level, int index );
                float get_fx_level( int index ) const;

                void set_random_pitch_factor( float val );
                float get_random_pitch_factor() const;
                
                void set_pitch_offset( float val );
                float get_pitch_offset() const;

                void set_active( bool active );
                bool is_active() const;

                void set_soloed( bool soloed );
                bool is_soloed() const;

                void enqueue();
                void dequeue();
                bool is_queued() const;

                void set_stop_notes( bool stopnotes );
                bool is_stop_notes() const;
 
                void set_sample_selection_alg( SampleSelectionAlgo selected_algo);
                SampleSelectionAlgo sample_selection_alg() const;
 
                void set_hihat_grp( int hihat_grp );
                int get_hihat_grp() const;
 
                void set_lower_cc( int message );
                int get_lower_cc() const;
 
                void set_higher_cc( int message );
                int get_higher_cc() const;

                void set_drumkit_path( const QString& sPath );
                QString get_drumkit_path() const;
                void set_drumkit_name( const QString& sName );
                const QString& get_drumkit_name() const;

                void set_is_preview_instrument(bool isPreview);
                bool is_preview_instrument() const;

                void set_is_metronome_instrument(bool isMetronome);
                bool is_metronome_instrument() const;
 
                std::vector<std::shared_ptr<InstrumentComponent>>* get_components();
                std::shared_ptr<InstrumentComponent> get_component( int DrumkitComponentID );
 
                void set_apply_velocity( bool apply_velocity );
                bool get_apply_velocity() const;
 
                bool is_currently_exported() const;
                void set_currently_exported( bool isCurrentlyExported );
 
                bool has_missing_samples() const { return m_bHasMissingSamples; }
                void set_missing_samples( bool bHasMissingSamples ) { m_bHasMissingSamples = bHasMissingSamples; }

        bool hasSamples() const;

                static constexpr float fPitchMax = 24.5;
                static constexpr float fPitchMin = -24.5;

                QString toQString( const QString& sPrefix = "", bool bShort = true ) const override;
 
        private:
                int                                     __id;
                QString                                 __name;
        QString                                 __drumkit_path;
        QString                                 __drumkit_name;
        float                                   __gain;                                   
                float                                   __volume;                               
                float                                   m_fPan;   
                float                                   __peak_l;                               
                float                                   __peak_r;                               
                std::shared_ptr<ADSR>                                   __adsr;                                   
                bool                                    __filter_active;         
                float                                   __filter_cutoff;         
                float                                   __filter_resonance;           
                float                                   __random_pitch_factor;
                float                                   __pitch_offset;   
                int                                             __midi_out_note;         
                int                                             __midi_out_channel;           
                bool                                    __stop_notes;                       
                SampleSelectionAlgo          __sample_selection_alg;   
                bool                                    __active;                               
                bool                                    __soloed;                               
                bool                                    __muted;                         
                int                                             __mute_group;                       
                int                                             __queued;                               
                float                                   __fx_level[MAX_FX];             
                int                                             __hihat_grp;                 
                int                                             __lower_cc;                           
                int                                             __higher_cc;                 
                bool                                    __is_preview_instrument;         
                bool                                    __is_metronome_instrument;             
                std::vector<std::shared_ptr<InstrumentComponent>>* __components;            
                bool                                    __apply_velocity;                               
                bool                                    __current_instr_for_export;           
                bool                                    m_bHasMissingSamples;       
};
 
// DEFINITIONS
inline void Instrument::set_name( const QString& name )
{
        __name = name;
}

inline const QString& Instrument::get_name() const
{
        return __name;
}

inline void Instrument::set_id( const int id )
{
        __id = id;
}

inline int Instrument::get_id() const
{
        return __id;
}
 
inline std::shared_ptr<ADSR> Instrument::get_adsr() const
{
        return __adsr;
}
 
inline std::shared_ptr<ADSR> Instrument::copy_adsr() const
{
        return std::make_shared<ADSR>( __adsr );
}
 
inline void Instrument::set_mute_group( int group )
{
        __mute_group = ( group<-1 ? -1 : group );
}
 
inline int Instrument::get_mute_group() const
{
        return __mute_group;
}
 
inline int Instrument::get_midi_out_channel() const
{
        return __midi_out_channel;
}
 
inline void Instrument::set_midi_out_channel( int nChannel )
{
        if ( ( nChannel >= MIDI_OUT_CHANNEL_MIN ) &&
                 ( nChannel <= MIDI_OUT_CHANNEL_MAX ) ) {
                __midi_out_channel = nChannel;
        } else {
                ERRORLOG( QString( "midi out channel [%1] out of bounds [%2,%3]" )
                                  .arg( nChannel )
                                  .arg( MIDI_OUT_CHANNEL_MIN )
                                  .arg( MIDI_OUT_CHANNEL_MAX ) );
        }
}
 
inline int Instrument::get_midi_out_note() const
{
        return __midi_out_note;
}
 
inline void Instrument::set_midi_out_note( int note )
{
        if ( ( note >= MIDI_OUT_NOTE_MIN ) && ( note <= MIDI_OUT_NOTE_MAX ) ) {
                __midi_out_note = note;
        } else {
                ERRORLOG( QString( "midi out note %1 out of bounds" ).arg( note ) );
        }
}
 
inline void Instrument::set_muted( bool muted )
{
        __muted = muted;
}
 
inline bool Instrument::is_muted() const
{
        return __muted;
}
 
inline void Instrument::setPan( float val ) //TODO check boundary factorize function?
{
        if ( val > 1.0 ) {
                m_fPan = 1.0;
        } else if ( val < -1.0 ) {
                m_fPan = -1.0;
        } else {
                m_fPan = val;
        }
}
 
inline float Instrument::getPan() const
{
        return m_fPan;
}
 
inline void Instrument::set_gain( float gain )
{
        __gain = gain;
}
 
inline float Instrument::get_gain() const
{
        return __gain;
}
 
inline void Instrument::set_volume( float volume )
{
        __volume = volume;
}
 
inline float Instrument::get_volume() const
{
        return __volume;
}
 
inline void Instrument::set_filter_active( bool active )
{
        __filter_active = active;
}
 
inline bool Instrument::is_filter_active() const
{
        return __filter_active;
}
 
inline void Instrument::set_filter_resonance( float val )
{
        __filter_resonance = val;
}
 
inline float Instrument::get_filter_resonance() const
{
        return __filter_resonance;
}
 
inline void Instrument::set_filter_cutoff( float val )
{
        __filter_cutoff = val;
}
 
inline float Instrument::get_filter_cutoff() const
{
        return __filter_cutoff;
}
 
inline void Instrument::set_peak_l( float val )
{
        __peak_l = val;
}
 
inline float Instrument::get_peak_l() const
{
        return __peak_l;
}
 
inline void Instrument::set_peak_r( float val )
{
        __peak_r = val;
}
 
inline float Instrument::get_peak_r() const
{
        return __peak_r;
}
 
inline void Instrument::set_fx_level( float level, int index )
{
        __fx_level[index] = level;
}
 
inline float Instrument::get_fx_level( int index ) const
{
        return __fx_level[index];
}
 
inline void Instrument::set_random_pitch_factor( float val )
{
        __random_pitch_factor = val;
}
 
inline float Instrument::get_random_pitch_factor() const
{
        return __random_pitch_factor;
}
 
inline float Instrument::get_pitch_offset() const
{
        return __pitch_offset;
}
 
inline void Instrument::set_active( bool active )
{
        __active = active;
}
 
inline bool Instrument::is_active() const
{
        return __active;
}
 
inline void Instrument::set_soloed( bool soloed )
{
        __soloed = soloed;
}
 
inline bool Instrument::is_soloed() const
{
        return __soloed;
}
 
inline void Instrument::enqueue()
{
        __queued++;
}
 
inline void Instrument::dequeue()
{
        assert( __queued > 0 );
        __queued--;
}
 
inline bool Instrument::is_queued() const
{
        return ( __queued > 0 );
}
 
inline void Instrument::set_stop_notes( bool stopnotes )
{
        __stop_notes = stopnotes;
}
 
inline bool Instrument::is_stop_notes() const
{
        return __stop_notes;
}
 
inline void Instrument::set_sample_selection_alg( SampleSelectionAlgo selected_algo)
{
        __sample_selection_alg = selected_algo;
}
 
inline Instrument::SampleSelectionAlgo Instrument::sample_selection_alg() const
{
        return __sample_selection_alg;
}
 
inline void Instrument::set_hihat_grp( int hihat_grp )
{
        __hihat_grp = hihat_grp;
}
 
inline int Instrument::get_hihat_grp() const
{
        return __hihat_grp;
}
 
inline void Instrument::set_lower_cc( int message )
{
        __lower_cc = message;
}
 
inline int Instrument::get_lower_cc() const
{
        return __lower_cc;
}
 
inline void Instrument::set_higher_cc( int message )
{
        __higher_cc = message;
}
 
inline int Instrument::get_higher_cc() const
{
        return __higher_cc;
}
 
inline void Instrument::set_drumkit_path( const QString& sPath )
{
        __drumkit_path = sPath;
}
 
inline void Instrument::set_drumkit_name( const QString& sName )
{
        __drumkit_name = sName;
}
 
inline const QString& Instrument::get_drumkit_name() const
{
        return __drumkit_name;
}
 
inline bool Instrument::is_preview_instrument() const
{
        return __is_preview_instrument;
}
 
inline void Instrument::set_is_preview_instrument(bool isPreview)
{
        __is_preview_instrument = isPreview;
}
 
inline bool Instrument::is_metronome_instrument() const
{
        return __is_metronome_instrument;
}
 
inline void Instrument::set_is_metronome_instrument(bool isMetronome)
{
        __is_metronome_instrument = isMetronome;
}
 
inline std::vector<std::shared_ptr<InstrumentComponent>>* Instrument::get_components()
{
        return __components;
}
 
inline void Instrument::set_apply_velocity( bool apply_velocity )
{
        __apply_velocity = apply_velocity;
}
 
inline bool Instrument::get_apply_velocity() const
{
        return __apply_velocity;
}
 
inline bool Instrument::is_currently_exported() const
{
        return __current_instr_for_export;
}
 
inline void Instrument::set_currently_exported( bool isCurrentlyExported )
{
        __current_instr_for_export = isCurrentlyExported;
}
 
};
 
 
 
#endif // H2C_INSTRUMENT_H
 
/* vim: set softtabstop=4 noexpandtab:  */