#    /*

    Copyright (C) 2001 Stefan Westerfeld
                       stefan@space.twc.de

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 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
    Library General Public License for more details.
   
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.

    */

#include "artsmodulessynth.h"
#include <sys/stat.h>
#include <stdsynthmodule.h>
#include <unistd.h>
#include <math.h>
#include <debug.h>
#include <cache.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

using namespace std;

namespace Arts {

namespace PatchLoader {
	typedef unsigned char byte;
	typedef unsigned short int word;
	typedef unsigned int dword;
	typedef char sbyte;
	typedef short int sword;
	typedef int sdword;

	static int pos = 0;
	static int apos = 0;

	inline void xRead(FILE *file, int len, void *data)
	{
		//	printf("(0x%2x) - 0x%02x  ... reading %d bytes\n",apos,pos,len);
		pos += len;
		apos += len;
		if(fread(data, len, 1, file) != 1)
			fprintf(stdout, "short read\n");
	}

	inline void skip(FILE *file, int len)
	{
		//	printf("(0x%2x) - 0x%02x  ... skipping %d bytes\n",apos,pos,len);
		pos += len;
		apos += len;
		while(len > 0)
		{
			char junk;
			if(fread(&junk, 1, 1, file) != 1)
				fprintf(stdout, "short read\n");
			len--;
		}
	}


	inline void readBytes(FILE *file, unsigned char *bytes, int len)
	{
		xRead(file, len, bytes);
	}

	inline void readString(FILE *file, char *str, int len)
	{
		xRead(file, len, str);
	}

	/* readXXX with sizeof(xxx) == 1 */
	inline void readByte(FILE *file, byte& b)
	{
		xRead(file, 1, &b);
	}

	/* readXXX with sizeof(xxx) == 2 */
	inline void readWord(FILE *file, word& w)
	{
		byte h, l;
		xRead(file, 1, &l);
		xRead(file, 1, &h);
		w = (h << 8) + l;
	}

	inline void readSWord(FILE *file, sword& sw)
	{
		word w;
		readWord(file, w);
		sw = (sword)w;
	}

	/* readXXX with sizeof(xxx) == 4 */
	inline void readDWord(FILE *file, dword& dw)
	{
		byte h, l, hh, hl;
		xRead(file, 1, &l);
		xRead(file, 1, &h);
		xRead(file, 1, &hl);
		xRead(file, 1, &hh);
		dw = (hh << 24) + (hl << 16) + (h << 8) + l;
	}

	struct PatHeader {
		char id[12];					/* ID='GF1PATCH110' */
		char manufacturer_id[10];		/* Manufacturer ID */
		char description[60];			/* Description of the contained Instruments
										   or copyright of manufacturer. */
		byte instruments;				/* Number of instruments in this patch */
		byte voices;					/* Number of voices for sample */
		byte channels;					/* Number of output channels
										   (1=mono,2=stereo) */
		word waveforms;					/* Number of waveforms */
		word mastervolume;				/* Master volume for all samples */
		dword size;						/* Size of the following data */
		char reserved[36];				/* reserved */

		PatHeader(FILE *file)
		{
			readString(file, id, 12);
			readString(file, manufacturer_id, 10);
			readString(file, description, 60);
			/*		skip(file, 2);*/

			readByte(file, instruments);
			readByte(file, voices);
			readByte(file, channels);

			readWord(file, waveforms);
			readWord(file, mastervolume);
			readDWord(file, size);

			readString(file, reserved, 36);
		}
	};

	struct PatInstrument {
		word	number;
		char	name[16];
		dword 	size;					/* Size of the whole instrument in bytes. */
		byte	layers;
		char	reserved[40];

		/* layer? */
		word	layerUnknown;
		dword	layerSize;
		byte	sampleCount;			/* number of samples in this layer (?) */
		char	layerReserved[40];

		PatInstrument(FILE *file)
		{
			readWord(file, number);
			readString(file, name, 16);
			readDWord(file, size);
			readByte(file, layers);
			readString(file, reserved, 40);

			/* layer: (?) */
			readWord(file, layerUnknown);
			readDWord(file, layerSize);
			readByte(file, sampleCount);
			readString(file, reserved, 40);
		}
	};

