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

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

/*
 * 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);
}