NotePlayHandle.h

Go to the documentation of this file.

/*
 * NotePlayHandle.h - declaration of class NotePlayHandle which manages
 *                    playback of a single note by an instrument
 *
 * Copyright (c) 2004-2014 Tobias Doerffel <tobydox/at/users.sourceforge.net>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * 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 (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LMMS_NOTE_PLAY_HANDLE_H
#define LMMS_NOTE_PLAY_HANDLE_H
 
#include <memory>
 
#include "BasicFilters.h"
#include "Note.h"
#include "PlayHandle.h"
#include "Track.h"
 
class QReadWriteLock;
 
namespace lmms
{
 
class InstrumentTrack;
class NotePlayHandle;
 
using NotePlayHandleList = QList<NotePlayHandle*>;
using ConstNotePlayHandleList = QList<const NotePlayHandle*>;
 
class LMMS_EXPORT NotePlayHandle : public PlayHandle, public Note
{
public:
        void * m_pluginData;
        std::unique_ptr<BasicFilters<>> m_filter;
 
        // length of the declicking fade in
        f_cnt_t m_fadeInLength;
 
        // specifies origin of NotePlayHandle
        enum class Origin
        {
                MidiClip,               
                MidiInput,      
                NoteStacking,   
                Arpeggio,               
        };
 
        NotePlayHandle( InstrumentTrack* instrumentTrack,
                                        const f_cnt_t offset,
                                        const f_cnt_t frames,
                                        const Note& noteToPlay,
                                        NotePlayHandle* parent = nullptr,
                                        int midiEventChannel = -1,
                                        Origin origin = Origin::MidiClip );
        ~NotePlayHandle() override;
 
        void * operator new ( size_t size, void * p )
        {
                return p;
        }
 
        void setVolume( volume_t volume ) override;
        void setPanning( panning_t panning ) override;
 
        int midiKey() const;
        int midiChannel() const
        {
                return m_midiChannel;
        }

        f_cnt_t noteOffset() const
        {
                return m_totalFramesPlayed == 0
                        ? offset()
                        : 0;
        }
 
        const float& frequency() const
        {
                return m_frequency;
        }

        float unpitchedFrequency() const
        {
                return m_unpitchedFrequency;
        }

        float currentDetuning() const { return m_baseDetuning->value(); }

        void play( SampleFrame* buffer ) override;

        bool isFinished() const override
        {
                return m_released && framesLeft() <= 0;
        }

        f_cnt_t framesLeft() const;

        f_cnt_t framesLeftForCurrentPeriod() const;

        bool isFromTrack( const Track* _track ) const override;

        void noteOff( const f_cnt_t offset = 0 );

        f_cnt_t framesBeforeRelease() const
        {
                return m_framesBeforeRelease;
        }

        f_cnt_t releaseFramesDone() const
        {
                return m_releaseFramesDone;
        }

        f_cnt_t actualReleaseFramesToDo() const;

        f_cnt_t frames() const
        {
                return m_frames;
        }

        void setFrames( const f_cnt_t _frames );

        bool isReleased() const
        {
                return m_released;
        }
 
        bool isReleaseStarted() const
        {
                return m_releaseStarted;
        }

        f_cnt_t totalFramesPlayed() const
        {
                return m_totalFramesPlayed;
        }

        float volumeLevel( const f_cnt_t frame );

        const InstrumentTrack* instrumentTrack() const
        {
                return m_instrumentTrack;
        }

        InstrumentTrack* instrumentTrack()
        {
                return m_instrumentTrack;
        }

        bool hasParent() const
        {
                return m_hasParent;
        }

        Origin origin() const
        {
                return m_origin;
        }

        bool isMasterNote() const
        {
                return m_subNotes.size() > 0 || m_hadChildren;
        }
 
        void setMasterNote()
        {
                m_hadChildren = true;
                setUsesBuffer( false );
        }

        bool isMuted() const
        {
                return m_muted;
        }

        void mute();

        int index() const;

        static ConstNotePlayHandleList nphsOfInstrumentTrack( const InstrumentTrack* Track, bool allPlayHandles = false );

        bool operator==( const NotePlayHandle & _nph ) const;

        bool isPatternTrackMuted()
        {
                return m_patternTrack && m_patternTrack->isMuted();
        }

        void setPatternTrack(Track* t)
        {
                m_patternTrack = t;
        }

        void processTimePos(const TimePos& time, float pitchValue, bool isRecording);

        void resize( const bpm_t newTempo );

        void setSongGlobalParentOffset( const TimePos& offset )
        {
                m_songGlobalParentOffset = offset;
        }

        const TimePos& songGlobalParentOffset() const
        {
                return m_songGlobalParentOffset;
        }
 
        void setFrequencyUpdate()
        {
                m_frequencyNeedsUpdate = true;
        }
 
private:
        class BaseDetuning
        {
        public:
                BaseDetuning( DetuningHelper* detuning );
 
                void setValue( float val )
                {
                        m_value = val;
                }
 
                float value() const
                {
                        return m_value;
                }
 
 
        private:
                float m_value;
 
        } ;
 
        void updateFrequency();
 
        InstrumentTrack* m_instrumentTrack;             // needed for calling
                                                                                        // InstrumentTrack::playNote
        f_cnt_t m_frames;                                               // total frames to play
        f_cnt_t m_totalFramesPlayed;                    // total frame-counter - used for
                                                                                        // figuring out whether a whole note
                                                                                        // has been played
        f_cnt_t m_framesBeforeRelease;                  // number of frames after which note
                                                                                        // is released
        f_cnt_t m_releaseFramesToDo;                    // total numbers of frames to be
                                                                                        // played after release
        f_cnt_t m_releaseFramesDone;                    // number of frames done after
                                                                                        // release of note
        NotePlayHandleList m_subNotes;                  // used for chords and arpeggios
        volatile bool m_released;                               // indicates whether note is released
        bool m_releaseStarted;
        bool m_hasMidiNote;
        bool m_hasParent;                                               // indicates whether note has parent
        NotePlayHandle * m_parent;                      // parent note
        bool m_hadChildren;
        bool m_muted;                                                   // indicates whether note is muted
        Track* m_patternTrack;                                          // related pattern track
 
        // tempo reaction
        bpm_t m_origTempo;                                              // original tempo
        f_cnt_t m_origFrames;                                   // original m_frames
 
        int m_origBaseNote;
 
        float m_frequency;
        float m_unpitchedFrequency;
 
        BaseDetuning* m_baseDetuning;
        TimePos m_songGlobalParentOffset;
 
        int m_midiChannel;
        Origin m_origin;
 
        bool m_frequencyNeedsUpdate;                            // used to update pitch
} ;
 
 
const int INITIAL_NPH_CACHE = 256;
const int NPH_CACHE_INCREMENT = 16;
 
class NotePlayHandleManager
{
public:
        static void init();
        static NotePlayHandle * acquire( InstrumentTrack* instrumentTrack,
                                        const f_cnt_t offset,
                                        const f_cnt_t frames,
                                        const Note& noteToPlay,
                                        NotePlayHandle* parent = nullptr,
                                        int midiEventChannel = -1,
                                        NotePlayHandle::Origin origin = NotePlayHandle::Origin::MidiClip );
        static void release( NotePlayHandle * nph );
        static void extend( int i );
        static void free();
 
private:
        static NotePlayHandle ** s_available;
        static QReadWriteLock s_mutex;
        static std::atomic_int s_availableIndex;
        static int s_size;
};
 
 
} // namespace lmms
 
#endif // LMMS_NOTE_PLAY_HANDLE_H