	struct PatPatch {
		char	filename[7];			/* Wave file name */
		byte	fractions;				/* Fractions */
		dword	wavesize;				/* Wave size.
										   Size of the wave digital data */
		dword	loopStart;
		dword	loopEnd;
		word	sampleRate;
		dword	minFreq;
		dword	maxFreq;
		dword	origFreq;
		sword	fineTune;
		byte	balance;
		byte	filterRate[6];
		byte	filterOffset[6];
		byte	tremoloSweep;
		byte	tremoloRate;
		byte	tremoloDepth;
		byte	vibratoSweep;
		byte	vibratoRate;
		byte	vibratoDepth;
		byte	waveFormat;
		sword	freqScale;
		word	freqScaleFactor;
		char	reserved[36];

		PatPatch(FILE *file)
		{
			readString(file, filename, 7);
			readByte(file, fractions);
			readDWord(file, wavesize);
			readDWord(file, loopStart);
			readDWord(file, loopEnd);
			readWord(file, sampleRate);
			readDWord(file, minFreq);
			readDWord(file, maxFreq);
			readDWord(file, origFreq);
			readSWord(file, fineTune);
			readByte(file, balance);
			readBytes(file, filterRate, 6);
			readBytes(file, filterOffset, 6);
			readByte(file, tremoloSweep);
			readByte(file, tremoloRate);
			readByte(file, tremoloDepth);
			readByte(file, vibratoSweep);
			readByte(file, vibratoRate);
			readByte(file, vibratoDepth);
			readByte(file, waveFormat);
			readSWord(file, freqScale);
			readWord(file, freqScaleFactor);
			readString(file, reserved, 36);
		}
	};
}

class CachedPat : public CachedObject
{
protected:
	struct stat oldstat;
	string filename;
	bool initOk;
	long dataSize;

	CachedPat(Cache *cache, const string& filename);
	~CachedPat();

public:

	struct Data {
		PatchLoader::PatPatch patch;
		mcopbyte *rawdata;
		Data(FILE *file)
			: patch(file)
		{
			rawdata = new mcopbyte[patch.wavesize];
			fread(rawdata, 1, patch.wavesize, file);

			// sign conversion only for 16bit!
			if(patch.waveFormat & (1 << 1))
			{
				for(unsigned int i = 1; i < patch.wavesize; i+=2)
					rawdata[i] ^= 0x80;
			}

			// unfold ping-pong loops
			if(patch.waveFormat & (1 << 3))
			{
				int looplen = patch.loopEnd - patch.loopStart;
				arts_assert(looplen > 0);

				mcopbyte *newdata = new mcopbyte[patch.wavesize + looplen];

				// copy head
				memcpy(&newdata[0], &rawdata[0], patch.loopStart + looplen);

				// 16 bit unfolding only:
				for(int i=0; i<looplen; i+=2)
				{
					newdata[patch.loopStart+looplen+i] =
						newdata[patch.loopStart+looplen-i-2];
					newdata[patch.loopStart+looplen+i+1] =
						newdata[patch.loopStart+looplen-i-1];
				}

				// copy tail:
				memcpy(&newdata[patch.loopStart+2*looplen],
					   &rawdata[patch.loopStart+looplen],
					   patch.wavesize - patch.loopEnd);

				delete[] rawdata;
				rawdata = newdata;

				patch.wavesize += looplen;
				patch.loopEnd += looplen;
				patch.waveFormat &= ~(1 << 3);
			}
		}
		~Data()
		{
			delete[] rawdata;
		}
	};

	list<Data*> dList;

