/home/pete/Work/TSE3.svn/tse3/src/tse3/ins/Instrument.h

Go to the documentation of this file.

/*
 * @(#)ins/Instrument.h 3.00 23 August 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_INS_INSTRUMENT_H
#define TSE3_INS_INSTRUMENT_H

#include <list>
#include <utility>
#include <vector>
#include <string>
#include <iosfwd>

namespace TSE3
{
    class Progress;

    namespace Ins
    {
        class PatchData;
        class ControlData;
        class RpnData;
        class NrpnData;
        class NoteData;

        inline int bankToLSB(int bank)
        {
            return (bank < 0) ? bank : bank & 0x7f;
        }

        inline int bankToMSB(int bank)
        {
            return (bank < 0) ? bank : bank >> 7;
        }

        inline int bankFromBytes(int bankLSB, int bankMSB)
        {
            return (bankLSB < 0 || bankMSB < 0) ? -1 : (bankMSB<<7) | bankLSB;
        }

        struct Voice : public std::pair<int, int>
        {
            Voice(int bank, int patch);

            Voice(int bankMSB, int bankLSB, int patch);

            int bank() const { return first; }

            int bankMSB()  const { return first >> 7; }

            int bankLSB()  const { return first & 0x7f; }

            int patch() const { return second; }

            int operator <(const Voice &v) const;
        };

        class Instrument
        {
            public:

                Instrument(const std::string &title,
                           const std::string &filename,
                           TSE3::Progress    *progess = 0);

                const std::string &title() const { return _title; }

                const std::string &filename() const { return _filename; }

                void setTitle(const std::string &title);

                int bankSelMethod() const { return _bankSelMethod; }

                void setBankSelMethod(int b);

                enum BankSelMethod
                {
                    BankSelMethod_Normal = 0,
                    BankSelMethod_MSB    = 1,
                    BankSelMethod_LSB    = 2,
                    BankSelMethod_Patch  = 3
                };

                bool useNotesAsController() const
                {
                    return _useNotesAsControllers;
                }

                void setUseNotesAsControllers(bool u);

                size_t numBanks() const { return banks.size(); }

                int bank(int index) const { return banks[index]; }

                int bank(const Voice &voice) const;

                int bankLSB(int index) const;

                int bankMSB(int index) const;

                PatchData *patch(int index) const { return patches[index]; }

                PatchData *patchForBank(int bank) const;

                PatchData *patchForBank(int bankLSB, int bankMSB) const;

                size_t numKeys() const { return keys.size(); }

                NoteData *key(size_t index) const { return keys[index].second; }

                NoteData *keyForVoice(const Voice &voice) const;

                size_t numDrums() const { return drumFlags.size(); }

                Voice drum(size_t index) const { return drumFlags[index]; }

                bool isDrum(const Voice &voice) const;

                ControlData *control() const { return _control; }

                RpnData *rpn() const { return _rpn; }

                NrpnData *nrpn() const { return _nrpn; }

                void write(std::ostream &out);

            private:

                void load(std::istream &in, TSE3::Progress *progress);

                void parseLine(const std::string &line, std::istream &in);

                std::string _title;
                std::string _filename;
                int         _bankSelMethod;
                bool        _useNotesAsControllers;

                std::vector<PatchData *>                    patches;
                std::vector<int>                            banks;

                std::vector<std::pair<Voice, NoteData *> >  keys;
                std::vector<Voice>                          drumFlags;

                ControlData                                *_control;
                RpnData                                    *_rpn;
                NrpnData                                   *_nrpn;
        };

        class InstrumentData
        {
            public:

                const std::string &title() const { return _title; }

                const std::string &name(size_t index) const
                {
                    std::string *s = _names[index];
                    return s ? *s : empty;
                }

                void write(std::ostream &out) const;

            protected:

                InstrumentData(std::string const &title,
                               std::string const &insHeading,
                               std::istream      &in);

                const std::string insHeading;

                void load(const std::string &secname, std::istream &in);

                std::string  _title;
                std::string *_names[128];

                static std::string empty;
        };

        class PatchData : public InstrumentData
        {
            public:
                PatchData(std::string const &title, std::istream &in)
                    : InstrumentData(title, ".Patch Names", in) {}
        };

        class NoteData : public InstrumentData
        {
            public:
                NoteData(std::string const &title, std::istream &in)
                    : InstrumentData(title, ".Note Names", in) {}
        };

        class ControlData : public InstrumentData
        {
            public:
                ControlData(std::string const &title, std::istream &in)
                    : InstrumentData(title, ".Controller Names", in) {}
        };

        class NrpnData : public InstrumentData
        {
            public:
                NrpnData(std::string const &title, std::istream &in)
                    : InstrumentData(title, ".NRPN Names", in) {}
        };

        class RpnData : public InstrumentData
        {
            public:
                RpnData(std::string const &title, std::istream &in)
                    : InstrumentData(title, ".RPN Names", in) {}
        };

        class CakewalkInstrumentFile
        {
            public:

                CakewalkInstrumentFile(const std::string &filename);

                const std::list<std::string>
                    &instruments(TSE3::Progress *progress = 0);

                Instrument *instrument(const std::string &title,
                                       TSE3::Progress *progress = 0);

            private:

                std::string            filename;
                bool                   searched_yet;
                std::list<std::string> ins;
        };
    }
}

#endif

---