Mercurial > audlegacy
annotate Plugins/Input/adplug/core/s3m.cpp @ 1376:c71e2ef2dcf4 trunk
[svn] Security fixes from AdPlug CVS (their July 7 commit shortly before the secunia announcement).
author | chainsaw |
---|---|
date | Sat, 08 Jul 2006 08:29:18 -0700 |
parents | 1cd8716972df |
children | f12d7e208b43 |
rev | line source |
---|---|
359 | 1 /* |
2 * Adplug - Replayer for many OPL2/OPL3 audio file formats. | |
843
1cd8716972df
[svn] Sync core with upstream. Also, rename plugin from AdPlug to AdLib synthesizer, by request of Giacomo.
chainsaw
parents:
359
diff
changeset
|
3 * Copyright (C) 1999 - 2006 Simon Peter, <dn.tlp@gmx.net>, et al. |
359 | 4 * |
5 * This library is free software; you can redistribute it and/or | |
6 * modify it under the terms of the GNU Lesser General Public | |
7 * License as published by the Free Software Foundation; either | |
8 * version 2.1 of the License, or (at your option) any later version. | |
9 * | |
10 * This library is distributed in the hope that it will be useful, | |
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
13 * Lesser General Public License for more details. | |
14 * | |
15 * You should have received a copy of the GNU Lesser General Public | |
16 * License along with this library; if not, write to the Free Software | |
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
18 * | |
19 * s3m.c - S3M Player by Simon Peter <dn.tlp@gmx.net> | |
20 * | |
21 * BUGS: | |
22 * Extra Fine Slides (EEx, FEx) & Fine Vibrato (Uxy) are inaccurate | |
23 */ | |
24 | |
25 #include "s3m.h" | |
26 | |
27 const char Cs3mPlayer::chnresolv[] = // S3M -> adlib channel conversion | |
28 {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,1,2,3,4,5,6,7,8,-1,-1,-1,-1,-1,-1,-1}; | |
29 | |
30 const unsigned short Cs3mPlayer::notetable[12] = // S3M adlib note table | |
31 {340,363,385,408,432,458,485,514,544,577,611,647}; | |
32 | |
33 const unsigned char Cs3mPlayer::vibratotab[32] = // vibrato rate table | |
34 {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1}; | |
35 | |
36 /*** public methods *************************************/ | |
37 | |
38 CPlayer *Cs3mPlayer::factory(Copl *newopl) | |
39 { | |
40 return new Cs3mPlayer(newopl); | |
41 } | |
42 | |
43 Cs3mPlayer::Cs3mPlayer(Copl *newopl): CPlayer(newopl) | |
44 { | |
45 int i,j,k; | |
46 | |
47 memset(pattern,255,sizeof(pattern)); | |
48 memset(orders,255,sizeof(orders)); | |
49 | |
50 for(i=0;i<99;i++) // setup pattern | |
51 for(j=0;j<64;j++) | |
52 for(k=0;k<32;k++) { | |
53 pattern[i][j][k].instrument = 0; | |
54 pattern[i][j][k].info = 0; | |
55 } | |
56 } | |
57 | |
58 bool Cs3mPlayer::load(const std::string &filename, const CFileProvider &fp) | |
59 { | |
60 binistream *f = fp.open(filename); if(!f) return false; | |
61 unsigned short insptr[99],pattptr[99]; | |
62 int i,row; | |
63 unsigned char bufval,bufval2; | |
64 unsigned short ppatlen; | |
65 s3mheader *checkhead; | |
66 bool adlibins=false; | |
67 | |
68 // file validation section | |
69 checkhead = new s3mheader; | |
70 load_header(f, checkhead); | |
1376
c71e2ef2dcf4
[svn] Security fixes from AdPlug CVS (their July 7 commit shortly before the secunia announcement).
chainsaw
parents:
843
diff
changeset
|
71 if(checkhead->kennung != 0x1a || checkhead->typ != 16 |
c71e2ef2dcf4
[svn] Security fixes from AdPlug CVS (their July 7 commit shortly before the secunia announcement).
chainsaw
parents:
843
diff
changeset
|
72 || checkhead->insnum > 99) { |
359 | 73 delete checkhead; fp.close(f); return false; |
74 } else | |
75 if(strncmp(checkhead->scrm,"SCRM",4)) { | |
76 delete checkhead; fp.close(f); return false; | |
77 } else { // is an adlib module? | |
78 f->seek(checkhead->ordnum, binio::Add); | |
79 for(i = 0; i < checkhead->insnum; i++) | |
80 insptr[i] = f->readInt(2); | |
81 for(i=0;i<checkhead->insnum;i++) { | |
82 f->seek(insptr[i]*16); | |
83 if(f->readInt(1) >= 2) { | |
84 adlibins = true; | |
85 break; | |
86 } | |
87 } | |
88 delete checkhead; | |
89 if(!adlibins) { fp.close(f); return false; } | |
90 } | |
91 | |
92 // load section | |
93 f->seek(0); // rewind for load | |
94 load_header(f, &header); // read header | |
1376
c71e2ef2dcf4
[svn] Security fixes from AdPlug CVS (their July 7 commit shortly before the secunia announcement).
chainsaw
parents:
843
diff
changeset
|
95 |
c71e2ef2dcf4
[svn] Security fixes from AdPlug CVS (their July 7 commit shortly before the secunia announcement).
chainsaw
parents:
843
diff
changeset
|
96 // security check |
c71e2ef2dcf4
[svn] Security fixes from AdPlug CVS (their July 7 commit shortly before the secunia announcement).
chainsaw
parents:
843
diff
changeset
|
97 if(header.ordnum > 256 || header.insnum > 99 || header.patnum > 99) { |
c71e2ef2dcf4
[svn] Security fixes from AdPlug CVS (their July 7 commit shortly before the secunia announcement).
chainsaw
parents:
843
diff
changeset
|
98 fp.close(f); |
c71e2ef2dcf4
[svn] Security fixes from AdPlug CVS (their July 7 commit shortly before the secunia announcement).
chainsaw
parents:
843
diff
changeset
|
99 return false; |
c71e2ef2dcf4
[svn] Security fixes from AdPlug CVS (their July 7 commit shortly before the secunia announcement).
chainsaw
parents:
843
diff
changeset
|
100 } |
c71e2ef2dcf4
[svn] Security fixes from AdPlug CVS (their July 7 commit shortly before the secunia announcement).
chainsaw
parents:
843
diff
changeset
|
101 |
359 | 102 for(i = 0; i < header.ordnum; i++) orders[i] = f->readInt(1); // read orders |
103 for(i = 0; i < header.insnum; i++) insptr[i] = f->readInt(2); // instrument parapointers | |
104 for(i = 0; i < header.patnum; i++) pattptr[i] = f->readInt(2); // pattern parapointers | |
105 | |
106 for(i=0;i<header.insnum;i++) { // load instruments | |
107 f->seek(insptr[i]*16); | |
108 inst[i].type = f->readInt(1); | |
109 f->readString(inst[i].filename, 15); | |
110 inst[i].d00 = f->readInt(1); inst[i].d01 = f->readInt(1); | |
111 inst[i].d02 = f->readInt(1); inst[i].d03 = f->readInt(1); | |
112 inst[i].d04 = f->readInt(1); inst[i].d05 = f->readInt(1); | |
113 inst[i].d06 = f->readInt(1); inst[i].d07 = f->readInt(1); | |
114 inst[i].d08 = f->readInt(1); inst[i].d09 = f->readInt(1); | |
115 inst[i].d0a = f->readInt(1); inst[i].d0b = f->readInt(1); | |
116 inst[i].volume = f->readInt(1); inst[i].dsk = f->readInt(1); | |
117 f->ignore(2); | |
118 inst[i].c2spd = f->readInt(4); | |
119 f->ignore(12); | |
120 f->readString(inst[i].name, 28); | |
121 f->readString(inst[i].scri, 4); | |
122 } | |
123 | |
124 for(i=0;i<header.patnum;i++) { // depack patterns | |
125 f->seek(pattptr[i]*16); | |
126 ppatlen = f->readInt(2); | |
127 unsigned long pattpos = f->pos(); | |
128 for(row=0;(row<64) && (pattpos-pattptr[i]*16<=ppatlen);row++) | |
129 do { | |
130 bufval = f->readInt(1); | |
131 if(bufval & 32) { | |
132 bufval2 = f->readInt(1); | |
133 pattern[i][row][bufval & 31].note = bufval2 & 15; | |
134 pattern[i][row][bufval & 31].oct = (bufval2 & 240) >> 4; | |
135 pattern[i][row][bufval & 31].instrument = f->readInt(1); | |
136 } | |
137 if(bufval & 64) | |
138 pattern[i][row][bufval & 31].volume = f->readInt(1); | |
139 if(bufval & 128) { | |
140 pattern[i][row][bufval & 31].command = f->readInt(1); | |
141 pattern[i][row][bufval & 31].info = f->readInt(1); | |
142 } | |
143 } while(bufval); | |
144 } | |
145 | |
146 fp.close(f); | |
147 rewind(0); | |
148 return true; // done | |
149 } | |
150 | |
151 bool Cs3mPlayer::update() | |
152 { | |
153 unsigned char pattbreak=0,donote; // remember vars | |
154 unsigned char pattnr,chan,row,info; // cache vars | |
155 signed char realchan; | |
156 | |
157 // effect handling (timer dependant) | |
158 for(realchan=0; realchan<9; realchan++) { | |
159 info = channel[realchan].info; // fill infobyte cache | |
160 switch(channel[realchan].fx) { | |
161 case 11: | |
162 case 12: if(channel[realchan].fx == 11) // dual command: H00 and Dxy | |
163 vibrato(realchan,channel[realchan].dualinfo); | |
164 else // dual command: G00 and Dxy | |
165 tone_portamento(realchan,channel[realchan].dualinfo); | |
166 case 4: if(info <= 0x0f) // volume slide down | |
167 if(channel[realchan].vol - info >= 0) | |
168 channel[realchan].vol -= info; | |
169 else | |
170 channel[realchan].vol = 0; | |
171 if((info & 0x0f) == 0) // volume slide up | |
172 if(channel[realchan].vol + (info >> 4) <= 63) | |
173 channel[realchan].vol += info >> 4; | |
174 else | |
175 channel[realchan].vol = 63; | |
176 setvolume(realchan); | |
177 break; | |
178 case 5: if(info == 0xf0 || info <= 0xe0) { // slide down | |
179 slide_down(realchan,info); | |
180 setfreq(realchan); | |
181 } | |
182 break; | |
183 case 6: if(info == 0xf0 || info <= 0xe0) { // slide up | |
184 slide_up(realchan,info); | |
185 setfreq(realchan); | |
186 } | |
187 break; | |
188 case 7: tone_portamento(realchan,channel[realchan].dualinfo); break; // tone portamento | |
189 case 8: vibrato(realchan,channel[realchan].dualinfo); break; // vibrato | |
190 case 10: channel[realchan].nextfreq = channel[realchan].freq; // arpeggio | |
191 channel[realchan].nextoct = channel[realchan].oct; | |
192 switch(channel[realchan].trigger) { | |
193 case 0: channel[realchan].freq = notetable[channel[realchan].note]; break; | |
194 case 1: if(channel[realchan].note + ((info & 0xf0) >> 4) < 12) | |
195 channel[realchan].freq = notetable[channel[realchan].note + ((info & 0xf0) >> 4)]; | |
196 else { | |
197 channel[realchan].freq = notetable[channel[realchan].note + ((info & 0xf0) >> 4) - 12]; | |
198 channel[realchan].oct++; | |
199 } | |
200 break; | |
201 case 2: if(channel[realchan].note + (info & 0x0f) < 12) | |
202 channel[realchan].freq = notetable[channel[realchan].note + (info & 0x0f)]; | |
203 else { | |
204 channel[realchan].freq = notetable[channel[realchan].note + (info & 0x0f) - 12]; | |
205 channel[realchan].oct++; | |
206 } | |
207 break; | |
208 } | |
209 if(channel[realchan].trigger < 2) | |
210 channel[realchan].trigger++; | |
211 else | |
212 channel[realchan].trigger = 0; | |
213 setfreq(realchan); | |
214 channel[realchan].freq = channel[realchan].nextfreq; | |
215 channel[realchan].oct = channel[realchan].nextoct; | |
216 break; | |
217 case 21: vibrato(realchan,(unsigned char) (info / 4)); break; // fine vibrato | |
218 } | |
219 } | |
220 | |
221 if(del) { // speed compensation | |
222 del--; | |
223 return !songend; | |
224 } | |
225 | |
226 // arrangement handling | |
227 pattnr = orders[ord]; | |
228 if(pattnr == 0xff || ord > header.ordnum) { // "--" end of song | |
229 songend = 1; // set end-flag | |
230 ord = 0; | |
231 pattnr = orders[ord]; | |
232 if(pattnr == 0xff) | |
233 return !songend; | |
234 } | |
235 if(pattnr == 0xfe) { // "++" skip marker | |
236 ord++; pattnr = orders[ord]; | |
237 } | |
238 | |
239 // play row | |
240 row = crow; // fill row cache | |
241 for(chan=0;chan<32;chan++) { | |
242 if(!(header.chanset[chan] & 128)) // resolve S3M -> AdLib channels | |
243 realchan = chnresolv[header.chanset[chan] & 127]; | |
244 else | |
245 realchan = -1; // channel disabled | |
246 if(realchan != -1) { // channel playable? | |
247 // set channel values | |
248 donote = 0; | |
249 if(pattern[pattnr][row][chan].note < 14) | |
250 // tone portamento | |
251 if(pattern[pattnr][row][chan].command == 7 || pattern[pattnr][row][chan].command == 12) { | |
252 channel[realchan].nextfreq = notetable[pattern[pattnr][row][chan].note]; | |
253 channel[realchan].nextoct = pattern[pattnr][row][chan].oct; | |
254 } else { // normal note | |
255 channel[realchan].note = pattern[pattnr][row][chan].note; | |
256 channel[realchan].freq = notetable[pattern[pattnr][row][chan].note]; | |
257 channel[realchan].oct = pattern[pattnr][row][chan].oct; | |
258 channel[realchan].key = 1; | |
259 donote = 1; | |
260 } | |
261 if(pattern[pattnr][row][chan].note == 14) { // key off (is 14 here, cause note is only first 4 bits) | |
262 channel[realchan].key = 0; | |
263 setfreq(realchan); | |
264 } | |
265 if((channel[realchan].fx != 8 && channel[realchan].fx != 11) && // vibrato begins | |
266 (pattern[pattnr][row][chan].command == 8 || pattern[pattnr][row][chan].command == 11)) { | |
267 channel[realchan].nextfreq = channel[realchan].freq; | |
268 channel[realchan].nextoct = channel[realchan].oct; | |
269 } | |
270 if(pattern[pattnr][row][chan].note >= 14) | |
271 if((channel[realchan].fx == 8 || channel[realchan].fx == 11) && // vibrato ends | |
272 (pattern[pattnr][row][chan].command != 8 && pattern[pattnr][row][chan].command != 11)) { | |
273 channel[realchan].freq = channel[realchan].nextfreq; | |
274 channel[realchan].oct = channel[realchan].nextoct; | |
275 setfreq(realchan); | |
276 } | |
277 if(pattern[pattnr][row][chan].instrument) { // set instrument | |
278 channel[realchan].inst = pattern[pattnr][row][chan].instrument - 1; | |
279 if(inst[channel[realchan].inst].volume < 64) | |
280 channel[realchan].vol = inst[channel[realchan].inst].volume; | |
281 else | |
282 channel[realchan].vol = 63; | |
283 if(pattern[pattnr][row][chan].command != 7) | |
284 donote = 1; | |
285 } | |
286 if(pattern[pattnr][row][chan].volume != 255) | |
287 if(pattern[pattnr][row][chan].volume < 64) // set volume | |
288 channel[realchan].vol = pattern[pattnr][row][chan].volume; | |
289 else | |
290 channel[realchan].vol = 63; | |
291 channel[realchan].fx = pattern[pattnr][row][chan].command; // set command | |
292 if(pattern[pattnr][row][chan].info) // set infobyte | |
293 channel[realchan].info = pattern[pattnr][row][chan].info; | |
294 | |
843
1cd8716972df
[svn] Sync core with upstream. Also, rename plugin from AdPlug to AdLib synthesizer, by request of Giacomo.
chainsaw
parents:
359
diff
changeset
|
295 // some commands reset the infobyte memory |
1cd8716972df
[svn] Sync core with upstream. Also, rename plugin from AdPlug to AdLib synthesizer, by request of Giacomo.
chainsaw
parents:
359
diff
changeset
|
296 switch(channel[realchan].fx) { |
1cd8716972df
[svn] Sync core with upstream. Also, rename plugin from AdPlug to AdLib synthesizer, by request of Giacomo.
chainsaw
parents:
359
diff
changeset
|
297 case 1: |
1cd8716972df
[svn] Sync core with upstream. Also, rename plugin from AdPlug to AdLib synthesizer, by request of Giacomo.
chainsaw
parents:
359
diff
changeset
|
298 case 2: |
1cd8716972df
[svn] Sync core with upstream. Also, rename plugin from AdPlug to AdLib synthesizer, by request of Giacomo.
chainsaw
parents:
359
diff
changeset
|
299 case 3: |
1cd8716972df
[svn] Sync core with upstream. Also, rename plugin from AdPlug to AdLib synthesizer, by request of Giacomo.
chainsaw
parents:
359
diff
changeset
|
300 case 20: |
1cd8716972df
[svn] Sync core with upstream. Also, rename plugin from AdPlug to AdLib synthesizer, by request of Giacomo.
chainsaw
parents:
359
diff
changeset
|
301 channel[realchan].info = pattern[pattnr][row][chan].info; |
1cd8716972df
[svn] Sync core with upstream. Also, rename plugin from AdPlug to AdLib synthesizer, by request of Giacomo.
chainsaw
parents:
359
diff
changeset
|
302 break; |
1cd8716972df
[svn] Sync core with upstream. Also, rename plugin from AdPlug to AdLib synthesizer, by request of Giacomo.
chainsaw
parents:
359
diff
changeset
|
303 } |
1cd8716972df
[svn] Sync core with upstream. Also, rename plugin from AdPlug to AdLib synthesizer, by request of Giacomo.
chainsaw
parents:
359
diff
changeset
|
304 |
359 | 305 // play note |
306 if(donote) | |
307 playnote(realchan); | |
308 if(pattern[pattnr][row][chan].volume != 255) // set volume | |
309 setvolume(realchan); | |
310 | |
311 // command handling (row dependant) | |
312 info = channel[realchan].info; // fill infobyte cache | |
313 switch(channel[realchan].fx) { | |
314 case 1: speed = info; break; // set speed | |
315 case 2: if(info <= ord) songend = 1; ord = info; crow = 0; pattbreak = 1; break; // jump to order | |
316 case 3: if(!pattbreak) { crow = info; ord++; pattbreak = 1; } break; // pattern break | |
317 case 4: if(info > 0xf0) // fine volume down | |
318 if(channel[realchan].vol - (info & 0x0f) >= 0) | |
319 channel[realchan].vol -= info & 0x0f; | |
320 else | |
321 channel[realchan].vol = 0; | |
322 if((info & 0x0f) == 0x0f && info >= 0x1f) // fine volume up | |
323 if(channel[realchan].vol + ((info & 0xf0) >> 4) <= 63) | |
324 channel[realchan].vol += (info & 0xf0) >> 4; | |
325 else | |
326 channel[realchan].vol = 63; | |
327 setvolume(realchan); | |
328 break; | |
329 case 5: if(info > 0xf0) { // fine slide down | |
330 slide_down(realchan,(unsigned char) (info & 0x0f)); | |
331 setfreq(realchan); | |
332 } | |
333 if(info > 0xe0 && info < 0xf0) { // extra fine slide down | |
334 slide_down(realchan,(unsigned char) ((info & 0x0f) / 4)); | |
335 setfreq(realchan); | |
336 } | |
337 break; | |
338 case 6: if(info > 0xf0) { // fine slide up | |
339 slide_up(realchan,(unsigned char) (info & 0x0f)); | |
340 setfreq(realchan); | |
341 } | |
342 if(info > 0xe0 && info < 0xf0) { // extra fine slide up | |
343 slide_up(realchan,(unsigned char) ((info & 0x0f) / 4)); | |
344 setfreq(realchan); | |
345 } | |
346 break; | |
347 case 7: // tone portamento | |
348 case 8: if((channel[realchan].fx == 7 || // vibrato (remember info for dual commands) | |
349 channel[realchan].fx == 8) && pattern[pattnr][row][chan].info) | |
350 channel[realchan].dualinfo = info; | |
351 break; | |
352 case 10: channel[realchan].trigger = 0; break; // arpeggio (set trigger) | |
353 case 19: if(info == 0xb0) // set loop start | |
354 loopstart = row; | |
355 if(info > 0xb0 && info <= 0xbf) // pattern loop | |
356 if(!loopcnt) { | |
357 loopcnt = info & 0x0f; | |
358 crow = loopstart; | |
359 pattbreak = 1; | |
360 } else | |
361 if(--loopcnt > 0) { | |
362 crow = loopstart; | |
363 pattbreak = 1; | |
364 } | |
365 if((info & 0xf0) == 0xe0) // patterndelay | |
366 del = speed * (info & 0x0f) - 1; | |
367 break; | |
368 case 20: tempo = info; break; // set tempo | |
369 } | |
370 } | |
371 } | |
372 | |
373 if(!del) | |
1376
c71e2ef2dcf4
[svn] Security fixes from AdPlug CVS (their July 7 commit shortly before the secunia announcement).
chainsaw
parents:
843
diff
changeset
|
374 del = speed - 1; // speed compensation |
359 | 375 if(!pattbreak) { // next row (only if no manual advance) |
376 crow++; | |
377 if(crow > 63) { | |
378 crow = 0; | |
379 ord++; | |
380 loopstart = 0; | |
381 } | |
382 } | |
383 | |
384 return !songend; // still playing | |
385 } | |
386 | |
387 void Cs3mPlayer::rewind(int subsong) | |
388 { | |
389 // set basic variables | |
390 songend = 0; ord = 0; crow = 0; tempo = header.it; | |
391 speed = header.is; del = 0; loopstart = 0; loopcnt = 0; | |
392 | |
393 memset(channel,0,sizeof(channel)); | |
394 | |
395 opl->init(); // reset OPL chip | |
396 opl->write(1,32); // Go to ym3812 mode | |
397 } | |
398 | |
399 std::string Cs3mPlayer::gettype() | |
400 { | |
401 char filever[5]; | |
402 | |
403 switch(header.cwtv) { // determine version number | |
404 case 0x1300: strcpy(filever,"3.00"); break; | |
405 case 0x1301: strcpy(filever,"3.01"); break; | |
406 case 0x1303: strcpy(filever,"3.03"); break; | |
407 case 0x1320: strcpy(filever,"3.20"); break; | |
408 default: strcpy(filever,"3.??"); | |
409 } | |
410 | |
411 return (std::string("Scream Tracker ") + filever); | |
412 } | |
413 | |
414 float Cs3mPlayer::getrefresh() | |
415 { | |
416 return (float) (tempo / 2.5); | |
417 } | |
418 | |
419 /*** private methods *************************************/ | |
420 | |
421 void Cs3mPlayer::load_header(binistream *f, s3mheader *h) | |
422 { | |
423 int i; | |
424 | |
425 f->readString(h->name, 28); | |
426 h->kennung = f->readInt(1); h->typ = f->readInt(1); | |
427 f->ignore(2); | |
428 h->ordnum = f->readInt(2); h->insnum = f->readInt(2); | |
429 h->patnum = f->readInt(2); h->flags = f->readInt(2); | |
430 h->cwtv = f->readInt(2); h->ffi = f->readInt(2); | |
431 f->readString(h->scrm, 4); | |
432 h->gv = f->readInt(1); h->is = f->readInt(1); h->it = f->readInt(1); | |
433 h->mv = f->readInt(1); h->uc = f->readInt(1); h->dp = f->readInt(1); | |
434 f->ignore(8); | |
435 h->special = f->readInt(2); | |
436 for(i = 0; i < 32; i++) h->chanset[i] = f->readInt(1); | |
437 } | |
438 | |
439 void Cs3mPlayer::setvolume(unsigned char chan) | |
440 { | |
441 unsigned char op = op_table[chan], insnr = channel[chan].inst; | |
442 | |
443 opl->write(0x43 + op,(int)(63-((63-(inst[insnr].d03 & 63))/63.0)*channel[chan].vol) + (inst[insnr].d03 & 192)); | |
444 if(inst[insnr].d0a & 1) | |
445 opl->write(0x40 + op,(int)(63-((63-(inst[insnr].d02 & 63))/63.0)*channel[chan].vol) + (inst[insnr].d02 & 192)); | |
446 } | |
447 | |
448 void Cs3mPlayer::setfreq(unsigned char chan) | |
449 { | |
450 opl->write(0xa0 + chan, channel[chan].freq & 255); | |
451 if(channel[chan].key) | |
452 opl->write(0xb0 + chan, ((channel[chan].freq & 768) >> 8) + (channel[chan].oct << 2) | 32); | |
453 else | |
454 opl->write(0xb0 + chan, ((channel[chan].freq & 768) >> 8) + (channel[chan].oct << 2)); | |
455 } | |
456 | |
457 void Cs3mPlayer::playnote(unsigned char chan) | |
458 { | |
459 unsigned char op = op_table[chan], insnr = channel[chan].inst; | |
460 | |
461 opl->write(0xb0 + chan, 0); // stop old note | |
462 | |
463 // set instrument data | |
464 opl->write(0x20 + op, inst[insnr].d00); | |
465 opl->write(0x23 + op, inst[insnr].d01); | |
466 opl->write(0x40 + op, inst[insnr].d02); | |
467 opl->write(0x43 + op, inst[insnr].d03); | |
468 opl->write(0x60 + op, inst[insnr].d04); | |
469 opl->write(0x63 + op, inst[insnr].d05); | |
470 opl->write(0x80 + op, inst[insnr].d06); | |
471 opl->write(0x83 + op, inst[insnr].d07); | |
472 opl->write(0xe0 + op, inst[insnr].d08); | |
473 opl->write(0xe3 + op, inst[insnr].d09); | |
474 opl->write(0xc0 + chan, inst[insnr].d0a); | |
475 | |
476 // set frequency & play | |
477 channel[chan].key = 1; | |
478 setfreq(chan); | |
479 } | |
480 | |
481 void Cs3mPlayer::slide_down(unsigned char chan, unsigned char amount) | |
482 { | |
483 if(channel[chan].freq - amount > 340) | |
484 channel[chan].freq -= amount; | |
485 else | |
486 if(channel[chan].oct > 0) { | |
487 channel[chan].oct--; | |
488 channel[chan].freq = 684; | |
489 } else | |
490 channel[chan].freq = 340; | |
491 } | |
492 | |
493 void Cs3mPlayer::slide_up(unsigned char chan, unsigned char amount) | |
494 { | |
495 if(channel[chan].freq + amount < 686) | |
496 channel[chan].freq += amount; | |
497 else | |
498 if(channel[chan].oct < 7) { | |
499 channel[chan].oct++; | |
500 channel[chan].freq = 341; | |
501 } else | |
502 channel[chan].freq = 686; | |
503 } | |
504 | |
505 void Cs3mPlayer::vibrato(unsigned char chan, unsigned char info) | |
506 { | |
507 unsigned char i,speed,depth; | |
508 | |
509 speed = info >> 4; | |
510 depth = (info & 0x0f) / 2; | |
511 | |
512 for(i=0;i<speed;i++) { | |
513 channel[chan].trigger++; | |
514 while(channel[chan].trigger >= 64) | |
515 channel[chan].trigger -= 64; | |
516 if(channel[chan].trigger >= 16 && channel[chan].trigger < 48) | |
517 slide_down(chan,(unsigned char) (vibratotab[channel[chan].trigger - 16] / (16-depth))); | |
518 if(channel[chan].trigger < 16) | |
519 slide_up(chan,(unsigned char) (vibratotab[channel[chan].trigger + 16] / (16-depth))); | |
520 if(channel[chan].trigger >= 48) | |
521 slide_up(chan,(unsigned char) (vibratotab[channel[chan].trigger - 48] / (16-depth))); | |
522 } | |
523 setfreq(chan); | |
524 } | |
525 | |
526 void Cs3mPlayer::tone_portamento(unsigned char chan, unsigned char info) | |
527 { | |
528 if(channel[chan].freq + (channel[chan].oct << 10) < channel[chan].nextfreq + | |
529 (channel[chan].nextoct << 10)) | |
530 slide_up(chan,info); | |
531 if(channel[chan].freq + (channel[chan].oct << 10) > channel[chan].nextfreq + | |
532 (channel[chan].nextoct << 10)) | |
533 slide_down(chan,info); | |
534 setfreq(chan); | |
535 } |