Sampler.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 SAMPLER_H
#define SAMPLER_H
 
#include <core/Object.h>
#include <core/Globals.h>
#include <core/Sampler/Interpolation.h>
 
#include <inttypes.h>
#include <vector>
#include <memory>
 
namespace H2Core
{
 
class Note;
class Song;
class Sample;
class DrumkitComponent;
class Instrument;
struct SelectedLayerInfo;
class InstrumentComponent;
 
 
class Sampler : public H2Core::Object<Sampler>
{
        H2_OBJECT(Sampler)
public:
 
        enum PAN_LAW_TYPES {
                RATIO_STRAIGHT_POLYGONAL = 0,
                RATIO_CONST_POWER,
                RATIO_CONST_SUM,
                LINEAR_STRAIGHT_POLYGONAL,
                LINEAR_CONST_POWER,
                LINEAR_CONST_SUM,
                POLAR_STRAIGHT_POLYGONAL,
                POLAR_CONST_POWER,
                POLAR_CONST_SUM,
                QUADRATIC_STRAIGHT_POLYGONAL,
                QUADRATIC_CONST_POWER,
                QUADRATIC_CONST_SUM,
                LINEAR_CONST_K_NORM,
                RATIO_CONST_K_NORM,
                POLAR_CONST_K_NORM,
                QUADRATIC_CONST_K_NORM
        };
        
        static const float K_NORM_DEFAULT;
        
 
        // pan law functions
        static float ratioStraightPolygonalPanLaw( float fPan );
        static float ratioConstPowerPanLaw( float fPan );
        static float ratioConstSumPanLaw( float fPan );
        static float linearStraightPolygonalPanLaw( float fPan );
        static float linearConstPowerPanLaw( float fPan );
        static float linearConstSumPanLaw( float fPan );
        static float polarStraightPolygonalPanLaw( float fPan );
        static float polarConstPowerPanLaw( float fPan );
        static float polarConstSumPanLaw( float fPan );
        static float quadraticStraightPolygonalPanLaw( float fPan );
        static float quadraticConstPowerPanLaw( float fPan );
        static float quadraticConstSumPanLaw( float fPan );
        // customly compensated 
        static float linearConstKNormPanLaw( float fPan, float k );
        static float polarConstKNormPanLaw( float fPan, float k );
        static float ratioConstKNormPanLaw( float fPan, float k );
        static float quadraticConstKNormPanLaw( float fPan, float k );
 
        static float getRatioPan( float fPan_L, float fPan_R );
        
 
        float* m_pMainOut_L;    
        float* m_pMainOut_R;    
 
        Sampler();
        ~Sampler();
 
        void process( uint32_t nFrames );
 
        bool isRenderingNotes() const;
        
        void noteOn( Note * pNote );
 
        void noteOff( Note *pNote );
        void midiKeyboardNoteOff( int key );
 
        void stopPlayingNotes( std::shared_ptr<Instrument> pInstr = nullptr );
 
        int getPlayingNotesNumber() {
                return m_playingNotesQueue.size();
        }
 
        void preview_sample( std::shared_ptr<Sample> pSample, int length );
        void preview_instrument( std::shared_ptr<Instrument> pInstr );
 
        bool isInstrumentPlaying( std::shared_ptr<Instrument> pInstr );
 
        void setInterpolateMode( Interpolation::InterpolateMode mode ){
                         m_interpolateMode = mode;
        }
        
        std::shared_ptr<Instrument> getPreviewInstrument() const {
                return m_pPreviewInstrument;
        }
        
        std::shared_ptr<Instrument> getPlaybackTrackInstrument() const {
                return m_pPlaybackTrackInstrument;
        }
 
        Interpolation::InterpolateMode getInterpolateMode(){ return m_interpolateMode; }
 
        void reinitializePlaybackTrack();
 
        void handleTimelineOrTempoChange();
        void handleSongSizeChange();
 
        const std::vector<Note*> getPlayingNotesQueue() const;
        
private:
        std::vector<Note*> m_playingNotesQueue;
        std::vector<Note*> m_queuedNoteOffs;
        
        std::shared_ptr<Instrument> m_pPlaybackTrackInstrument;
 
        std::shared_ptr<Instrument> m_pPreviewInstrument;
 
        int m_nMaxLayers;
        
        int m_nPlayBackSamplePosition;
        
        float panLaw( float fPan, std::shared_ptr<Song> pSong );
 
 
 
        bool processPlaybackTrack(int nBufferSize);
 
        bool renderNote( Note* pNote, unsigned nBufferSize );
 
        Interpolation::InterpolateMode m_interpolateMode;
 
        bool renderNoteResample(
                std::shared_ptr<Sample> pSample,
                Note *pNote,
                std::shared_ptr<SelectedLayerInfo> pSelectedLayerInfo,
                std::shared_ptr<InstrumentComponent> pCompo,
                std::shared_ptr<DrumkitComponent> pDrumCompo,
                int nBufferSize,
                int nInitialBufferPos,
                float cost_L,
                float cost_R,
                float cost_track_L,
                float cost_track_R,
                float fLayerPitch
        );
};
 
inline const std::vector<Note*> Sampler::getPlayingNotesQueue() const {
        return m_playingNotesQueue;
}
 
} // namespace
 
#endif