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

Go to the documentation of this file.

/*
 * @(#)MidiScheduler.h 3.00 10 November 2001
 *
 * 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_SCHEDULER_H
#define TSE3_SCHEDULER_H

#include "tse3/listen/MidiScheduler.h"

#include "tse3/Notifier.h"
#include "tse3/Midi.h"
#include "tse3/util/MulDiv.h"

#include <cstddef>
#include <vector>

namespace TSE3
{
    class MidiSchedulerFactory
    {
        public:

            MidiSchedulerFactory(bool canReturnNull = false);
            virtual ~MidiSchedulerFactory();

            MidiScheduler *createScheduler();

        private:

            MidiSchedulerFactory &operator=(const MidiSchedulerFactory &);
            MidiSchedulerFactory(const MidiSchedulerFactory &);

            bool _canReturnNull;
    };

    class MidiScheduler : public Notifier<MidiSchedulerListener>
    {
        public:

            MidiScheduler();

            virtual ~MidiScheduler();

            const char *implementationName() const
            {
                return this->impl_implementationName();
            }

            /******************************************************************
             * Finding out about the MIDI ports
             *****************************************************************/

            size_t numPorts() const { return _portNumbers.size(); }

            bool validPort(int port) const;

            int portNumber(size_t index) const
            {
                return _portNumbers[index].first;
            }

            size_t numberToIndex(int number) const;

            void portNumbers(std::vector<int> &numbers) const;

            const char *portName(int port) const;

            const char *portType(int port) const;

            bool portReadable(int port) const;

            bool portWriteable(int port) const;

            bool portInternal(int port) const;

            int defaultInternalPort() const;

            int defaultExternalPort() const;

            /******************************************************************
             * Manipulating the clock
             *****************************************************************/

            void start(Clock startTime) { this->impl_start(startTime); }

            void start() { this->impl_start(_restingClock); }

            void stop(Clock stopTime = -1);

            bool running() const { return _running; }

            void moveTo(Clock moveTime, Clock newTime);

            void moveTo(Clock moveTime) { moveTo(clock(), moveTime); }

            Clock clock()
            {
                return _running ? this->impl_clock() : _restingClock; }

            int msecs() { return this->impl_msecs(); }

            int tempo() const { return _tempo; }

            void setTempo(int newTempo, Clock changeTime)
            {
                if (newTempo >= 0)
                {
                    this->impl_setTempo(newTempo, changeTime);
                    _tempo = newTempo;
                }
            }

            /******************************************************************
             * Transmitting and receiving commands
             *****************************************************************/

            bool eventWaiting() { return this->impl_eventWaiting(); }

            MidiEvent rx();

            void tx(MidiCommand mc);

            void tx(MidiEvent event);

            /*
             * Transmit a MIDI "system exclusive" data section immeditately.
             * The data is prepended by a MidiSystem_SysExStart status byte,
             * and followed by a MidiSystem_SysExEnd status byte. You don't
             * have to include these in your parameters.
             *
             * Although you use this method to send sysex data, you receive
             * it through the normal rx mechanism; you will receive a
             * @ref MidiEvent with a @ref MidiSystem_SysExStart status byte,
             * and the first data byte (in data1). Subsequent data
             * bytes are received as MidiEvents with this same status byte. The
             * sysex data end is denoted by a @ref MidiEvent with the
             * @ref MidiSystem_SysExEnd status byte.
             *
             * @param port MIDI port number
             * @param data A buffer containing the sysex data to send
             * @param size The number of bytes in the @p data buffer
             */
            void txSysEx(int port, const unsigned char *data, size_t size);

            /******************************************************************
             * Remote control
             *****************************************************************/

            bool remoteControl() const { return _remote; }

            void setRemoteControl(bool s) { _remote = s; }

            bool consumeRemoveEvents() const { return _consumeRemote; }

            unsigned int startNote() const { return _startNote; }

            void setStartNote(unsigned int n) { _startNote = n; }

            unsigned int stopNote() const { return _stopNote; }

            void setStopNote(unsigned int n) { _stopNote = n; }

        protected:

            MidiScheduler(const MidiScheduler &);
            MidiScheduler &operator=(const MidiScheduler &);

            /******************************************************************
             * Implementation functions
             *
             * To implement a MidiScheduler for a particular platform you
             * implement the functions below. They are called by the
             * public MidiScheduler functions, using the Template Method
             * design pattern (GoF book).
             *
             * You can assume that you will never be called with an invalid
             * port number, and a number of other parameters are guaranteed
             * to be valid, as documented.
             *
             * Functions like impl_start and impl_stop are more requests
             * than commands. The MidiScheduler will not assume that the
             * clock has started until the implementation calls the
             * clockStarted function.
             *
             * You shouldn't need to perform any notifications, however, you
             * do need to take care to call the next block of protected APIs to
             * inform the MidiScheduler code what's going on. If you
             * don't do this, the MidiScheduler class will not behave
             * properly.
             *
             * Note that in your destructor you will also want to put the
             * following code first:
             *     // if playing, stop first!
             *     if (MidiScheduler::running()) stop();
             *
             * Your implementation of the MidiScheduler will have to deal
             * with timing. You will be sent events (via impl_tx) IN TIME
             * ORDER, for some time in the not-too distant future (as usually
             * specified by the Transport class's look-ahead). You have to
             * do the work of sending the event at the exact timer tick.
             *****************************************************************/

            virtual const char *impl_implementationName() const = 0;
            virtual const char *impl_portName(int port) const = 0;
            virtual const char *impl_portType(int port) const = 0;
            virtual bool        impl_portReadable(int port) const = 0;
            virtual bool        impl_portWriteable(int port) const = 0;
            virtual void impl_start(Clock clock) = 0;
            virtual void impl_stop(Clock clock) = 0;
            virtual void impl_moveTo(Clock moveTime, Clock newTime) = 0;
            virtual Clock impl_clock() = 0;
            virtual int impl_msecs() = 0;
            virtual void impl_setTempo(int tempo, Clock changeTime) = 0;
            virtual bool impl_eventWaiting() = 0;
            virtual MidiEvent impl_rx() = 0;
            virtual void impl_tx(MidiCommand mc) = 0;
            virtual void impl_tx(MidiEvent mc) = 0;
            virtual void impl_txSysEx(int port,
                                      const unsigned char *data,
                                      size_t size) = 0;

            /******************************************************************
             * Implementations call these functions to let the MidiScheduler
             * class know whats going on.
             *
             * Don't forget to call these at appropriate times from the
             * impl_XXX functions above.
             *****************************************************************/

            int addPort(int portIndex, bool isInternal, int requestedPort = 0);

            void removePort(int portIndex);
            void clockStarted(Clock startTime);
            void clockStopped(Clock stopTime);
            void clockMoved(const Clock moveTime, Clock newTime);
            void tempoChanged(int tempo, Clock changeTime);

            /******************************************************************
             * Internal helper functions you can call
             *****************************************************************/

            Clock startClock;

            // XXX use muldiv switch?

            int clockToMs(Clock time)
            {
                return Util::muldiv(time-startClock, 60000/Clock::PPQN, _tempo);
            }

            Clock msToClock(int ms)
            {
                return startClock + Util::muldiv(ms, _tempo, 60000/Clock::PPQN);
            }

        private:

            /******************************************************************
             * Internal private functions
             *****************************************************************/

            MidiEvent doRemoteControl(MidiEvent e);

            bool validChannel(int channel) const
            {
                return channel >= 0 && channel <= 15;
            }
            bool validChannel(MidiCommand mc) const
            {
                return validChannel(mc.channel);
            }

            bool lookUpPortNumber(MidiCommand &mc) const;
            bool lookUpPortNumber(int &port) const;

            void setToPortNumber(MidiCommand &mc) const;

            /******************************************************************
             * Internal private data
             *****************************************************************/

            struct PortInfo
            {
                int  index;
                bool isInternal;
                PortInfo(int n, bool i) : index(n), isInternal(i) {}
            };
            typedef std::vector<std::pair<int,PortInfo> > port_vector;

            port_vector    _portNumbers;

            bool           _running;
            int            _tempo;
            Clock          _restingClock;
            bool           _remote;
            bool           _consumeRemote;
            unsigned int   _startNote;
            unsigned int   _stopNote;
            int            _defaultInternal;
            int            _defaultExternal;
    };
}

#endif

---