1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
/* ScummVM - Scumm Interpreter
* Copyright (C) 2001-2003 The ScummVM project
*
* 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 2
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* $Header$
*
*/
#ifndef INCLUDED_MIDIPARSER
#define INCLUDED_MIDIPARSER
class MidiParser;
#include "common/scummsys.h"
class MidiDriver;
//////////////////////////////////////////////////
//
// Support entities
//
//////////////////////////////////////////////////
struct Tracker {
byte * _play_pos;
uint32 _play_time;
uint32 _play_tick;
uint32 _last_event_time;
uint32 _last_event_tick;
byte _running_status;
Tracker() { clear(); }
Tracker (const Tracker ©) :
_play_pos (copy._play_pos),
_play_time (copy._play_time),
_play_tick (copy._play_tick),
_last_event_time (copy._last_event_time),
_last_event_tick (copy._last_event_tick),
_running_status (copy._running_status)
{ }
void clear() {
_play_pos = 0;
_play_time = 0;
_play_tick = 0;
_last_event_time = 0;
_last_event_tick = 0;
_running_status = 0;
}
};
struct EventInfo {
byte * start; // Points to delta
uint32 delta;
byte event;
union {
struct {
byte param1;
byte param2;
} basic;
struct {
byte type; // Used for METAs
byte * data; // Used for SysEx and METAs
} ext;
};
uint32 length; // Used for SysEx and METAs, and note lengths
byte channel() { return event & 0x0F; }
byte command() { return event >> 4; }
};
struct NoteTimer {
byte channel;
byte note;
uint32 time_left;
NoteTimer() : channel(0), note(0), time_left(0) {}
};
//////////////////////////////////////////////////
//
// MidiParser declaration
//
//////////////////////////////////////////////////
class MidiParser {
private:
uint16 _active_notes[128]; // Each uint16 is a bit mask for channels that have that note on
NoteTimer _hanging_notes[32]; // Supports "smart" jump with notes still playing
byte _hanging_notes_count;
protected:
MidiDriver *_driver;
uint32 _timer_rate;
uint32 _ppqn; // Pulses (ticks) Per Quarter Note
uint32 _tempo; // Microseconds per quarter note
uint32 _psec_per_tick; // Microseconds per tick (_tempo / _ppqn)
bool _autoLoop; // For lightweight clients that don't monitor events
bool _smartJump; // Support smart expiration of hanging notes when jumping
byte * _tracks[32];
byte _num_tracks;
byte _active_track;
Tracker _position;
EventInfo _next_event;
bool _abort_parse; // If a jump or some other interruption occurs
protected:
static uint32 readVLQ (byte * &data);
virtual void resetTracking();
virtual void allNotesOff();
virtual void parseNextEvent (EventInfo &info) = 0;
void activeNote (byte channel, byte note, bool active);
void hangingNote (byte channel, byte note, uint32 ticks_left);
void hangAllActiveNotes();
// Multi-byte read helpers
uint32 read4high (byte * &data) {
uint32 val = 0;
int i;
for (i = 0; i < 4; ++i) val = (val << 8) | *data++;
return val;
}
uint16 read2low (byte * &data) {
uint16 val = 0;
int i;
for (i = 0; i < 2; ++i) val |= (*data++) << (i * 8);
return val;
}
public:
enum {
mpMalformedPitchBends = 1,
mpAutoLoop = 2,
mpSmartJump = 3
};
public:
MidiParser();
virtual ~MidiParser() { allNotesOff(); }
virtual bool loadMusic (byte *data, uint32 size) = 0;
virtual void unloadMusic();
virtual void property (int prop, int value);
void setMidiDriver (MidiDriver *driver) { _driver = driver; }
void setTimerRate (uint32 rate) { _timer_rate = rate; }
void setTempo (uint32 tempo);
void onTimer();
bool setTrack (int track);
bool jumpToTick (uint32 tick, bool fireEvents = false);
uint32 getTick() { return _position._play_tick; }
static MidiParser *createParser_SMF();
static MidiParser *createParser_XMIDI();
static void timerCallback (void *data) { ((MidiParser *) data)->onTimer(); }
};
#endif
|
