Note.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 H2C_NOTE_H
#define H2C_NOTE_H
 
#include <memory>
 
#include <core/Object.h>
#include <core/Basics/Instrument.h>
#include <core/Basics/Sample.h>
 
#define KEY_MIN                 0
#define KEY_MAX                 11
#define OCTAVE_MIN              -3
#define OCTAVE_MAX              3
#define OCTAVE_OFFSET           3
#define OCTAVE_DEFAULT          0
#define KEYS_PER_OCTAVE         12
 
#define MIDI_MIDDLE_C           60
#define MIDI_FACTOR             127
 
#define VELOCITY_MIN            0.0f
#define VELOCITY_MAX            1.0f
#define PAN_MIN                 0.0f
#define PAN_MAX                 0.5f
#define LEAD_LAG_MIN            -1.0f
#define LEAD_LAG_MAX            1.0f
 
/* Should equal (default __octave + OCTAVE_OFFSET) * KEYS_PER_OCTAVE + default __key */
#define MIDI_DEFAULT_OFFSET     36
 
namespace H2Core
{
 
class XMLNode;
class ADSR;
class Instrument;
class InstrumentList;
 
struct SelectedLayerInfo {
        int nSelectedLayer;
 
        float fSamplePosition;
 
        int nNoteLength;
};
 
class Note : public H2Core::Object<Note>
{
                H2_OBJECT(Note)
        public:
                enum Key { C=KEY_MIN, Cs, D, Ef, E, F, Fs, G, Af, A, Bf, B };
        static QString KeyToQString( Key key );
        
                enum Octave { P8Z=-3, P8Y=-2, P8X=-1, P8=OCTAVE_DEFAULT, P8A=1, P8B=2, P8C=3 };
 
        Note( std::shared_ptr<Instrument> pInstrument, int nPosition = 0, float fVelocity = 0.8, float fPan = 0.0, int nLength = -1, float fPitch = 0.0 );
 
                Note( Note* pOther, std::shared_ptr<Instrument> pInstrument = nullptr );
                ~Note();
 
                /*
                 * save the note within the given XMLNode
                 * \param node the XMLNode to feed
                 */
                void save_to( XMLNode* node );
        static Note* load_from( XMLNode* node, std::shared_ptr<InstrumentList> instruments, bool bSilent = false );
 
                void map_instrument( std::shared_ptr<InstrumentList> instruments );
                std::shared_ptr<Instrument> get_instrument();
                bool has_instrument() const;
                void set_instrument_id( int value );
                int get_instrument_id() const;
                void set_specific_compo_id( int value );
                int get_specific_compo_id() const;
                void set_position( int value );
                int get_position() const;
                void set_velocity( float value );
                float get_velocity() 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_lead_lag( float value );
                float get_lead_lag() const;
                void set_length( int value );
                int get_length() const;
                void set_pitch( float value );
                float get_pitch() const;
                void set_note_off( bool value );
                bool get_note_off() const;
                int get_midi_msg() const;
                void set_pattern_idx( int value );
                int get_pattern_idx() const;
                void set_just_recorded( bool value );
                bool get_just_recorded() const;
 
                /*
                 * selected sample
                 * */
        std::shared_ptr<SelectedLayerInfo> get_layer_selected( int CompoID );
        std::map<int, std::shared_ptr<SelectedLayerInfo>> get_layers_selected() const;
 
 
                void set_probability( float value );
                float get_probability() const;
 
                void set_humanize_delay( int value );
                int get_humanize_delay() const;
                float get_cut_off() const;
                float get_resonance() const;
                float get_bpfb_l() const;
                float get_bpfb_r() const;
                float get_lpfb_l() const;
                float get_lpfb_r() const;
                bool filter_sustain() const;
                Key get_key();
                Octave get_octave();
                int get_midi_key() const;
                int get_midi_velocity() const;
                float get_notekey_pitch() const;
                float get_total_pitch() const;
 
                QString key_to_string();
                void set_key_octave( const QString& str );
                void set_key_octave( Key key, Octave octave );
                void set_midi_info( Key key, Octave octave, int msg );
 
                std::shared_ptr<ADSR> get_adsr() const;
 
                bool match( std::shared_ptr<Instrument> instrument, Key key, Octave octave ) const;
 
