midiparser.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
 
#ifndef AUDIO_MIDIPARSER_H
#define AUDIO_MIDIPARSER_H
 
#include "common/scummsys.h"
#include "common/endian.h"
#include "common/stream.h"
 
#define AUDIO_MIDIPARSER_MAXIMUM_SUBTRACKS 35
 
class MidiDriver_BASE;
 
//
// Support entities
//
 
struct Tracker {
    struct SubtrackStatus {
        const byte * _playPos;        
        uint32 _lastEventTime;  
        uint32 _lastEventTick;  
        byte   _runningStatus;  
 
        void clear() {
            _playPos = nullptr;
            _lastEventTime = 0;
            _lastEventTick = 0;
            _runningStatus = 0;
        }
 
        void stopTracking() {
            _playPos = nullptr;
        }
 
        bool isTracking() const {
            return _playPos != nullptr;
        }
    };
 
    uint32 _playTime;      
    uint32 _playTick;      
    uint32 _lastEventTime; 
    uint32 _lastEventTick; 
    SubtrackStatus _subtracks[AUDIO_MIDIPARSER_MAXIMUM_SUBTRACKS];
 
    Tracker() { clear(); }
 
    void clear() {
        _playTime = 0;
        _playTick = 0;
        _lastEventTime = 0;
        _lastEventTick = 0;
 
        for (int i = 0; i < AUDIO_MIDIPARSER_MAXIMUM_SUBTRACKS; i++) {
            _subtracks[i].clear();
        }
    }
 
    bool isTracking() const {
        for (int i = 0; i < AUDIO_MIDIPARSER_MAXIMUM_SUBTRACKS; i++) {
            if (_subtracks[i].isTracking())
                return true;
        }
        return false;
    }
 
    bool isTracking(uint8 subtrack) const {
        assert(subtrack < AUDIO_MIDIPARSER_MAXIMUM_SUBTRACKS);
        return _subtracks[subtrack].isTracking();
    }
 
    void stopTracking() {
        for (int i = 0; i < AUDIO_MIDIPARSER_MAXIMUM_SUBTRACKS; i++) {
            _subtracks[i].stopTracking();
        }
    }
 
    void stopTracking(uint8 subtrack) {
        assert(subtrack < AUDIO_MIDIPARSER_MAXIMUM_SUBTRACKS);
        _subtracks[subtrack].stopTracking();
    }
};
 
struct EventInfo {
    const byte * start; 
    uint8  subtrack; 
    uint32 delta;    
    byte   event;    
    union {
        struct {
            byte param1; 
            byte param2; 
        } basic;
        struct {
            byte   type; 
            const byte * data; 
        } ext;
    };
    uint32 length; 
    bool   loop;   
    bool   noop;   
 
    byte channel() const { return event & 0x0F; } 
    byte command() const { return event >> 4; }   
 
    void clear() {
        start = nullptr;
        delta = 0;
        event = 0;
        basic.param1 = 0;
        basic.param2 = 0;
        ext.type = 0;
        ext.data = nullptr;
        length = 0;
        loop = false;
        noop = false;
    }
 
    EventInfo() : subtrack(0) { clear(); }
};
 
struct NoteTimer {
    byte channel;     
    byte note;        
    uint32 timeLeft; 
    NoteTimer() : channel(0), note(0), timeLeft(0) {}
};
 
 
 
 
//
// MidiParser declaration
//
 
class MidiParser {
protected:
    static const uint8 MAXIMUM_TRACKS = 120;
    static const uint8 MAXIMUM_SUBTRACKS = AUDIO_MIDIPARSER_MAXIMUM_SUBTRACKS;
 
    uint16    _activeNotes[128];   
    NoteTimer _hangingNotes[32];   
    byte      _hangingNotesCount; 
 
    MidiDriver_BASE *_driver;    
    uint32 _timerRate;     
    uint32 _ppqn;           
    uint32 _tempo;          
    uint32 _psecPerTick;  
    uint32 _sysExDelay;     
    bool   _autoLoop;       
    uint32 _loopStartPoint;   
    uint32 _loopEndPoint;     
    uint32 _loopStartPointMs; 
    uint32 _loopEndPointMs;   
    bool   _smartJump;      
    bool   _centerPitchWheelOnUnload;  
    bool   _sendSustainOffOnNotesOff;   
    bool   _disableAllNotesOffMidiEvents;   
    bool   _disableAutoStartPlayback;  
    const byte  *_tracks[MAXIMUM_TRACKS][MAXIMUM_SUBTRACKS]; 
    byte   _numTracks;     
    byte   _numSubtracks[MAXIMUM_TRACKS]; 
    byte   _activeTrack;   
 
