/home/pete/Work/TSE3.svn/tse3/src/tse3/Transport.h

Go to the documentation of this file.

/*
 * @(#)Transport.h 3.00 25 May 1999
 *
 * Copyright (c) 2000 Pete Goodliffe (pete@cthree.org)
 *
 * This file is part of TSE3 - the Trax Sequencer Engine version 3.00.
 *
 * This library is modifiable/redistributable under the terms of the GNU
 * General Public License.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING. If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#ifndef TSE3_TRANSPORT_H
#define TSE3_TRANSPORT_H

#include "tse3/listen/Transport.h"

#include "tse3/Notifier.h"
#include "tse3/Panic.h"
#include "tse3/MidiMapper.h"
#include "tse3/MidiEcho.h"
#include "tse3/listen/Playable.h"
#include "tse3/listen/PhraseEdit.h"
#include "tse3/listen/MidiScheduler.h"
#include "tse3/listen/FlagTrack.h"
#include "tse3/listen/Metronome.h"

#include <queue>
#include <list>

namespace TSE3
{
    class Transport : public Listener<MidiSchedulerListener>,
                      public Listener<FlagTrackListener>,
                      public Listener<PhraseEditListener>,
                      public Listener<MetronomeListener>,
                      public Listener<PlayableListener>,
                      public Notifier<TransportListener>
    {
        public:

            Transport(Metronome     *metronome,
                      MidiScheduler *scheduler);
            virtual ~Transport();

            void attachCallback(TransportCallback *c);

            void detachCallback(TransportCallback *c);

            MidiScheduler *scheduler() const { return _scheduler; }

            MidiFilter *filter() { return &_filter; };

            Panic *startPanic() { return &_startPanic; }

            Panic *endPanic() { return &_endPanic; }

            MidiMapper *midiMapper() { return &_midiMapper; }

            MidiEcho *midiEcho() { return &_midiEcho; }

            void setFlagTrack(FlagTrack *f) { flagTrack = f; }

            bool synchro() const { return _synchro; }

            void setSynchro(bool s);

            bool punchIn() const { return _punchIn; }

            void setPunchIn(bool p);

            bool autoStop() const { return _autoStop; }

            void setAutoStop(bool s);

            Clock playLeadIn() const { return _playLeadIn; }

            void setPlayLeadIn(Clock c);

            Clock recordLeadIn() const { return _recLeadIn; }

            void setRecordLeadIn(Clock c);

            void play(Playable *p, Clock startTime);

            void record(Playable *p, Clock startTime,
                        PhraseEdit *pe, MidiFilter *filter = 0);

            void stop();

            void ff(bool strong);

            void ffFlag();

            void rew(bool strong);

            void rewFlag();

            void poll();

            int status() const { return _status; }

            Playable *playable() const { return _playable; }

            enum TransportMode
            {
                Resting,
                Playing,
                Recording,
                SynchroPlaying,
                SynchroRecording
            };

            Clock lookAhead() const { return _lookAhead; }

            void setLookAhead(Clock c);

            Clock minimumLookAhead() const { return _minimumLookAhead; }

            bool adaptiveLookAhead() const { return _adaptiveLookAhead; }

            void setAdaptiveLookAhead(bool ala);

            int breakUps() const { return _breakUps; }

            void inject(MidiCommand c);

            virtual void MidiScheduler_Started(MidiScheduler *);

            virtual void MidiScheduler_Stopped(MidiScheduler *);

            virtual void MidiScheduler_Moved(MidiScheduler *);

            virtual void Notifier_Deleted(FlagTrack *);

            virtual void Notifier_Deleted(Metronome *);

            virtual void Notifier_Deleted(MidiScheduler *);

            virtual void Notifier_Deleted(PhraseEdit *);

            virtual void Notifier_Deleted(Playable *);

        private:

            Transport &operator=(const Transport &);
            Transport(const Transport &);

            void startPlayback();

            void pollPlayback();

            void stopPlayback(Clock stopTime);

            void shiftBy(Clock c);

            void callback_MidiOut(MidiCommand c);

            void callback_MidiIn(MidiCommand c);

            void handleMidiSchedulerEvent();

            std::list<TransportCallback *>  callbacks;
            Playable                       *_playable;
            PlayableIterator               *iterator;
            FlagTrack                      *flagTrack;
            PhraseEdit                     *recPE;
            std::priority_queue<MidiEvent,
                                std::vector<MidiEvent>,
                                std::greater<MidiEvent> >
                                            noteOffBuffer;
            Metronome                      *metronome;
            PlayableIterator               *metronomeIterator;
            MidiScheduler                  *_scheduler;
            MidiFilter                      _filter;
            Panic                           _startPanic;
            Panic                           _endPanic;
            MidiMapper                      _midiMapper;
            MidiEcho                        _midiEcho;

            int                             _status;
            bool                            _synchro;
            bool                            _punchIn;
            bool                            _autoStop;
            Clock                           lastScheduledClock;
            Clock                           lastPollPlaybackClock;
            bool                            _adaptiveLookAhead;
            Clock                           _lookAhead;
            static const Clock              _minimumLookAhead;
            int                             _breakUps;
            bool                            punchedInYet;
            MidiFilter                     *punchInFilter;
            bool                            punchInStatus;
            MidiCommand                     injectedMidiCommand;

            Clock                           _playLeadIn;
            Clock                           _recLeadIn;

            Clock transportLeadIn;
    };
}

#endif

---