                bool match( const Note *pNote ) const;
                bool match( const std::shared_ptr<Note> pNote ) const;
 
                void compute_lr_values( float* val_l, float* val_r );
 
        long long getNoteStart() const;
        float getUsedTickSize() const;
 
        bool isPartiallyRendered() const;
 
        void computeNoteStart();
 
        void humanize();
 
        void swing();
        
                QString toQString( const QString& sPrefix = "", bool bShort = true ) const override;
 
                static inline double pitchToFrequency( double fPitch ) {
                        // Equivalent to, but quicker to compute than, pow( 2.0, ( fPitch/12 ) )
                        return pow( 1.0594630943593, fPitch );
                }
 
                static inline Octave pitchToOctave( int nPitch ) {
                        if ( nPitch >= 0 ) {
                                return (Octave)(nPitch / 12);
                        } else {
                                return (Octave)((nPitch-11) / 12);
                        }
                }
                static inline Key pitchToKey( int nPitch ) {
                        return (Key)(nPitch - 12 * pitchToOctave( nPitch ));
                }
                static inline int octaveKeyToPitch( Octave octave, Key key ) {
                        return 12 * (int)octave + (int)key;
                }
 
        std::shared_ptr<Sample> getSample( int nComponentID, int nSelectedLayer = -1 );
 
        private:
                std::shared_ptr<Instrument>             __instrument;   
                int                             __instrument_id;        
                int                             __specific_compo_id;    
                int                             __position;             
                float                   __velocity;           
                float                   m_fPan;         
 
                int                             __length;               
                float                   __pitch;              
                Key                             __key;                  
                Octave                   __octave;            
                std::shared_ptr<ADSR>                   __adsr;               
                float                   __lead_lag;           
                float                   __cut_off;            
                float                   __resonance;          
 
                int                             __humanize_delay;
        std::map< int, std::shared_ptr<SelectedLayerInfo>> __layers_selected;
                float                   __bpfb_l;             
                float                   __bpfb_r;             
                float                   __lpfb_l;             
                float                   __lpfb_r;             
                int                             __pattern_idx;          
                int                             __midi_msg;             
                bool                    __note_off;            
                bool                    __just_recorded;       
                float                   __probability;        
                static const char* __key_str[]; 
 
