diff Plugins/Input/adplug/core/s3m.cpp @ 396:329a48431102 trunk

[svn] Really add S3M support back after receiving a convincing testcase.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Plugins/Input/adplug/core/s3m.cpp	Sat Jan 07 06:18:41 2006 -0800
@@ -0,0 +1,517 @@
+/*
+ * Adplug - Replayer for many OPL2/OPL3 audio file formats.
+ * Copyright (C) 1999 - 2003 Simon Peter, <[e-mail]>, et al.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * This library 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
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * s3m.c - S3M Player by Simon Peter <[e-mail]>
+ *
+ * BUGS:
+ * Extra Fine Slides (EEx, FEx) & Fine Vibrato (Uxy) are inaccurate
+ */
+
+#include "s3m.h"
+
+const char Cs3mPlayer::chnresolv[] =	// S3M -> adlib channel conversion
+	{-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};
+
+const unsigned short Cs3mPlayer::notetable[12] =		// S3M adlib note table
+			{340,363,385,408,432,458,485,514,544,577,611,647};
+
+const unsigned char Cs3mPlayer::vibratotab[32] =		// vibrato rate table
+			{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};
+
+/*** public methods *************************************/
+
+CPlayer *Cs3mPlayer::factory(Copl *newopl)
+{
+  return new Cs3mPlayer(newopl);
+}
+
+Cs3mPlayer::Cs3mPlayer(Copl *newopl): CPlayer(newopl)
+{
+	int			i,j,k;
+
+	memset(pattern,255,sizeof(pattern));
+	memset(orders,255,sizeof(orders));
+
+	for(i=0;i<99;i++)		// setup pattern
+		for(j=0;j<64;j++)
+			for(k=0;k<32;k++) {
+				pattern[i][j][k].instrument = 0;
+				pattern[i][j][k].info = 0;
+			}
+}
+
+bool Cs3mPlayer::load(const std::string &filename, const CFileProvider &fp)
+{
+        binistream *f = fp.open(filename); if(!f) return false;
+	unsigned short	insptr[99],pattptr[99];
+	int		i,row;
+	unsigned char	bufval,bufval2;
+	unsigned short	ppatlen;
+	s3mheader	*checkhead;
+	bool		adlibins=false;
+
+	// file validation section
+	checkhead = new s3mheader;
+	load_header(f, checkhead);
+	if((checkhead->kennung != 0x1a) || (checkhead->typ != 16)) {
+		delete checkhead; fp.close(f); return false;
+	} else
+		if(strncmp(checkhead->scrm,"SCRM",4)) {
+			delete checkhead; fp.close(f); return false;
+		} else {	// is an adlib module?
+             	        f->seek(checkhead->ordnum, binio::Add);
+			for(i = 0; i < checkhead->insnum; i++)
+			  insptr[i] = f->readInt(2);
+			for(i=0;i<checkhead->insnum;i++) {
+				f->seek(insptr[i]*16);
+				if(f->readInt(1) >= 2) {
+					adlibins = true;
+					break;
+				}
+			}
+			delete checkhead;
+			if(!adlibins) { fp.close(f); return false; }
+		}
+
+	// load section
+	f->seek(0);	// rewind for load
+	load_header(f, &header);			// read header
+	for(i = 0; i < header.ordnum; i++) orders[i] = f->readInt(1);	// read orders
+	for(i = 0; i < header.insnum; i++) insptr[i] = f->readInt(2);	// instrument parapointers
+	for(i = 0; i < header.patnum; i++) pattptr[i] = f->readInt(2);	// pattern parapointers
+
+	for(i=0;i<header.insnum;i++) {	// load instruments
+		f->seek(insptr[i]*16);
+		inst[i].type = f->readInt(1);
+		f->readString(inst[i].filename, 15);
+		inst[i].d00 = f->readInt(1); inst[i].d01 = f->readInt(1);
+		inst[i].d02 = f->readInt(1); inst[i].d03 = f->readInt(1);
+		inst[i].d04 = f->readInt(1); inst[i].d05 = f->readInt(1);
+		inst[i].d06 = f->readInt(1); inst[i].d07 = f->readInt(1);
+		inst[i].d08 = f->readInt(1); inst[i].d09 = f->readInt(1);
+		inst[i].d0a = f->readInt(1); inst[i].d0b = f->readInt(1);
+		inst[i].volume = f->readInt(1); inst[i].dsk = f->readInt(1);
+		f->ignore(2);
+		inst[i].c2spd = f->readInt(4);
+		f->ignore(12);
+		f->readString(inst[i].name, 28);
+		f->readString(inst[i].scri, 4);
+	}
+
+	for(i=0;i<header.patnum;i++) {	// depack patterns
+		f->seek(pattptr[i]*16);
+		ppatlen = f->readInt(2);
+		unsigned long pattpos = f->pos();
+		for(row=0;(row<64) && (pattpos-pattptr[i]*16<=ppatlen);row++)
+			do {
+            		        bufval = f->readInt(1);
+				if(bufval & 32) {
+				        bufval2 = f->readInt(1);
+					pattern[i][row][bufval & 31].note = bufval2 & 15;
+					pattern[i][row][bufval & 31].oct = (bufval2 & 240) >> 4;
+					pattern[i][row][bufval & 31].instrument = f->readInt(1);
+				}
+				if(bufval & 64)
+				        pattern[i][row][bufval & 31].volume = f->readInt(1);
+				if(bufval & 128) {
+				        pattern[i][row][bufval & 31].command = f->readInt(1);
+					pattern[i][row][bufval & 31].info = f->readInt(1);
+				}
+			} while(bufval);
+	}
+
+	fp.close(f);
+	rewind(0);
+	return true;		// done
+}
+
+bool Cs3mPlayer::update()
+{
+	unsigned char	pattbreak=0,donote;		// remember vars
+	unsigned char	pattnr,chan,row,info;	// cache vars
+	signed char		realchan;
+
+	// effect handling (timer dependant)
+	for(realchan=0; realchan<9; realchan++) {
+		info = channel[realchan].info;	// fill infobyte cache
+		switch(channel[realchan].fx) {
+		case 11:
+		case 12: if(channel[realchan].fx == 11)								// dual command: H00 and Dxy
+					 vibrato(realchan,channel[realchan].dualinfo);
+				 else															// dual command: G00 and Dxy
+					 tone_portamento(realchan,channel[realchan].dualinfo);
+		case 4: if(info <= 0x0f)												// volume slide down
+					if(channel[realchan].vol - info >= 0)
+						channel[realchan].vol -= info;
+					else
+						channel[realchan].vol = 0;
+				if((info & 0x0f) == 0)											// volume slide up
+					if(channel[realchan].vol + (info >> 4) <= 63)
+						channel[realchan].vol += info >> 4;
+					else
+						channel[realchan].vol = 63;
+				setvolume(realchan);
+				break;
+		case 5: if(info == 0xf0 || info <= 0xe0) {								// slide down
+					slide_down(realchan,info);
+					setfreq(realchan);
+				}
+				break;
+		case 6: if(info == 0xf0 || info <= 0xe0) {								// slide up
+					slide_up(realchan,info);
+					setfreq(realchan);
+				}
+				break;
+		case 7: tone_portamento(realchan,channel[realchan].dualinfo); break;	// tone portamento
+		case 8: vibrato(realchan,channel[realchan].dualinfo); break;		// vibrato
+		case 10: channel[realchan].nextfreq = channel[realchan].freq;	// arpeggio
+				 channel[realchan].nextoct = channel[realchan].oct;
+				 switch(channel[realchan].trigger) {
+				 case 0: channel[realchan].freq = notetable[channel[realchan].note]; break;
+				 case 1: if(channel[realchan].note + ((info & 0xf0) >> 4) < 12)
+							 channel[realchan].freq = notetable[channel[realchan].note + ((info & 0xf0) >> 4)];
+						 else {
+							 channel[realchan].freq = notetable[channel[realchan].note + ((info & 0xf0) >> 4) - 12];
+							 channel[realchan].oct++;
+						 }
+						 break;
+				 case 2: if(channel[realchan].note + (info & 0x0f) < 12)
+							 channel[realchan].freq = notetable[channel[realchan].note + (info & 0x0f)];
+						 else {
+							 channel[realchan].freq = notetable[channel[realchan].note + (info & 0x0f) - 12];
+							 channel[realchan].oct++;
+						 }
+						 break;
+				 }
+				 if(channel[realchan].trigger < 2)
+					 channel[realchan].trigger++;
+				 else
+					 channel[realchan].trigger = 0;
+				 setfreq(realchan);
+				 channel[realchan].freq = channel[realchan].nextfreq;
+				 channel[realchan].oct = channel[realchan].nextoct;
+				 break;
+		case 21: vibrato(realchan,(unsigned char) (info / 4)); break;		// fine vibrato
+		}
+	}
+
+	if(del) {		// speed compensation
+		del--;
+		return !songend;
+	}
+
+	// arrangement handling
+	pattnr = orders[ord];
+	if(pattnr == 0xff || ord > header.ordnum) {	// "--" end of song
+		songend = 1;				// set end-flag
+		ord = 0;
+		pattnr = orders[ord];
+		if(pattnr == 0xff)
+			return !songend;
+	}
+	if(pattnr == 0xfe) {		// "++" skip marker
+		ord++; pattnr = orders[ord];
+	}
+
+	// play row
+	row = crow;	// fill row cache
+	for(chan=0;chan<32;chan++) {
+		if(!(header.chanset[chan] & 128))		// resolve S3M -> AdLib channels
+			realchan = chnresolv[header.chanset[chan] & 127];
+		else
+			realchan = -1;		// channel disabled
+		if(realchan != -1) {	// channel playable?
+			// set channel values
+			donote = 0;
+			if(pattern[pattnr][row][chan].note < 14)
+				// tone portamento
+				if(pattern[pattnr][row][chan].command == 7 || pattern[pattnr][row][chan].command == 12) {
+					channel[realchan].nextfreq = notetable[pattern[pattnr][row][chan].note];
+					channel[realchan].nextoct = pattern[pattnr][row][chan].oct;
+				} else {											// normal note
+					channel[realchan].note = pattern[pattnr][row][chan].note;
+					channel[realchan].freq = notetable[pattern[pattnr][row][chan].note];
+					channel[realchan].oct = pattern[pattnr][row][chan].oct;
+					channel[realchan].key = 1;
+					donote = 1;
+				}
+			if(pattern[pattnr][row][chan].note == 14) {	// key off (is 14 here, cause note is only first 4 bits)
+				channel[realchan].key = 0;
+				setfreq(realchan);
+			}
+			if((channel[realchan].fx != 8 && channel[realchan].fx != 11) &&		// vibrato begins
+				(pattern[pattnr][row][chan].command == 8 || pattern[pattnr][row][chan].command == 11)) {
+				channel[realchan].nextfreq = channel[realchan].freq;
+				channel[realchan].nextoct = channel[realchan].oct;
+			}
+			if(pattern[pattnr][row][chan].note >= 14)
+				if((channel[realchan].fx == 8 || channel[realchan].fx == 11) &&	// vibrato ends
+					(pattern[pattnr][row][chan].command != 8 && pattern[pattnr][row][chan].command != 11)) {
+					channel[realchan].freq = channel[realchan].nextfreq;
+					channel[realchan].oct = channel[realchan].nextoct;
+					setfreq(realchan);
+				}
+			if(pattern[pattnr][row][chan].instrument) {	// set instrument
+				channel[realchan].inst = pattern[pattnr][row][chan].instrument - 1;
+				if(inst[channel[realchan].inst].volume < 64)
+					channel[realchan].vol = inst[channel[realchan].inst].volume;
+				else
+					channel[realchan].vol = 63;
+				if(pattern[pattnr][row][chan].command != 7)
+					donote = 1;
+			}
+			if(pattern[pattnr][row][chan].volume != 255)
+				if(pattern[pattnr][row][chan].volume < 64)	// set volume
+					channel[realchan].vol = pattern[pattnr][row][chan].volume;
+				else
+					channel[realchan].vol = 63;
+			channel[realchan].fx = pattern[pattnr][row][chan].command;	// set command
+			if(pattern[pattnr][row][chan].info)			// set infobyte
+				channel[realchan].info = pattern[pattnr][row][chan].info;
+
+			// play note
+			if(donote)
+				playnote(realchan);
+			if(pattern[pattnr][row][chan].volume != 255)	// set volume
+				setvolume(realchan);
+
+			// command handling (row dependant)
+			info = channel[realchan].info;	// fill infobyte cache
+			switch(channel[realchan].fx) {
+			case 1: speed = info; break;							// set speed
+			case 2: if(info <= ord) songend = 1; ord = info; crow = 0; pattbreak = 1; break;	// jump to order
+			case 3: if(!pattbreak) { crow = info; ord++; pattbreak = 1; } break;	// pattern break
+			case 4: if(info > 0xf0)										// fine volume down
+						if(channel[realchan].vol - (info & 0x0f) >= 0)
+							channel[realchan].vol -= info & 0x0f;
+						else
+							channel[realchan].vol = 0;
+					if((info & 0x0f) == 0x0f && info >= 0x1f)			// fine volume up
+						if(channel[realchan].vol + ((info & 0xf0) >> 4) <= 63)
+							channel[realchan].vol += (info & 0xf0) >> 4;
+						else
+							channel[realchan].vol = 63;
+					setvolume(realchan);
+					break;
+			case 5: if(info > 0xf0)	{									// fine slide down
+						slide_down(realchan,(unsigned char) (info & 0x0f));
+						setfreq(realchan);
+					}
+					if(info > 0xe0 && info < 0xf0) {					// extra fine slide down
+						slide_down(realchan,(unsigned char) ((info & 0x0f) / 4));
+						setfreq(realchan);
+					}
+					break;
+			case 6: if(info > 0xf0) {									// fine slide up
+						slide_up(realchan,(unsigned char) (info & 0x0f));
+						setfreq(realchan);
+					}
+					if(info > 0xe0 && info < 0xf0) {					// extra fine slide up
+						slide_up(realchan,(unsigned char) ((info & 0x0f) / 4));
+						setfreq(realchan);
+					}
+					break;
+			case 7:														// tone portamento
+			case 8:	if((channel[realchan].fx == 7 ||				// vibrato (remember info for dual commands)
+					 channel[realchan].fx == 8) && pattern[pattnr][row][chan].info)
+						channel[realchan].dualinfo = info;
+					break;
+			case 10: channel[realchan].trigger = 0; break;			// arpeggio (set trigger)
+			case 19: if(info == 0xb0)									// set loop start
+						loopstart = row;
+					 if(info > 0xb0 && info <= 0xbf)					// pattern loop
+						if(!loopcnt) {
+							loopcnt = info & 0x0f;
+							crow = loopstart;
+							pattbreak = 1;
+						} else
+							if(--loopcnt > 0) {
+								crow = loopstart;
+								pattbreak = 1;
+							}
+					 if((info & 0xf0) == 0xe0)							// patterndelay
+						 del = speed * (info & 0x0f) - 1;
+					 break;
+			case 20: tempo = info; break;							// set tempo
+			}
+		}
+	}
+
+	if(!del)
+		del = speed - 1;// speed compensation
+	if(!pattbreak) {			// next row (only if no manual advance)
+		crow++;
+		if(crow > 63) {
+			crow = 0;
+			ord++;
+			loopstart = 0;
+		}
+	}
+
+	return !songend;		// still playing
+}
+
+void Cs3mPlayer::rewind(int subsong)
+{
+	// set basic variables
+	songend = 0; ord = 0; crow = 0; tempo = header.it;
+	speed = header.is; del = 0; loopstart = 0; loopcnt = 0;
+
+	memset(channel,0,sizeof(channel));
+
+	opl->init();				// reset OPL chip
+	opl->write(1,32);			// Go to ym3812 mode
+}
+
+std::string Cs3mPlayer::gettype()
+{
+	char filever[5];
+
+	switch(header.cwtv) {		// determine version number
+	case 0x1300: strcpy(filever,"3.00"); break;
+	case 0x1301: strcpy(filever,"3.01"); break;
+	case 0x1303: strcpy(filever,"3.03"); break;
+	case 0x1320: strcpy(filever,"3.20"); break;
+	default: strcpy(filever,"3.??");
+	}
+
+	return (std::string("Scream Tracker ") + filever);
+}
+
+float Cs3mPlayer::getrefresh()
+{
+	return (float) (tempo / 2.5);
+}
+
+/*** private methods *************************************/
+
+void Cs3mPlayer::load_header(binistream *f, s3mheader *h)
+{
+  int i;
+
+  f->readString(h->name, 28);
+  h->kennung = f->readInt(1); h->typ = f->readInt(1);
+  f->ignore(2);
+  h->ordnum = f->readInt(2); h->insnum = f->readInt(2);
+  h->patnum = f->readInt(2); h->flags = f->readInt(2);
+  h->cwtv = f->readInt(2); h->ffi = f->readInt(2);
+  f->readString(h->scrm, 4);
+  h->gv = f->readInt(1); h->is = f->readInt(1); h->it = f->readInt(1);
+  h->mv = f->readInt(1); h->uc = f->readInt(1); h->dp = f->readInt(1);
+  f->ignore(8);
+  h->special = f->readInt(2);
+  for(i = 0; i < 32; i++) h->chanset[i] = f->readInt(1);
+}
+
+void Cs3mPlayer::setvolume(unsigned char chan)
+{
+	unsigned char op = op_table[chan], insnr = channel[chan].inst;
+
+	opl->write(0x43 + op,(int)(63-((63-(inst[insnr].d03 & 63))/63.0)*channel[chan].vol) + (inst[insnr].d03 & 192));
+	if(inst[insnr].d0a & 1)
+		opl->write(0x40 + op,(int)(63-((63-(inst[insnr].d02 & 63))/63.0)*channel[chan].vol) + (inst[insnr].d02 & 192));
+}
+
+void Cs3mPlayer::setfreq(unsigned char chan)
+{
+	opl->write(0xa0 + chan, channel[chan].freq & 255);
+	if(channel[chan].key)
+		opl->write(0xb0 + chan, ((channel[chan].freq & 768) >> 8) + (channel[chan].oct << 2) | 32);
+	else
+		opl->write(0xb0 + chan, ((channel[chan].freq & 768) >> 8) + (channel[chan].oct << 2));
+}
+
+void Cs3mPlayer::playnote(unsigned char chan)
+{
+	unsigned char op = op_table[chan], insnr = channel[chan].inst;
+
+	opl->write(0xb0 + chan, 0);	// stop old note
+
+	// set instrument data
+	opl->write(0x20 + op, inst[insnr].d00);
+	opl->write(0x23 + op, inst[insnr].d01);
+	opl->write(0x40 + op, inst[insnr].d02);
+	opl->write(0x43 + op, inst[insnr].d03);
+	opl->write(0x60 + op, inst[insnr].d04);
+	opl->write(0x63 + op, inst[insnr].d05);
+	opl->write(0x80 + op, inst[insnr].d06);
+	opl->write(0x83 + op, inst[insnr].d07);
+	opl->write(0xe0 + op, inst[insnr].d08);
+	opl->write(0xe3 + op, inst[insnr].d09);
+	opl->write(0xc0 + chan, inst[insnr].d0a);
+
+	// set frequency & play
+	channel[chan].key = 1;
+	setfreq(chan);
+}
+
+void Cs3mPlayer::slide_down(unsigned char chan, unsigned char amount)
+{
+	if(channel[chan].freq - amount > 340)
+		channel[chan].freq -= amount;
+	else
+		if(channel[chan].oct > 0) {
+			channel[chan].oct--;
+			channel[chan].freq = 684;
+		} else
+			channel[chan].freq = 340;
+}
+
+void Cs3mPlayer::slide_up(unsigned char chan, unsigned char amount)
+{
+	if(channel[chan].freq + amount < 686)
+		channel[chan].freq += amount;
+	else
+		if(channel[chan].oct < 7) {
+			channel[chan].oct++;
+			channel[chan].freq = 341;
+		} else
+			channel[chan].freq = 686;
+}
+
+void Cs3mPlayer::vibrato(unsigned char chan, unsigned char info)
+{
+	unsigned char i,speed,depth;
+
+	speed = info >> 4;
+	depth = (info & 0x0f) / 2;
+
+	for(i=0;i<speed;i++) {
+		channel[chan].trigger++;
+		while(channel[chan].trigger >= 64)
+			channel[chan].trigger -= 64;
+		if(channel[chan].trigger >= 16 && channel[chan].trigger < 48)
+			slide_down(chan,(unsigned char) (vibratotab[channel[chan].trigger - 16] / (16-depth)));
+		if(channel[chan].trigger < 16)
+			slide_up(chan,(unsigned char) (vibratotab[channel[chan].trigger + 16] / (16-depth)));
+		if(channel[chan].trigger >= 48)
+			slide_up(chan,(unsigned char) (vibratotab[channel[chan].trigger - 48] / (16-depth)));
+	}
+	setfreq(chan);
+}
+
+void Cs3mPlayer::tone_portamento(unsigned char chan, unsigned char info)
+{
+	if(channel[chan].freq + (channel[chan].oct << 10) < channel[chan].nextfreq +
+		(channel[chan].nextoct << 10))
+		slide_up(chan,info);
+	if(channel[chan].freq + (channel[chan].oct << 10) > channel[chan].nextfreq +
+		(channel[chan].nextoct << 10))
+		slide_down(chan,info);
+	setfreq(chan);
+}