/home/pete/Work/TSE3.svn/tse3/src/tse3/plt/OSS.h

Go to the documentation of this file.

/*
 * @(#)plt/OSS.h 3.00 20 July 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_PLT_OSS_H
#define TSE3_PLT_OSS_H

#include "tse3/MidiScheduler.h"

#include <string>
#include <list>

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef TSE3_WITH_OSS
#include <sys/soundcard.h>
#else
    struct synth_info;
    struct midi_info;
#endif

namespace TSE3
{
    namespace Plt
    {
        class OSSMidiScheduler_SynthDevice;

        class OSSMidiScheduler : public MidiScheduler
        {
            public:

                OSSMidiScheduler();
                virtual ~OSSMidiScheduler();

                /**************************************************************
                 * OSS specific settings
                 *************************************************************/

                static std::string &fmPatchesDirectory();

                static void setFmPatchesDirectory(const std::string &dir);

                static std::string &gusPatchesDirectory();

                static void setGusPatchesDirectory(const std::string &dir);

            protected:

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

            private:

                OSSMidiScheduler(const OSSMidiScheduler &);
                OSSMidiScheduler &operator=(const OSSMidiScheduler &);

                void tx(const MidiCommand mc, bool outOfBand);

                unsigned char *running;     // running status values
                bool          *useRunning;  // does device support running sts?
                unsigned int   nosynths;    // no of internal synth devices
                unsigned int   nomidis;     // no of MIDI ports
                unsigned int   nodevices;   // nosynths + nomidis
                int            rate;        // sequencer timer rate (in ms)
                int            rateDivisor; // value to / timer by to get ms
                synth_info    *synthinfo;   // synth_info for each synth device
                midi_info     *midiinfo;    // midi_info for each MIDI device

                // In C we write SEQ_DEFINEBUF(1024); to set up some OSS magic
                // which creates a buffer that the OSS macros write data into.
                // However, this won't work in a class declaration. Sigh.
                // So this is how we do it.
                int            seqfd;          // file descfor /dev/sequencer
                unsigned char *_seqbuf;        // buffer for /dev/sequencer data
                int            _seqbuflen;     // size of _seqbuf
                int            _seqbufptr;     // pointer to end of pending data
                void           seqbuf_dump();  // wrts _seqbuf to /dev/sequencer
                void           seqbuf_clean(); // flushes the buffer

                // For a given port (TSE3 speak, same as OSS device number) is
                // it a synth or MIDI device?
                bool isSynth(unsigned int port) const
                {
                    return port < nosynths;
                }
                bool isMidi(unsigned int port) const
                {
                    return port >= nosynths;
                }

                // MIDI devices are easy to send data too, but the synths need
                // some special massaging. The classes held in this table do
                // just that.
                OSSMidiScheduler_SynthDevice **devices;

                // Output malarky
                Clock lastTxTime; // Time last MidiCommand was scheduled

                // Input malarky
                bool        input;   // true if there is an input command
                MidiCommand command; // if input is true, this holds the input
                Clock       time;    // time of the input MidiCommand

                void readInput();
        };
    }
}

#endif

---