2 * Adplug - Replayer for many OPL2/OPL3 audio file formats.
3 * Copyright (C) 1999 - 2006 Simon Peter, <dn.tlp@gmx.net>, et al.
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.
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.
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
19 * s3m.c - S3M Player by Simon Peter <dn.tlp@gmx.net>
22 * Extra Fine Slides (EEx, FEx) & Fine Vibrato (Uxy) are inaccurate
28 const char Cs3mPlayer::chnresolv[] = // S3M -> adlib channel conversion
29 {-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};
31 const unsigned short Cs3mPlayer::notetable[12] = // S3M adlib note table
32 {340,363,385,408,432,458,485,514,544,577,611,647};
34 const unsigned char Cs3mPlayer::vibratotab[32] = // vibrato rate table
35 {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};
37 /*** public methods *************************************/
39 CPlayer *Cs3mPlayer::factory(Copl *newopl)
41 return new Cs3mPlayer(newopl);
44 Cs3mPlayer::Cs3mPlayer(Copl *newopl): CPlayer(newopl)
48 memset(pattern,255,sizeof(pattern));
49 memset(orders,255,sizeof(orders));
51 for(i=0;i<99;i++) // setup pattern
54 pattern[i][j][k].instrument = 0;
55 pattern[i][j][k].info = 0;
59 bool Cs3mPlayer::load(const std::string &filename, const CFileProvider &fp)
61 binistream *f = fp.open(filename); if(!f) return false;
62 unsigned short insptr[99],pattptr[99];
64 unsigned char bufval,bufval2;
65 unsigned short ppatlen;
69 // file validation section
70 checkhead = new s3mheader;
71 load_header(f, checkhead);
72 if(checkhead->kennung != 0x1a || checkhead->typ != 16
73 || checkhead->insnum > 99) {
74 delete checkhead; fp.close(f); return false;
76 if(strncmp(checkhead->scrm,"SCRM",4)) {
77 delete checkhead; fp.close(f); return false;
78 } else { // is an adlib module?
79 f->seek(checkhead->ordnum, binio::Add);
80 for(i = 0; i < checkhead->insnum; i++)
81 insptr[i] = f->readInt(2);
82 for(i=0;i<checkhead->insnum;i++) {
83 f->seek(insptr[i]*16);
84 if(f->readInt(1) >= 2) {
90 if(!adlibins) { fp.close(f); return false; }
94 f->seek(0); // rewind for load
95 load_header(f, &header); // read header
98 if(header.ordnum > 256 || header.insnum > 99 || header.patnum > 99) {
103 for(i = 0; i < header.ordnum; i++) orders[i] = f->readInt(1); // read orders
104 for(i = 0; i < header.insnum; i++) insptr[i] = f->readInt(2); // instrument parapointers
105 for(i = 0; i < header.patnum; i++) pattptr[i] = f->readInt(2); // pattern parapointers
107 for(i=0;i<header.insnum;i++) { // load instruments
108 f->seek(insptr[i]*16);
109 inst[i].type = f->readInt(1);
110 f->readString(inst[i].filename, 15);
111 inst[i].d00 = f->readInt(1); inst[i].d01 = f->readInt(1);
112 inst[i].d02 = f->readInt(1); inst[i].d03 = f->readInt(1);
113 inst[i].d04 = f->readInt(1); inst[i].d05 = f->readInt(1);
114 inst[i].d06 = f->readInt(1); inst[i].d07 = f->readInt(1);
115 inst[i].d08 = f->readInt(1); inst[i].d09 = f->readInt(1);
116 inst[i].d0a = f->readInt(1); inst[i].d0b = f->readInt(1);
117 inst[i].volume = f->readInt(1); inst[i].dsk = f->readInt(1);
119 inst[i].c2spd = f->readInt(4);
121 f->readString(inst[i].name, 28);
122 f->readString(inst[i].scri, 4);
125 for(i=0;i<header.patnum;i++) { // depack patterns
126 f->seek(pattptr[i]*16);
127 ppatlen = f->readInt(2);
128 unsigned long pattpos = f->pos();
129 for(row=0;(row<64) && (pattpos-pattptr[i]*16<=ppatlen);row++)
131 bufval = f->readInt(1);
133 bufval2 = f->readInt(1);
134 pattern[i][row][bufval & 31].note = bufval2 & 15;
135 pattern[i][row][bufval & 31].oct = (bufval2 & 240) >> 4;
136 pattern[i][row][bufval & 31].instrument = f->readInt(1);
139 pattern[i][row][bufval & 31].volume = f->readInt(1);
141 pattern[i][row][bufval & 31].command = f->readInt(1);
142 pattern[i][row][bufval & 31].info = f->readInt(1);
152 bool Cs3mPlayer::update()
154 unsigned char pattbreak=0,donote; // remember vars
155 unsigned char pattnr,chan,row,info; // cache vars
156 signed char realchan;
158 // effect handling (timer dependant)
159 for(realchan=0; realchan<9; realchan++) {
160 info = channel[realchan].info; // fill infobyte cache
161 switch(channel[realchan].fx) {
163 case 12: if(channel[realchan].fx == 11) // dual command: H00 and Dxy
164 vibrato(realchan,channel[realchan].dualinfo);
165 else // dual command: G00 and Dxy
166 tone_portamento(realchan,channel[realchan].dualinfo);
167 case 4: if(info <= 0x0f) { // volume slide down
168 if(channel[realchan].vol - info >= 0)
169 channel[realchan].vol -= info;
171 channel[realchan].vol = 0;
173 if((info & 0x0f) == 0) { // volume slide up
174 if(channel[realchan].vol + (info >> 4) <= 63)
175 channel[realchan].vol += info >> 4;
177 channel[realchan].vol = 63;
181 case 5: if(info == 0xf0 || info <= 0xe0) { // slide down
182 slide_down(realchan,info);
186 case 6: if(info == 0xf0 || info <= 0xe0) { // slide up
187 slide_up(realchan,info);
191 case 7: tone_portamento(realchan,channel[realchan].dualinfo); break; // tone portamento
192 case 8: vibrato(realchan,channel[realchan].dualinfo); break; // vibrato
193 case 10: channel[realchan].nextfreq = channel[realchan].freq; // arpeggio
194 channel[realchan].nextoct = channel[realchan].oct;
195 switch(channel[realchan].trigger) {
196 case 0: channel[realchan].freq = notetable[channel[realchan].note]; break;
197 case 1: if(channel[realchan].note + ((info & 0xf0) >> 4) < 12)
198 channel[realchan].freq = notetable[channel[realchan].note + ((info & 0xf0) >> 4)];
200 channel[realchan].freq = notetable[channel[realchan].note + ((info & 0xf0) >> 4) - 12];
201 channel[realchan].oct++;
204 case 2: if(channel[realchan].note + (info & 0x0f) < 12)
205 channel[realchan].freq = notetable[channel[realchan].note + (info & 0x0f)];
207 channel[realchan].freq = notetable[channel[realchan].note + (info & 0x0f) - 12];
208 channel[realchan].oct++;
212 if(channel[realchan].trigger < 2)
213 channel[realchan].trigger++;
215 channel[realchan].trigger = 0;
217 channel[realchan].freq = channel[realchan].nextfreq;
218 channel[realchan].oct = channel[realchan].nextoct;
220 case 21: vibrato(realchan,(unsigned char) (info / 4)); break; // fine vibrato
224 if(del) { // speed compensation
229 // arrangement handling
230 pattnr = orders[ord];
231 if(pattnr == 0xff || ord > header.ordnum) { // "--" end of song
232 songend = 1; // set end-flag
234 pattnr = orders[ord];
238 if(pattnr == 0xfe) { // "++" skip marker
239 ord++; pattnr = orders[ord];
243 row = crow; // fill row cache
244 for(chan=0;chan<32;chan++) {
245 if(!(header.chanset[chan] & 128)) // resolve S3M -> AdLib channels
246 realchan = chnresolv[header.chanset[chan] & 127];
248 realchan = -1; // channel disabled
249 if(realchan != -1) { // channel playable?
250 // set channel values
252 if(pattern[pattnr][row][chan].note < 14) {
254 if(pattern[pattnr][row][chan].command == 7 || pattern[pattnr][row][chan].command == 12) {
255 channel[realchan].nextfreq = notetable[pattern[pattnr][row][chan].note];
256 channel[realchan].nextoct = pattern[pattnr][row][chan].oct;
257 } else { // normal note
258 channel[realchan].note = pattern[pattnr][row][chan].note;
259 channel[realchan].freq = notetable[pattern[pattnr][row][chan].note];
260 channel[realchan].oct = pattern[pattnr][row][chan].oct;
261 channel[realchan].key = 1;
265 if(pattern[pattnr][row][chan].note == 14) { // key off (is 14 here, cause note is only first 4 bits)
266 channel[realchan].key = 0;
269 if((channel[realchan].fx != 8 && channel[realchan].fx != 11) && // vibrato begins
270 (pattern[pattnr][row][chan].command == 8 || pattern[pattnr][row][chan].command == 11)) {
271 channel[realchan].nextfreq = channel[realchan].freq;
272 channel[realchan].nextoct = channel[realchan].oct;
274 if(pattern[pattnr][row][chan].note >= 14)
275 if((channel[realchan].fx == 8 || channel[realchan].fx == 11) && // vibrato ends
276 (pattern[pattnr][row][chan].command != 8 && pattern[pattnr][row][chan].command != 11)) {
277 channel[realchan].freq = channel[realchan].nextfreq;
278 channel[realchan].oct = channel[realchan].nextoct;
281 if(pattern[pattnr][row][chan].instrument) { // set instrument
282 channel[realchan].inst = pattern[pattnr][row][chan].instrument - 1;
283 if(inst[channel[realchan].inst].volume < 64)
284 channel[realchan].vol = inst[channel[realchan].inst].volume;
286 channel[realchan].vol = 63;
287 if(pattern[pattnr][row][chan].command != 7)
290 if(pattern[pattnr][row][chan].volume != 255) {
291 if(pattern[pattnr][row][chan].volume < 64) // set volume
292 channel[realchan].vol = pattern[pattnr][row][chan].volume;
294 channel[realchan].vol = 63;
296 channel[realchan].fx = pattern[pattnr][row][chan].command; // set command
297 if(pattern[pattnr][row][chan].info) // set infobyte
298 channel[realchan].info = pattern[pattnr][row][chan].info;
300 // some commands reset the infobyte memory
301 switch(channel[realchan].fx) {
306 channel[realchan].info = pattern[pattnr][row][chan].info;
313 if(pattern[pattnr][row][chan].volume != 255) // set volume
316 // command handling (row dependant)
317 info = channel[realchan].info; // fill infobyte cache
318 switch(channel[realchan].fx) {
319 case 1: speed = info; break; // set speed
320 case 2: if(info <= ord) songend = 1; ord = info; crow = 0; pattbreak = 1; break; // jump to order
321 case 3: if(!pattbreak) { crow = info; ord++; pattbreak = 1; } break; // pattern break
322 case 4: if(info > 0xf0) { // fine volume down
323 if(channel[realchan].vol - (info & 0x0f) >= 0)
324 channel[realchan].vol -= info & 0x0f;
326 channel[realchan].vol = 0;
328 if((info & 0x0f) == 0x0f && info >= 0x1f) { // fine volume up
329 if(channel[realchan].vol + ((info & 0xf0) >> 4) <= 63)
330 channel[realchan].vol += (info & 0xf0) >> 4;
332 channel[realchan].vol = 63;
336 case 5: if(info > 0xf0) { // fine slide down
337 slide_down(realchan,(unsigned char) (info & 0x0f));
340 if(info > 0xe0 && info < 0xf0) { // extra fine slide down
341 slide_down(realchan,(unsigned char) ((info & 0x0f) / 4));
345 case 6: if(info > 0xf0) { // fine slide up
346 slide_up(realchan,(unsigned char) (info & 0x0f));
349 if(info > 0xe0 && info < 0xf0) { // extra fine slide up
350 slide_up(realchan,(unsigned char) ((info & 0x0f) / 4));
354 case 7: // tone portamento
355 case 8: if((channel[realchan].fx == 7 || // vibrato (remember info for dual commands)
356 channel[realchan].fx == 8) && pattern[pattnr][row][chan].info)
357 channel[realchan].dualinfo = info;
359 case 10: channel[realchan].trigger = 0; break; // arpeggio (set trigger)
360 case 19: if(info == 0xb0) // set loop start
362 if(info > 0xb0 && info <= 0xbf) { // pattern loop
364 loopcnt = info & 0x0f;
373 if((info & 0xf0) == 0xe0) // patterndelay
374 del = speed * (info & 0x0f) - 1;
376 case 20: tempo = info; break; // set tempo
382 del = speed - 1; // speed compensation
383 if(!pattbreak) { // next row (only if no manual advance)
392 return !songend; // still playing
395 void Cs3mPlayer::rewind(int subsong)
397 // set basic variables
398 songend = 0; ord = 0; crow = 0; tempo = header.it;
399 speed = header.is; del = 0; loopstart = 0; loopcnt = 0;
401 memset(channel,0,sizeof(channel));
403 opl->init(); // reset OPL chip
404 opl->write(1,32); // Go to ym3812 mode
407 std::string Cs3mPlayer::gettype()
411 switch(header.cwtv) { // determine version number
412 case 0x1300: strcpy(filever,"3.00"); break;
413 case 0x1301: strcpy(filever,"3.01"); break;
414 case 0x1303: strcpy(filever,"3.03"); break;
415 case 0x1320: strcpy(filever,"3.20"); break;
416 default: strcpy(filever,"3.??");
419 return (std::string("Scream Tracker ") + filever);
422 float Cs3mPlayer::getrefresh()
424 return (float) (tempo / 2.5);
427 /*** private methods *************************************/
429 void Cs3mPlayer::load_header(binistream *f, s3mheader *h)
433 f->readString(h->name, 28);
434 h->kennung = f->readInt(1); h->typ = f->readInt(1);
436 h->ordnum = f->readInt(2); h->insnum = f->readInt(2);
437 h->patnum = f->readInt(2); h->flags = f->readInt(2);
438 h->cwtv = f->readInt(2); h->ffi = f->readInt(2);
439 f->readString(h->scrm, 4);
440 h->gv = f->readInt(1); h->is = f->readInt(1); h->it = f->readInt(1);
441 h->mv = f->readInt(1); h->uc = f->readInt(1); h->dp = f->readInt(1);
443 h->special = f->readInt(2);
444 for(i = 0; i < 32; i++) h->chanset[i] = f->readInt(1);
447 void Cs3mPlayer::setvolume(unsigned char chan)
449 unsigned char op = op_table[chan], insnr = channel[chan].inst;
451 opl->write(0x43 + op,(int)(63-((63-(inst[insnr].d03 & 63))/63.0)*channel[chan].vol) + (inst[insnr].d03 & 192));
452 if(inst[insnr].d0a & 1)
453 opl->write(0x40 + op,(int)(63-((63-(inst[insnr].d02 & 63))/63.0)*channel[chan].vol) + (inst[insnr].d02 & 192));
456 void Cs3mPlayer::setfreq(unsigned char chan)
458 opl->write(0xa0 + chan, channel[chan].freq & 255);
459 if(channel[chan].key)
460 opl->write(0xb0 + chan, (((channel[chan].freq & 768) >> 8) + (channel[chan].oct << 2)) | 32);
462 opl->write(0xb0 + chan, ((channel[chan].freq & 768) >> 8) + (channel[chan].oct << 2));
465 void Cs3mPlayer::playnote(unsigned char chan)
467 unsigned char op = op_table[chan], insnr = channel[chan].inst;
469 opl->write(0xb0 + chan, 0); // stop old note
471 // set instrument data
472 opl->write(0x20 + op, inst[insnr].d00);
473 opl->write(0x23 + op, inst[insnr].d01);
474 opl->write(0x40 + op, inst[insnr].d02);
475 opl->write(0x43 + op, inst[insnr].d03);
476 opl->write(0x60 + op, inst[insnr].d04);
477 opl->write(0x63 + op, inst[insnr].d05);
478 opl->write(0x80 + op, inst[insnr].d06);
479 opl->write(0x83 + op, inst[insnr].d07);
480 opl->write(0xe0 + op, inst[insnr].d08);
481 opl->write(0xe3 + op, inst[insnr].d09);
482 opl->write(0xc0 + chan, inst[insnr].d0a);
484 // set frequency & play
485 channel[chan].key = 1;
489 void Cs3mPlayer::slide_down(unsigned char chan, unsigned char amount)
491 if(channel[chan].freq - amount > 340)
492 channel[chan].freq -= amount;
494 if(channel[chan].oct > 0) {
496 channel[chan].freq = 684;
498 channel[chan].freq = 340;
501 void Cs3mPlayer::slide_up(unsigned char chan, unsigned char amount)
503 if(channel[chan].freq + amount < 686)
504 channel[chan].freq += amount;
506 if(channel[chan].oct < 7) {
508 channel[chan].freq = 341;
510 channel[chan].freq = 686;
513 void Cs3mPlayer::vibrato(unsigned char chan, unsigned char info)
515 unsigned char i,speed,depth;
518 depth = (info & 0x0f) / 2;
520 for(i=0;i<speed;i++) {
521 channel[chan].trigger++;
522 while(channel[chan].trigger >= 64)
523 channel[chan].trigger -= 64;
524 if(channel[chan].trigger >= 16 && channel[chan].trigger < 48)
525 slide_down(chan,(unsigned char) (vibratotab[channel[chan].trigger - 16] / (16-depth)));
526 if(channel[chan].trigger < 16)
527 slide_up(chan,(unsigned char) (vibratotab[channel[chan].trigger + 16] / (16-depth)));
528 if(channel[chan].trigger >= 48)
529 slide_up(chan,(unsigned char) (vibratotab[channel[chan].trigger - 48] / (16-depth)));
534 void Cs3mPlayer::tone_portamento(unsigned char chan, unsigned char info)
536 if(channel[chan].freq + (channel[chan].oct << 10) < channel[chan].nextfreq +
537 (channel[chan].nextoct << 10))
539 if(channel[chan].freq + (channel[chan].oct << 10) > channel[chan].nextfreq +
540 (channel[chan].nextoct << 10))
541 slide_down(chan,info);