TransportPosition.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 TRANSPORT_POSITION_H
#define TRANSPORT_POSITION_H
 
#include <memory>
 
#include <core/Object.h>
#include <core/AudioEngine/AudioEngine.h>
#include <core/AudioEngine/AudioEngineTests.h>
#include <core/IO/JackAudioDriver.h>
 
namespace H2Core
{
 
class PatternList;

class TransportPosition : public H2Core::Object<TransportPosition>
{
        H2_OBJECT(TransportPosition)
public:
 
        TransportPosition( const QString sLabel = "" );
        TransportPosition( std::shared_ptr<TransportPosition> pOther );
        ~TransportPosition();
 
        const QString getLabel() const;
        long long getFrame() const;
        long getTick() const;
        float getTickSize() const;
        float getBpm() const;
        long getPatternStartTick() const;
        long getPatternTickPosition() const;
        int getColumn() const;
        double getTickMismatch() const;
        long long getFrameOffsetTempo() const;
        double getTickOffsetQueuing() const;
        double getTickOffsetSongSize() const;
        const PatternList* getPlayingPatterns() const;
        const PatternList* getNextPatterns() const;
        int getPatternSize() const;
        long long getLastLeadLagFactor() const;
        int getBar() const;
        int getBeat() const;

        static double computeTickFromFrame( long long nFrame, int nSampleRate = 0 );

        static long long computeFrameFromTick( double fTick, double* fTickMismatch, int nSampleRate = 0 );
 
        friend bool operator==( std::shared_ptr<TransportPosition> lhs,
                                                         std::shared_ptr<TransportPosition> rhs );
        friend bool operator!=( std::shared_ptr<TransportPosition> lhs,
                                                         std::shared_ptr<TransportPosition> rhs );
        
        QString toQString( const QString& sPrefix = "", bool bShort = true ) const override;
 
        friend class AudioEngine;
        friend class AudioEngineTests;
        friend class JackAudioDriver;
 
private:
        void set( std::shared_ptr<TransportPosition> pOther );
        void reset();
        
        void setFrame( long long nNewFrame );
        void setTick( double fNewTick );
        void setTickSize( float fNewTickSize );
        void setBpm( float fNewBpm );
        void setPatternStartTick( long nPatternStartTick );
        void setPatternTickPosition( long nPatternTickPosition );
        void setColumn( int nColumn );
        void setFrameOffsetTempo( long long nFrameOffset );
        void setTickOffsetQueuing( double nTickOffset );
        void setTickOffsetSongSize( double fTickOffset );
        void setPlayingPatterns( PatternList* pPatternList );
        void setNextPatterns( PatternList* pPatternList );
        void setPatternSize( int nPatternSize );
        void setLastLeadLagFactor( long long nValue );
        void setBar( int nBar );
        void setBeat( int nBeat );
        
        PatternList* getPlayingPatterns();
        PatternList* getNextPatterns();

        static long long computeFrame( double fTick, float fTickSize );
        static double computeTick( long long nFrame, float fTickSize );
 
        double getDoubleTick() const;

        const QString m_sLabel;

        long long m_nFrame;
        
        double m_fTick;
        
        float m_fTickSize;
        float m_fBpm;
        
        long                            m_nPatternStartTick;
        long                            m_nPatternTickPosition;
        int                                     m_nColumn;
        
        double                          m_fTickMismatch;

        long long                       m_nFrameOffsetTempo;
        double                          m_fTickOffsetQueuing;

        double                          m_fTickOffsetSongSize;

        PatternList*         m_pNextPatterns;
        
        PatternList*         m_pPlayingPatterns;
        
        int                             m_nPatternSize;

        long long m_nLastLeadLagFactor;

        int m_nBar;
        int m_nBeat;
};
 
inline const QString TransportPosition::getLabel() const {
        return m_sLabel;
}
inline long long TransportPosition::getFrame() const {
        return m_nFrame;
}
inline double TransportPosition::getDoubleTick() const {
        return m_fTick;
}
inline long TransportPosition::getTick() const {
        return static_cast<long>(std::floor( m_fTick ));
}
inline float TransportPosition::getTickSize() const {
        return m_fTickSize;
}
inline float TransportPosition::getBpm() const {
        return m_fBpm;
}
inline long TransportPosition::getPatternStartTick() const {
        return m_nPatternStartTick;
}
inline long TransportPosition::getPatternTickPosition() const {
        return m_nPatternTickPosition;
}
inline int TransportPosition::getColumn() const {
        return m_nColumn;
}
inline double TransportPosition::getTickMismatch() const {
        return m_fTickMismatch;
}
inline long long TransportPosition::getFrameOffsetTempo() const {
        return m_nFrameOffsetTempo;
}
inline void TransportPosition::setFrameOffsetTempo( long long nFrameOffset ) {
        m_nFrameOffsetTempo = nFrameOffset;
}
inline double TransportPosition::getTickOffsetQueuing() const {
        return m_fTickOffsetQueuing;
}
inline void TransportPosition::setTickOffsetQueuing( double fTickOffset ) {
        m_fTickOffsetQueuing = fTickOffset;
}
inline double TransportPosition::getTickOffsetSongSize() const {
        return m_fTickOffsetSongSize;
}
inline void TransportPosition::setTickOffsetSongSize( double fTickOffset ) {
        m_fTickOffsetSongSize = fTickOffset;
}
inline const PatternList* TransportPosition::getPlayingPatterns() const {
        return m_pPlayingPatterns;
}
inline PatternList* TransportPosition::getPlayingPatterns() {
        return m_pPlayingPatterns;
}
inline const PatternList* TransportPosition::getNextPatterns() const {
        return m_pNextPatterns;
}
inline PatternList* TransportPosition::getNextPatterns() {
        return m_pNextPatterns;
}
inline int TransportPosition::getPatternSize() const {
        return m_nPatternSize;
}
inline long long TransportPosition::getLastLeadLagFactor() const {
        return m_nLastLeadLagFactor;
}
inline void TransportPosition::setLastLeadLagFactor( long long nValue ) {
        m_nLastLeadLagFactor = nValue;
}
inline int TransportPosition::getBar() const {
        return m_nBar;
}
inline int TransportPosition::getBeat() const {
        return m_nBeat;
}
};
 
#endif