filereadmultitrack.h

Go to the documentation of this file.

/*
 *   NiCMidi - A C++ Class Library for MIDI
 *
 *   Copyright (C) 2004  J.D. Koftinoff Software, Ltd.
 *   www.jdkoftinoff.com jeffk@jdkoftinoff.com
 *   Copyright (C) 2021, 2022  Nicola Cassetta
 *   https://github.com/ncassetta/NiCMidi
 *
 *   This file is part of NiCMidi.
 *
 *   NiCMidi is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as
 *   published by the Free Software Foundation, either version 3 of
 *   the License, or (at your option) any later version.
 *
 *   NiCMidi is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with NiCMidi. If not, see <http://www.gnu.org/licenses/>.
 */
 
 
 
 
#ifndef _NICMIDI_FILEREADMULTITRACK_H
#define _NICMIDI_FILEREADMULTITRACK_H
 
//#include "midi.h"
//#include "msg.h"
//#include "sysex.h"
#include "fileread.h"
#include "multitrack.h"
 
#include <string>
 
 
class MIDIFileReadMultiTrack : public MIDIFileEventHandler {
    public:
                                        MIDIFileReadMultiTrack (MIDIMultiTrack *tracks);
        virtual                         ~MIDIFileReadMultiTrack()       {}
 
//
// The possible events in a MIDI Files
//
            // these are all unused because globally managed by ChanMessage()
        virtual void                    mf_system_mode(const MIDITimedMessage &msg)     {}
        virtual void                    mf_note_on(const MIDITimedMessage &msg)         {}
        virtual void                    mf_note_off(const  MIDITimedMessage &msg)       {}
        virtual void                    mf_poly_after(const MIDITimedMessage &msg)      {}
        virtual void                    mf_bender(const MIDITimedMessage &msg)          {}
        virtual void                    mf_program(const MIDITimedMessage &msg)         {}
        virtual void                    mf_chan_after(const MIDITimedMessage &msg)      {}
        virtual void                    mf_control(const MIDITimedMessage &msg)         {}
 
            // these implement pure virtual methods in MIDIFile EventHandler
        virtual void                    mf_sysex(MIDIClockTime time, const MIDISystemExclusive &ex);
        virtual void                    mf_arbitrary(MIDIClockTime time, int len, unsigned char *data);
        virtual void                    mf_metamisc(MIDIClockTime time, int b1, int b2, unsigned char *ch);
        virtual void                    mf_meta16(MIDIClockTime time, int type, int b1, int b2);
        virtual void                    mf_smpte(MIDIClockTime time, int h, int m, int s, int f, int sf);
        virtual void                    mf_timesig(MIDIClockTime time, int a, int b, int c, int d);
        virtual void                    mf_tempo(MIDIClockTime time, int b1, int b2, int b3);
        virtual void                    mf_keysig(MIDIClockTime time, int sf, int majmin);
        virtual void                    mf_sqspecific(MIDIClockTime time, int len, unsigned char *data);
        virtual void                    mf_text(MIDIClockTime time, int type, int len, unsigned char *data);
        virtual void                    mf_eot(MIDIClockTime time);
 
//
// the following methods are to be overridden for your specific purpose
//
 
        virtual void                    mf_error(const char* err);
        virtual void                    mf_starttrack(int trk);
        virtual void                    mf_endtrack(int trk);
        virtual void                    mf_header(int format_, int ntrks_, int division_);
 
//
// Higher level dispatch functions
//
 
        virtual void                    UpdateTime(MIDIClockTime delta_time)    {}
        virtual void                    ChanMessage(const MIDITimedMessage &msg);
 
    protected:
 
        MIDIMultiTrack*                 multitrack;
        int                             cur_track;
        MIDIFileHeader                  header;
};
 
 
 
 
MIDIFileHeader&                         GetMIDIFileHeader(const char* filename);
MIDIFileHeader&                         GetMIDIFileHeader(const std::string& filename);
bool                                    LoadMIDIFile(const char* filename, MIDIMultiTrack* tracks,
                                                     MIDIFileHeader* const head = 0);
bool                                    LoadMIDIFile(const std::string& filename, MIDIMultiTrack* tracks,
                                                     MIDIFileHeader* const head = 0);
 
 
#endif