/* MED-stmod.c: SoundTracker 2.x module load / ST-song save functions
		by Teijo Kinnunen 1989, 1990 */
#include "med.h"
extern struct Kappale far tamakappale;
extern void __asm Korosta(register __a0 struct Gadget *,register __d0 BOOL);
extern void __asm PaivitaNaytto(register __d0 BOOL);
extern void __asm SetTempo(register __d0 UWORD);
extern UWORD soittimennum,lohkoja;
extern BOOL diskerr(),AskName();
extern struct Gadget far gadget3[];
extern struct Soitin *soitin[];
extern struct Lohko *lohko[];

BOOL STModLoader(char *name)
{
	BPTR fh;
	struct ST24Mod stsong = { 0 };
	UBYTE scntr,*cnvblk;
	long modlen,samplelen = 0,readlen;
	if(*name == '\0') return(AskName());
	if(!(fh = Open2(name,MODE_OLDFILE))) return(diskerr(0,0));
	if(AlustaKappale(TRUE)) return(diskerr(fh,"Lacking memory..."));
	NollaaVarit();
	lohkoja = 0;
	Ilmoita("Loading ST2.x-module...");
	Seek(fh,0,OFFSET_END);
	modlen = Seek(fh,0,OFFSET_BEGINNING);
	if(Read(fh,(void *)&stsong,sizeof(struct ST24Mod)) <
		sizeof(struct ST24Mod)) return(diskerr(fh,0));
	modlen -= sizeof(struct ST24Mod); /* length of the remaining part */
	for(scntr = 0; scntr < 31; scntr++) {
		samplelen += stsong.sample[scntr].length * 2;
	}
	modlen -= samplelen;
	if(modlen < 0) 	return(diskerr(fh,"Not a valid module."));
	cnvblk = AllocMem(1028,MEMF_PUBLIC);
	if(!cnvblk) return(diskerr(fh,"No...MEMORY!!"));
	Ilmoita("Loading blocks...");
	while(modlen > 0) {	/* Load the song */
		if(lohkoja >= 100) break; /* too many blocks */
		if(AllocBlock(lohkoja,4)) {
			FreeMem(cnvblk,1028);
			return(diskerr(fh,"Hey, no mem for blocks."));
		}
		lohkoja++;
		if(modlen > 1024) readlen = 1024;
		else { readlen = modlen; memset((void *)cnvblk,0,1028); }
		if(Read(fh,cnvblk+4,readlen) < readlen) {
			FreeMem(cnvblk,1028);
			return(diskerr(fh,0));
		}
		modlen -= readlen;
		ConvertTo200(cnvblk,lohko[lohkoja-1]);
	}
	FreeMem(cnvblk,1028);
	tamakappale.lohkoja = lohkoja;
	tamakappale.tempo = 6;
	tamakappale.kappaleen_pituus = stsong.songlen;
	tamakappale.vaihtoja = 5;
	memcpy((char *)(tamakappale.soittojarjestys),(char *)(stsong.
		playseq),100);
	for(scntr = 0; scntr < 31; scntr++) {
		strcpy(tamakappale.soitin[scntr+1],stsong.sample[scntr].
			name);
		tamakappale.soittimenvoimakkuus[scntr+1] = stsong.sample[
			scntr].volume;
		tamakappale.stoisto[scntr+1] = stsong.sample[scntr].repeat;
		tamakappale.stoistonpit[scntr+1] = stsong.sample[scntr].
			replen * 2;
	}
	PaivitaNaytto(TRUE);
	Korosta(&gadget3[7],TRUE); Korosta(&gadget3[8],FALSE);
	SetTempo(6);
	Ilmoita("Loading samples...");
	soittimennum = 1;
	PaivitaSoittimennimi();
	for(scntr = 0; scntr < 31; scntr++) {
		samplelen = stsong.sample[scntr].length * 2;
		if(samplelen) {
			if(NewInstrument(samplelen,soittimennum))
				return(diskerr(fh,"No memory!!"));;
			if(Read(fh,(char *)(soitin[soittimennum]) +
				sizeof(struct Soitin),samplelen) <
				  samplelen) return(diskerr(fh,0));
		}
		SeurSoitin();
	}
	Close(fh);
	soittimennum = 1;
	PaivitaSoittimennimi();
	TulostaLohkoJaSoitin();
	Ilmoita("Module is now loaded.");
	return(FALSE);
}

void ConvertToST(UBYTE *from,UBYTE *to)
{
	extern UWORD periodit[];
	register UWORD cnt,per;
	register UBYTE instrG_V = 0,nnum;
	for(cnt = 0; cnt < (64 * 4); cnt++) {
		nnum = *from++;
		if(nnum & 0x80) { instrG_V = 1; nnum &= 0x7f; }
		else instrG_V = 0;
		if(!nnum) per = 0;
		else per = periodit[nnum - 1];
		if(instrG_V) per |= 0x1000;
		*to++ = (UBYTE)(per >> 8);
		*to++ = (UBYTE)(per & 0xff);
		*to++ = *from++;
		*to++ = *from++;
	}
}

BOOL STSongSaver(char *name)
{
	UBYTE oldexists,scnt,*convblk;
	struct SoundTrackerKappale stsong = { 0 };
	BPTR fh;
	if(*name == '\0') return(AskName());
	if(IsHere(name)) {
		oldexists = 1;
		Ilmoita("File already exists. Continue?");
		if(!Continue()) return(TRUE);
	}
	fh = Open2(name,MODE_NEWFILE);
	if(!fh) return(diskerr(0,"Can't create the file."));
	Ilmoita("Saving ST-song.");
	strcpy(stsong.st_nimi,name);
	for(scnt = 0; scnt < 15; scnt++) {
		strcpy(stsong.st_ins[scnt].sti_nimi,tamakappale.soitin[scnt+1]);
		stsong.st_ins[scnt].sti_vol = tamakappale.
			soittimenvoimakkuus[scnt+1];
		stsong.st_ins[scnt].sti_pit = soitin[scnt+1]->length / 2;
		stsong.st_ins[scnt].sti_repeat = tamakappale.stoisto[scnt+1];
		if(tamakappale.stoistonpit[scnt+1] <= 2)
			stsong.st_ins[scnt].sti_replen = 1;
		else stsong.st_ins[scnt].sti_replen = tamakappale.stoistonpit[scnt+1] / 2;
	}
	stsong.st_kappaleen_pit = tamakappale.kappaleen_pituus;
	memcpy(stsong.st_lohkojarj,tamakappale.soittojarjestys,100);
	stsong.st_kummajainen = 0x78; /* ???????? */
	if(Write(fh,(char *)&stsong,sizeof(struct SoundTrackerKappale)) !=
		sizeof(struct SoundTrackerKappale)) return(diskerr(fh,0));
	convblk = AllocMem(1024,MEMF_PUBLIC);
	if(!convblk) return(diskerr(fh,"No memory."));
	Ilmoita("Saving blocks...");
	for(scnt = 0; scnt < lohkoja; scnt++) {
		ConvertToST(lohko[scnt]->music,convblk);
		if(Write(fh,convblk,1024) != 1024) {
			FreeMem(convblk,1024);
			return(diskerr(fh,0));
		}
	}
	FreeMem(convblk,1024);
	Close(fh);
	if(!oldexists) InsertSavedFile(name);
	Ilmoita("ST-song is now saved.");
	return(FALSE);
}