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

Go to the documentation of this file.

/*
 * @(#)MidiFile.h 3.00 30 June 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_MIDIFILE_H
#define TSE3_MIDIFILE_H

#include "tse3/listen/MidiFile.h"

#include "tse3/Notifier.h"
#include "tse3/Playable.h"

#include <string>
#include <iosfwd>
#include <cstddef>

namespace TSE3
{
    class Song;
    class Track;
    class MidiFileImport;
    class Progress;

    class MidiFileImport : public Playable,
                           public Notifier<MidiFileImportListener>
    {
        public:

            MidiFileImport(const std::string &filename,
                           int                verbose = 0,
                           std::ostream      &out     = std::cout);
            ~MidiFileImport();

            Song *load(Progress *progress = 0);

            virtual PlayableIterator *iterator(Clock index);

            virtual Clock lastClock() const;

            friend class MidiFileImportIterator;

        private:

            void loadHeader();

            void loadMTrk(size_t &pos, Song *song, int mtrkNo);

            void loadMeta(size_t &pos, Song *song, Track *track,
                          int mtrkNo, Clock time, int &port,
                          Clock &end);

            int readFixed(size_t &pos, int length);

            int readVariable(size_t &pos);

            std::string   filename;
            int           verbose;
            std::ostream &out;

            unsigned char  *file;
            std::streampos  fileSize;

            int            filePPQN, fileFormat;        // set up by
            size_t         fileNoMTrks, fileHeaderSize; // loadHeader
            Clock          fileLastClock;               // set by the iterator
    };

    class MidiFileExport
    {
        public:

            MidiFileExport(int                format  = 1,
                           bool               compact = true,
                           int                verbose = 0,
                           std::ostream      &d_out = std::cout);
            ~MidiFileExport();

            void save(const std::string &filename, Song *song,
                      Progress *progress = 0);

            void save(std::ostream &out, Song *song, Progress *progress = 0);

            /*
             * Information about the MIDI file gleaned after having been saved.
             */

            int format() const { return _format; }

            size_t size() const { return _size; }

            int noMTrks() const { return _noMTrks; }

            bool compact() const { return _compact; }

        private:

            void writeMTrk(std::ostream &out, PlayableIterator *p,
                           const std::string &title = "");

            void writeMTrk_outputLoop(std::ostream &out, PlayableIterator *p);

            void writeMidiEvent(std::ostream &out, const MidiEvent &e);

            void writeMetaEvent(std::ostream &out, const MidiEvent &e);

            void writeFixed(std::ostream &out, int value, int length);

            void writeVariable(std::ostream &out, int value);

            void writeString(std::ostream &out, const std::string &str,
                             bool terminate = false);

            int           verbose;
            std::ostream &diag_out;
            int           _format;
            bool          _compact;

            /*
             * Things used in writeMTrk and lower
             */
            TSE3::Song    *song;
            size_t         _noMTrks;       // no of MTrks in the file so far
            std::streampos MTrkPos;        // where the current MTrk begins
            size_t         MTrkSize;       // whilst creating an MTrk, we have
                                           // to remember how big it is
            unsigned int   runningStatus;  // the current MIDI status byte
            Clock          lastEventClock; // use to calculate delta times
            size_t         _size;          // size of whole file
    };
}

#endif

---