	static CachedPat *load(Cache *cache, const string& filename);
	/**
	 * validity test for the cache - returns false if the object is having
	 * reflecting the correct contents anymore (e.g. if the file on the
	 * disk has changed), and there is no point in keeping it in the cache any
	 * longer
	 */
	bool isValid();
	/**
	 * memory usage for the cache
	 */
	int memoryUsage();
};

CachedPat *CachedPat::load(Cache *cache, const string& filename)
{
	CachedPat *pat;

	pat = (CachedPat *)cache->get(string("CachedPat:")+filename);
	if(!pat) {
		pat = new CachedPat(cache, filename);

		if(!pat->initOk)		// loading failed
		{
			pat->decRef();
			return 0;
		}
	}

	return pat;
}

bool CachedPat::isValid()
{
	if(!initOk)
		return false;

	struct stat newstat;

	lstat(filename.c_str(),&newstat);
	return(newstat.st_mtime == oldstat.st_mtime);
}

int CachedPat::memoryUsage()
{
	return dataSize;
}

CachedPat::CachedPat(Cache *cache, const string& filename)
	: CachedObject(cache), filename(filename), initOk(false), dataSize(0)
{
	setKey(string("CachedPat:")+filename);

	if(lstat(filename.c_str(),&oldstat) == -1)
	{
		arts_info("CachedPat: Can't stat file '%s'", filename.c_str());
		return;
	}

	FILE *patfile = fopen(filename.c_str(), "r");
	if(patfile)
	{
		//PatchLoader::PatHeader header(patfile);
		PatchLoader::PatInstrument ins(patfile);

		for(int i=0;i<ins.sampleCount;i++)
		{
			Data *data = new Data(patfile);
			dList.push_back(data);
			dataSize += data->patch.wavesize;
		}
		fclose(patfile);

		arts_debug("loaded pat %s",filename.c_str());
		arts_debug("  %d patches, datasize total is %d bytes",
											ins.sampleCount, dataSize);

		initOk = true;
	}
}

CachedPat::~CachedPat()
{
	while(!dList.empty())
	{
		delete dList.front();
		dList.pop_front();
	}
}

class Synth_PLAY_PAT_impl : virtual public Synth_PLAY_PAT_skel,
							virtual public StdSynthModule
{
protected:
	string _filename;
	CachedPat *pat;
	CachedPat::Data *selected;
	float fpos;

public:
	Synth_PLAY_PAT_impl()
	{
		pat = 0;
		selected = 0;
	}

	void unload()
	{
		if(pat)
		{
			pat->decRef();
			pat = 0;
		}
	}

	~Synth_PLAY_PAT_impl()
	{
		unload();
	}

	void streamStart()
	{
		fpos = 0.0;
		selected = 0;
	}
	
	void calculateBlock(unsigned long samples)
	{
		/* the normal offset is 60
		   60 = 12*5
		   so we scale with 2^5 = 32
		 */
		float freq = frequency[0]; /* * 32.0 / 2.0; * why /2.0? */
		int ifreq = (int)(freq * 1024.0);
		if(!selected && pat)
		{
			int bestdiff = 20000 * 1024;

			list<CachedPat::Data*>::iterator i;
			for(i = pat->dList.begin(); i != pat->dList.end(); i++)
			{
				int diff = ::abs(double(ifreq - (*i)->patch.origFreq));
				if(diff < bestdiff)
				{
					selected = *i;
					bestdiff = diff;
				}
			}

			/* drums */
			if(selected && selected->patch.freqScaleFactor == 0)
				ifreq = selected->patch.origFreq;
		}
		if(selected)
		{
			const PatchLoader::PatPatch& patch = selected->patch;

			/*
			 * thats just a *guess*, I have no idea how tuning actually
			 * should work
			 */
#if 0
			float tonetune = float(pat.fineTune)/float(pat.freqScaleFactor);
			float tuning = pow(2.0, tonetune/12.0);
			freq *= tuning;
#endif
			//printf("tonetune: %f\n",tonetune);
			//printf("tuning: %f\n",tuning);

			float step = double(patch.sampleRate)/samplingRateFloat *
				  		 float(ifreq) / float(patch.origFreq);
			for(unsigned int i = 0; i < samples; i++)
			{
				// ASSUME 16bit signed, native byte order
				int ifpos = int(fpos)*2;

				//                     looped?      bidi?     backw?
				if((patch.waveFormat & ((1 << 2) + (1 << 3) + (1 << 4)))
							== (1 << 2))
				{
					while(ifpos >= signed(patch.loopEnd))
					{
						ifpos -= (patch.loopEnd - patch.loopStart);
						fpos -= (patch.loopEnd - patch.loopStart)/2;
					}
				}
				
				short int *x = (short int *)&selected->rawdata[ifpos];
				float sample = (ifpos >= 0 && ifpos < signed(patch.wavesize))?
										x[0]/32768.0:0.0;
				float sample1 = ((ifpos+2) >= 0 && (ifpos+2) < signed(patch.wavesize))?
										x[1]/32768.0:0.0;
				float error = fpos - (int)fpos;
				outvalue[i] = sample * (1.0-error) + sample1 * error;

				fpos += step;
			}
		}
		else
		{
			for(unsigned int i = 0; i < samples; i++)
				outvalue[i] = 0.0;
		}
	}

	void clearDList()
	{
		selected = 0;

	}

	string filename() { return _filename; }
	void filename(const string& newFile)
	{
		if(newFile == _filename) return;
	
		unload();
		pat = CachedPat::load(Cache::the(), newFile);

		_filename = newFile;
		filename_changed(newFile);
	}
};

REGISTER_IMPLEMENTATION(Synth_PLAY_PAT_impl);

}