Song.h

Go to the documentation of this file.

/*
 * Song.h - class song - the root of the model-tree
 *
 * 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_SONG_H
#define LMMS_SONG_H
 
#include <array>
#include <memory>
 
#include <QString>
#include <QHash>  // IWYU pragma: keep
 
#include "AudioEngine.h"
#include "Controller.h"
#include "Metronome.h"
#include "lmms_constants.h"
#include "MeterModel.h"
#include "Timeline.h"
#include "TrackContainer.h"
#include "VstSyncController.h"
 
namespace lmms
{
 
class AutomationTrack;
class Keymap;
class MidiClip;
class Scale;
 
namespace gui
{
class SongEditor;
class ControllerRackView;
}
 
 
const bpm_t MinTempo = 10;
const bpm_t DefaultTempo = 140;
const bpm_t MaxTempo = 999;
const tick_t MaxSongLength = 9999 * DefaultTicksPerBar;
 
 
class LMMS_EXPORT Song : public TrackContainer
{
        Q_OBJECT
        mapPropertyFromModel( int,getTempo,setTempo,m_tempoModel );
        mapPropertyFromModel( int,masterPitch,setMasterPitch,m_masterPitchModel );
        mapPropertyFromModel( int,masterVolume,setMasterVolume, m_masterVolumeModel );
public:
        enum class PlayMode
        {
                None,
                Song,
                Pattern,
                MidiClip,
                AutomationClip,
                Count
        } ;
        constexpr static auto PlayModeCount = static_cast<std::size_t>(PlayMode::Count);
 
        struct SaveOptions {
                BoolModel discardMIDIConnections{false};
                BoolModel saveAsProjectBundle{false};
 
                void setDefaultOptions() {
                        discardMIDIConnections.setValue(false);
                        saveAsProjectBundle.setValue(false);
                }
        };
 
        void clearErrors();
        void collectError( const QString error );
        bool hasErrors();
        QString errorSummary();
 
        void processNextBuffer();
 
        inline int getLoadingTrackCount() const
        {
                return m_nLoadingTrack;
        }
 
        inline int getMilliseconds() const
        {
                return getMilliseconds(m_playMode);
        }

        inline int getMilliseconds(PlayMode playMode) const
        {
                return 1000 * getTimeline(playMode).getElapsedSeconds();
        }
 
        inline int getBars() const
        {
                return currentBar();
        }
 
        inline int ticksPerBar() const
        {
                return TimePos::ticksPerBar(m_timeSigModel);
        }
 
        // Returns the beat position inside the bar, 0-based
        inline int getBeat() const
        {
                return getPlayPos().getBeatWithinBar(m_timeSigModel);
        }
        // the remainder after bar and beat are removed
        inline int getBeatTicks() const
        {
                return getPlayPos().getTickWithinBeat(m_timeSigModel);
        }
        inline int getTicks() const
        {
                return currentTick();
        }
        inline f_cnt_t getFrames() const
        {
                return currentFrame();
        }
        inline bool isPaused() const
        {
                return m_paused;
        }
 
        inline bool isPlaying() const
        {
                return m_playing == true && m_exporting == false;
        }
 
        inline bool isStopped() const
        {
                return m_playing == false && m_paused == false;
        }
 
        inline bool isExporting() const
        {
                return m_exporting;
        }
 
        inline void setExportLoop( bool exportLoop )
        {
                m_exportLoop = exportLoop;
        }
 
        inline bool isRecording() const
        {
                return m_recording;
        }
        
        inline void setLoopRenderCount(int count)
        {
                if (count < 1)
                        m_loopRenderCount = 1;
                else
                        m_loopRenderCount = count;
                m_loopRenderRemaining = m_loopRenderCount;
        }
    
        inline int getLoopRenderCount() const
        {
                return m_loopRenderCount;
        }
 
        bool isExportDone() const;
        int getExportProgress() const;
 
        inline void setRenderBetweenMarkers( bool renderBetweenMarkers )
        {
                m_renderBetweenMarkers = renderBetweenMarkers;
        }
 
        inline PlayMode playMode() const
        {
                return m_playMode;
        }
 
        const TimePos& getPlayPos(PlayMode pm) const
        {
                return getTimeline(pm).pos();
        }
        const TimePos& getPlayPos() const
        {
                return getPlayPos(m_playMode);
        }
 
        void setPlayPos(tick_t ticks, PlayMode playMode)
        {
                getTimeline(playMode).setTicks(ticks);
        }
        void setPlayPos(tick_t ticks)
        {
                setPlayPos(ticks, m_playMode);
        }
 
        auto getTimeline(PlayMode mode) -> Timeline& { return m_timelines[static_cast<std::size_t>(mode)]; }
        auto getTimeline(PlayMode mode) const -> const Timeline& { return m_timelines[static_cast<std::size_t>(mode)]; }
        auto getTimeline() -> Timeline& { return getTimeline(m_playMode); }
        auto getTimeline() const -> const Timeline& { return getTimeline(m_playMode); }
 
        void updateLength();
        bar_t length() const
        {
                return m_length;
        }
 
 
        bpm_t getTempo();
 
        AutomationTrack * globalAutomationTrack()
        {
                return m_globalAutomationTrack;
        }
 
        //TODO: Add Q_DECL_OVERRIDE when Qt4 is dropped
        AutomatedValueMap automatedValuesAt(TimePos time, int clipNum = -1) const override;
 
        // file management
        void createNewProject();
        void createNewProjectFromTemplate( const QString & templ );
        void loadProject( const QString & filename );
        bool guiSaveProject();
        bool guiSaveProjectAs(const QString & filename);
        bool saveProjectFile(const QString & filename, bool withResources = false);
 
        const QString & projectFileName() const
        {
                return m_fileName;
        }
 
        bool isLoadingProject() const
        {
                return m_loadingProject;
        }
 
        void loadingCancelled()
        {
                m_isCancelled = true;
                Engine::audioEngine()->clearNewPlayHandles();
        }
 
        bool isCancelled()
        {
                return m_isCancelled;
        }
 
        bool isModified() const
        {
                return m_modified;
        }
 
        QString nodeName() const override
        {
                return "song";
        }
 
        virtual bool fixedClips() const
        {
                return false;
        }
 
        void addController( Controller * c );
        void removeController( Controller * c );
 
 
        const ControllerVector & controllers() const
        {
                return m_controllers;
        }
 
 
        MeterModel & getTimeSigModel()
        {
                return m_timeSigModel;
        }
 
        IntModel& tempoModel()
        {
                return m_tempoModel;
        }
 
        void exportProjectMidi(QString const & exportFileName) const;
 
        inline void setLoadOnLaunch(bool value) { m_loadOnLaunch = value; }
        SaveOptions &getSaveOptions() {
                return m_saveOptions;
        }
 
        bool isSavingProject() const;
 
        std::shared_ptr<const Scale> getScale(unsigned int index) const;
        std::shared_ptr<const Keymap> getKeymap(unsigned int index) const;
        void setScale(unsigned int index, std::shared_ptr<Scale> newScale);
        void setKeymap(unsigned int index, std::shared_ptr<Keymap> newMap);
 
        const std::string& syncKey() const noexcept { return m_vstSyncController.sharedMemoryKey(); }
 
        Metronome& metronome() { return m_metronome; }
 
public slots:
        void playSong();
        void record();
        void playAndRecord();
        void playPattern();
        void playMidiClip( const lmms::MidiClip * midiClipToPlay, bool loop = true );
        void togglePause();
        void stop();
 
        void startExport();
        void stopExport();
 
 
        void setModified();
 
        void clearProject();
 
        void addPatternTrack();
 
 
private slots:
        void insertBar();
        void removeBar();
        void addSampleTrack();
        void addAutomationTrack();
 
        void setTempo();
        void setTimeSignature();
 
        void masterVolumeChanged();
 
        void savePlayStartPosition();
 
        void updateFramesPerTick();
 
 
 
private:
        Song();
        Song( const Song & );
        ~Song() override;
 
 
        inline bar_t currentBar() const
        {
                return getPlayPos(m_playMode).getBar();
        }
 
        inline tick_t currentTick() const
        {
                return getPlayPos(m_playMode).getTicks();
        }
 
        inline f_cnt_t currentFrame() const
        {
                return getTimeline(m_playMode).ticks() * Engine::framesPerTick() + getTimeline(m_playMode).frameOffset();
        }
 
        void saveControllerStates( QDomDocument & doc, QDomElement & element );
        void restoreControllerStates( const QDomElement & element );
 
        void removeAllControllers();
 
        void saveScaleStates(QDomDocument &doc, QDomElement &element);
        void restoreScaleStates(const QDomElement &element);
 
        void saveKeymapStates(QDomDocument &doc, QDomElement &element);
        void restoreKeymapStates(const QDomElement &element);
 
        void processAutomations(const TrackList& tracks, TimePos timeStart, f_cnt_t frames);
        void processMetronome(size_t bufferOffset);
 
        void setModified(bool value);
 
        void setProjectFileName(QString const & projectFileName);
 
        AutomationTrack * m_globalAutomationTrack;
 
        IntModel m_tempoModel;
        MeterModel m_timeSigModel;
        int m_oldTicksPerBar;
        IntModel m_masterVolumeModel;
        IntModel m_masterPitchModel;
 
        ControllerVector m_controllers;
 
        int m_nLoadingTrack;
 
        QString m_fileName;
        QString m_oldFileName;
        bool m_modified;
        bool m_loadOnLaunch;
 
        volatile bool m_recording;
        volatile bool m_exporting;
        volatile bool m_exportLoop;
        volatile bool m_renderBetweenMarkers;
        volatile bool m_playing;
        volatile bool m_paused;
 
        bool m_savingProject;
        bool m_loadingProject;
        bool m_isCancelled;
 
        SaveOptions m_saveOptions;
 
        QHash<QString, int> m_errors;
 
        std::array<Timeline, PlayModeCount> m_timelines;
 
        PlayMode m_playMode;
        bar_t m_length;
 
        const MidiClip* m_midiClipToPlay;
        bool m_loopMidiClip;
 
        VstSyncController m_vstSyncController;
    
        int m_loopRenderCount;
        int m_loopRenderRemaining;
        TimePos m_exportSongBegin;
        TimePos m_exportLoopBegin;
        TimePos m_exportLoopEnd;
        TimePos m_exportSongEnd;
        TimePos m_exportEffectiveLength;
 
        std::shared_ptr<Scale> m_scales[MaxScaleCount];
        std::shared_ptr<Keymap> m_keymaps[MaxKeymapCount];
 
        AutomatedValueMap m_oldAutomatedValues;
 
        Metronome m_metronome;
 
        friend class Engine;
        friend class gui::SongEditor;
        friend class gui::ControllerRackView;
 
signals:
        void projectLoaded();
        void playbackStateChanged();
        void playbackPositionJumped();
        void lengthChanged( int bars );
        void tempoChanged( lmms::bpm_t newBPM );
        void timeSignatureChanged( int oldTicksPerBar, int ticksPerBar );
        void controllerAdded( lmms::Controller * );
        void controllerRemoved( lmms::Controller * );
        void stopped();
        void modified();
        void projectFileNameChanged();
        void scaleListChanged(int index);
        void keymapListChanged(int index);
} ;
 
 
} // namespace lmms
 
#endif // LMMS_SONG_H