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
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
/* 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 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#include "common/debug.h"
#include "common/util.h"
#include "common/textconsole.h"
#include "audio/mididrv.h"
#include "audio/midiparser.h"
namespace AGOS {
/**
* Simon 1 Demo version of MidiParser.
*/
class MidiParser_S1D : public MidiParser {
private:
byte *_data;
bool _noDelta;
struct Loop {
uint16 timer;
byte *start, *end;
} _loops[16];
uint32 readVLQ2(byte *&data);
void chainEvent(EventInfo &info);
protected:
void parseNextEvent(EventInfo &info);
void resetTracking();
public:
MidiParser_S1D() : _data(0), _noDelta(false) {}
bool loadMusic(byte *data, uint32 size);
};
uint32 MidiParser_S1D::readVLQ2(byte *&data) {
uint32 delta = 0;
// LE format VLQ, which is 2 bytes long at max.
delta = *data++;
if (delta & 0x80) {
delta &= 0x7F;
delta |= *data++ << 7;
}
return delta;
}
void MidiParser_S1D::chainEvent(EventInfo &info) {
// When we chain an event, we add up the old delta.
uint32 delta = info.delta;
parseNextEvent(info);
info.delta += delta;
}
void MidiParser_S1D::parseNextEvent(EventInfo &info) {
info.start = _position._playPos;
info.length = 0;
info.delta = _noDelta ? 0 : readVLQ2(_position._playPos);
_noDelta = false;
info.event = *_position._playPos++;
if (!(info.event & 0x80)) {
_noDelta = true;
info.event |= 0x80;
}
if (info.event == 0xFC) {
// This means End of Track.
// Rewrite in SMF (MIDI transmission) form.
info.event = 0xFF;
info.ext.type = 0x2F;
} else {
switch (info.command()) {
case 0x8: // note off
info.basic.param1 = *_position._playPos++;
info.basic.param2 = 0;
break;
case 0x9: // note on
info.basic.param1 = *_position._playPos++;
info.basic.param2 = *_position._playPos++;
// Rewrite note on events with velocity 0 as note off events.
// This is the actual meaning of this, but theoretically this
// should not need to be rewritten, since all MIDI devices should
// interpret it like that. On the other hand all our MidiParser
// implementations do it and there seems to be code in MidiParser
// which relies on this for tracking active notes.
if (info.basic.param2 == 0) {
info.event = info.channel() | 0x80;
}
break;
case 0xA: { // loop control
// In case the stop mode(?) is set to 0x80 this will stop the
// track over here.
const int16 loopIterations = int8(*_position._playPos++);
if (!loopIterations) {
_loops[info.channel()].start = _position._playPos;
} else {
if (!_loops[info.channel()].timer) {
if (_loops[info.channel()].start) {
_loops[info.channel()].timer = uint16(loopIterations);
_loops[info.channel()].end = _position._playPos;
// Go to the start of the loop
_position._playPos = _loops[info.channel()].start;
}
} else {
if (_loops[info.channel()].timer)
_position._playPos = _loops[info.channel()].start;
--_loops[info.channel()].timer;
}
}
// We need to read the next midi event here. Since we can not
// safely pass this event to the MIDI event processing.
chainEvent(info);
} break;
case 0xB: // auto stop marker(?)
// In case the stop mode(?) is set to 0x80 this will stop the
// track.
// We need to read the next midi event here. Since we can not
// safely pass this event to the MIDI event processing.
chainEvent(info);
break;
case 0xC: // program change
info.basic.param1 = *_position._playPos++;
info.basic.param2 = 0;
break;
case 0xD: // jump to loop end
if (_loops[info.channel()].end)
_position._playPos = _loops[info.channel()].end;
// We need to read the next midi event here. Since we can not
// safely pass this event to the MIDI event processing.
chainEvent(info);
break;
default:
// The original called some other function from here, which seems
// not to be MIDI related.
warning("MidiParser_S1D: default case %d", info.channel());
// We need to read the next midi event here. Since we can not
// safely pass this event to the MIDI event processing.
chainEvent(info);
break;
}
}
}
bool MidiParser_S1D::loadMusic(byte *data, uint32 size) {
unloadMusic();
// The original actually just ignores the first two bytes.
byte *pos = data;
if (*(pos++) != 0xFC)
debug(1, "Expected 0xFC header but found 0x%02X instead", (int) *pos);
pos += 1;
// And now we're at the actual data. Only one track.
_numTracks = 1;
_data = pos;
_tracks[0] = pos;
// Note that we assume the original data passed in
// will persist beyond this call, i.e. we do NOT
// copy the data to our own buffer. Take warning....
resetTracking();
setTempo(666667);
setTrack(0);
return true;
}
void MidiParser_S1D::resetTracking() {
MidiParser::resetTracking();
// The first event never contains any delta.
_noDelta = true;
memset(_loops, 0, sizeof(_loops));
}
MidiParser *MidiParser_createS1D() { return new MidiParser_S1D; }
} // End of namespace AGOS
|
