Mercurial > audlegacy-plugins

comparison src/adplug/core/s3m.cxx @ 12:3da1b8942b8b trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn] - remove src/Input src/Output src/Effect src/General src/Visualization src/Container
author nenolod
date Mon, 18 Sep 2006 03:14:20 -0700
parents src/Input/adplug/core/s3m.cxx@13389e613d67
children cae46214b8bf
comparison
equal deleted inserted replaced
11:cff1d04026ae 12:3da1b8942b8b
1 /*
2 * Adplug - Replayer for many OPL2/OPL3 audio file formats.
3 * Copyright (C) 1999 - 2006 Simon Peter, <dn.tlp@gmx.net>, et al.
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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);
71 if(checkhead->kennung != 0x1a || checkhead->typ != 16
72 || checkhead->insnum > 99) {
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
95
96 // security check
97 if(header.ordnum > 256 || header.insnum > 99 || header.patnum > 99) {
98 fp.close(f);
99 return false;
100 }
101
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
295 // some commands reset the infobyte memory
296 switch(channel[realchan].fx) {
297 case 1:
298 case 2:
299 case 3:
300 case 20:
301 channel[realchan].info = pattern[pattnr][row][chan].info;
302 break;
303 }
304
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)
374 del = speed - 1; // speed compensation
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 }