        long long m_nNoteStart;
        float m_fUsedTickSize;
};
 
// DEFINITIONS
 
inline std::shared_ptr<ADSR> Note::get_adsr() const
{
        return __adsr;
}
 
inline std::shared_ptr<Instrument> Note::get_instrument()
{
        return __instrument;
}
 
inline bool Note::has_instrument() const
{
        return __instrument!=nullptr;
}
 
inline void Note::set_instrument_id( int value )
{
        __instrument_id = value;
}
 
inline int Note::get_instrument_id() const
{
        return __instrument_id;
}
 
inline void Note::set_specific_compo_id( int value )
{
        __specific_compo_id = value;
}
 
inline int Note::get_specific_compo_id() const
{
        return __specific_compo_id;
}
 
inline void Note::set_position( int value )
{
        __position = value;
}
 
inline int Note::get_position() const
{
        return __position;
}
 
inline float Note::get_velocity() const
{
        return __velocity;
}
 
inline float Note::getPan() const
{
        return m_fPan;
}
 
inline float Note::get_lead_lag() const
{
        return __lead_lag;
}
 
inline void Note::set_length( int value )
{
        __length = value;
}
 
inline int Note::get_length() const
{
        return __length;
}
 
inline void Note::set_pitch( float value )
{
        __pitch = value;
}
 
inline float Note::get_pitch() const
{
        return __pitch;
}
 
inline void Note::set_note_off( bool value )
{
        __note_off = value;
}
 
inline bool Note::get_note_off() const
{
        return __note_off;
}
 
inline int Note::get_midi_msg() const
{
        return __midi_msg;
}
 
inline void Note::set_pattern_idx( int value )
{
        __pattern_idx = value;
}
 
inline int Note::get_pattern_idx() const
{
        return __pattern_idx;
}
 
inline void Note::set_just_recorded( bool value )
{
        __just_recorded = value;
}
 
inline bool Note::get_just_recorded() const
{
        return __just_recorded;
}
 
inline float Note::get_probability() const
{
        return __probability;
}
 
inline void Note::set_probability( float value )
{
        __probability = value;
}
 
inline std::shared_ptr<SelectedLayerInfo> Note::get_layer_selected( int CompoID )
{
        return __layers_selected[ CompoID ];
}
 
inline std::map<int, std::shared_ptr<SelectedLayerInfo>> Note::get_layers_selected() const
{
        return __layers_selected;
}
 
inline int Note::get_humanize_delay() const
{
        return __humanize_delay;
}
 
inline float Note::get_cut_off() const
{
        return __cut_off;
}
 
inline float Note::get_resonance() const
{
        return __resonance;
}
 
inline float Note::get_bpfb_l() const
{
        return __bpfb_l;
}
 
inline float Note::get_bpfb_r() const
{
        return __bpfb_r;
}
 
inline float Note::get_lpfb_l() const
{
        return __lpfb_l;
}
 
inline float Note::get_lpfb_r() const
{
        return __lpfb_r;
}
 
inline bool Note::filter_sustain() const
{
        const double fLimit = 0.001;
        return ( fabs( __lpfb_l ) > fLimit || fabs( __lpfb_r ) > fLimit ||
                         fabs( __bpfb_l ) > fLimit || fabs( __bpfb_r ) > fLimit );
}
 
inline Note::Key Note::get_key()
{
        return __key;
}
 
inline Note::Octave Note::get_octave()
{
        return __octave;
}
 
inline int Note::get_midi_key() const
{
        /* TODO ???
        if( !has_instrument() ) { return (__octave + OCTAVE_OFFSET ) * KEYS_PER_OCTAVE + __key; }
        */
        return ( __octave + OCTAVE_OFFSET ) * KEYS_PER_OCTAVE + __key + __instrument->get_midi_out_note() - MIDI_DEFAULT_OFFSET;
}
 
inline int Note::get_midi_velocity() const
{
        return __velocity * MIDI_FACTOR;
}
 
inline float Note::get_notekey_pitch() const
{
        return __octave * KEYS_PER_OCTAVE + __key;
}
 
inline void Note::set_key_octave( Key key, Octave octave )
{
        if( key>=KEY_MIN && key<=KEY_MAX ) __key = key;
        if( octave>=OCTAVE_MIN && octave<=OCTAVE_MAX ) __octave = octave;
}
 
inline void Note::set_midi_info( Key key, Octave octave, int msg )
{
        if( key>=KEY_MIN && key<=KEY_MAX ) __key = key;
        if( octave>=OCTAVE_MIN && octave<=OCTAVE_MAX ) __octave = octave;
        __midi_msg = msg;
}
 
inline bool Note::match( std::shared_ptr<Instrument> instrument, Key key, Octave octave ) const
{
        return ( ( __instrument==instrument ) && ( __key==key ) && ( __octave==octave ) );
}
 
inline bool Note::match( const Note *pNote ) const
{
        return match( pNote->__instrument, pNote->__key, pNote->__octave );
}
inline bool Note::match( const std::shared_ptr<Note> pNote ) const
{
        return match( pNote->__instrument, pNote->__key, pNote->__octave );
}
 
inline void Note::compute_lr_values( float* val_l, float* val_r )
{
        /* TODO ???
        if( !has_instrument() ) {
                *val_l = 0.0f;
                *val_r = 0.0f;
                return;
        }
        */
        float cut_off = __instrument->get_filter_cutoff();
        float resonance = __instrument->get_filter_resonance();
        __bpfb_l  =  resonance * __bpfb_l  + cut_off * ( *val_l - __lpfb_l );
        __lpfb_l +=  cut_off   * __bpfb_l;
        __bpfb_r  =  resonance * __bpfb_r  + cut_off * ( *val_r - __lpfb_r );
        __lpfb_r +=  cut_off   * __bpfb_r;
        *val_l = __lpfb_l;
        *val_r = __lpfb_r;
}
 
inline long long Note::getNoteStart() const {
        return m_nNoteStart;
}
inline float Note::getUsedTickSize() const {
        return m_fUsedTickSize;
}
};
 
#endif // H2C_NOTE_H
 
/* vim: set softtabstop=4 noexpandtab: */