    Tracker _position;      
    EventInfo *_nextEvent;  
    EventInfo _nextSubtrackEvents[MAXIMUM_SUBTRACKS]; 
    bool   _abortParse;    
    bool   _jumpingToTick; 
    bool   _doParse;       
    bool   _pause;         
 
    int8   _source;
 
protected:
    static uint32 readVLQ(const byte * &data);
    virtual void resetTracking();
    virtual void allNotesOff();
    virtual void parseNextEvent(EventInfo &info) = 0;
    virtual void determineNextEvent();
    virtual void rebaseTracking();
    virtual bool processEvent(const EventInfo &info, bool fireEvents = true);
 
    void activeNote(byte channel, byte note, bool active);
    void hangingNote(byte channel, byte note, uint32 ticksLeft, bool recycle = true);
    void hangAllActiveNotes();
 
    virtual void onTrackStart(uint8 track) { };
 
    virtual void sendToDriver(uint32 b);
    void sendToDriver(byte status, byte firstOp, byte secondOp) {
        sendToDriver(status | ((uint32)firstOp << 8) | ((uint32)secondOp << 16));
    }
    virtual void sendMetaEventToDriver(byte type, const byte *data, uint16 length);
 
    uint32 read4high(const byte * &data) {
        uint32 val = READ_BE_UINT32(data);
        data += 4;
        return val;
    }
 
    uint16 read2low(const byte * &data) {
        uint16 val = READ_LE_UINT16(data);
        data += 2;
        return val;
    }
 
public:
    enum {
        mpAutoLoop = 2,
 
        mpSmartJump = 3,
 
        mpCenterPitchWheelOnUnload = 4,
 
         mpSendSustainOffOnNotesOff = 5,
 
         mpDisableAllNotesOffMidiEvents = 6,
 
         mpDisableAutoStartPlayback = 7
    };
 
public:
    typedef void (*XMidiCallbackProc)(byte eventData, void *refCon);
 
    MidiParser(int8 source = -1);
    virtual ~MidiParser() { stopPlaying(); }
 
    virtual bool loadMusic(const byte *data, uint32 size) = 0;
    virtual void unloadMusic();
    virtual void property(int prop, int value);
    virtual int32 determineDataSize(Common::SeekableReadStream *stream) { return -1; };
 
    virtual void setMidiDriver(MidiDriver_BASE *driver) { _driver = driver; }
    void setTimerRate(uint32 rate) { _timerRate = rate; }
    virtual void setTempo(uint32 tempo);
    virtual void onTimer();
 
    bool isPlaying() const { return (_position.isTracking() && _doParse); }
    bool startPlaying();
    void stopPlaying();
    void pausePlaying();
    void resumePlaying();
 
    bool setTrack(int track);
    byte getActiveTrack() { return _activeTrack; }
    bool jumpToTick(uint32 tick, bool fireEvents = false, bool stopNotes = true, bool dontSendNoteOn = false);
    virtual bool hasJumpIndex(uint8 index) { return false; }
    virtual bool jumpToIndex(uint8 index, bool stopNotes = true) { return false; }
 
    void setLoopSection(uint32 startPoint, uint32 endPoint = 0);
    void setLoopSectionMicroseconds(uint32 startPoint, uint32 endPoint = 0);
    void clearLoopSection();
 
    uint32 getPPQN() { return _ppqn; }
    virtual uint32 getTick() { return _position._playTick; }
 
    static void defaultXMidiCallback(byte eventData, void *refCon);
 
    static MidiParser *createParser_SMF(int8 source = -1);
    static MidiParser *createParser_XMIDI(XMidiCallbackProc proc = defaultXMidiCallback, void *refCon = 0, int source = -1);
    static MidiParser *createParser_QT(int8 source = -1);
    static MidiParser *createParser_HMP(int8 source = -1);
    static void timerCallback(void *data) { ((MidiParser *)data)->onTimer(); }
};
#endif