gosu 1.3.0 → 1.4.0

data/dependencies/SDL_sound/libmodplug/load_mid.c

@@ -1,1405 +0,0 @@
-/*
-
- MikMod Sound System
-
-  By Jake Stine of Divine Entertainment (1996-2000)
-
- Support:
-  If you find problems with this code, send mail to:
-    air@divent.org
-
- Distribution / Code rights:
-  Use this source code in any fashion you see fit.  Giving me credit where
-  credit is due is optional, depending on your own levels of integrity and
-  honesty.
-
- -----------------------------------------
- Module: LOAD_MID
-
-  MID module loader.
-	by Peter Grootswagers (2006)
-	<email:pgrootswagers@planet.nl>
-
- Portability:
-	All systems - all compilers (hopefully)
-*/
-
-#include <stdlib.h>
-#include <time.h>
-#include <string.h>
-#include <math.h>
-#include <ctype.h>
-
-#include "libmodplug.h"
-#define PAN_LEFT    0x30
-#define PAN_RIGHT   0xD0
-#define MAX_POLYPHONY 16  // max notes in one midi channel
-#define MAX_TRACKS    (MAX_BASECHANNELS-6)  // max mod tracks
-#define WHEELSHIFT    10  // how many bits the 13bit midi wheel value must shift right 
-
-#include "load_pat.h"
-
-#define ROWSPERNOTE 16
-#define ENV_MMMID_SPEED	"MMMID_SPEED"
-
-/**************************************************************************
-**************************************************************************/
-
-typedef enum {
-	none,
-	wheeldown,
-	wheelup,
-	fxbrk,
-	tmpo,
-	fxsync,
-	modwheel,
-	mainvol,
-	prog
-} MIDEVENT_X_EFFECT;
-
-typedef struct _MIDEVENT
-{
-	struct _MIDEVENT *next;
-	ULONG	tracktick;
-	BYTE flg; // 1 = note present
-	BYTE note;
-	BYTE volume;
-	BYTE smpno;
-	BYTE fx;
-	BYTE fxparam;
-} MIDEVENT;
-
-typedef struct _MIDTRACK
-{
-	struct _MIDTRACK *next;
-	MIDEVENT *head;
-	MIDEVENT *tail;
-	MIDEVENT *workevent; // keeps track of events in track
-	int balance; // last balance on this track
-	ULONG vtracktick; // tracktick of last note event (on or off)
-	BYTE chan;
-	BYTE vpos;	// 0xff is track is free for use, otherwise it's the note playing on this track
-	BYTE volume; // last note volume on this track
-	BYTE instr;	// current instrument for this track
-} MIDTRACK;
-
-/**************************************************************************
-**************************************************************************/
-
-typedef struct _MIDHANDLE
-{
-	MMFILE *mmf;
-	MIDTRACK *track;
-	MIDTRACK *tp;
-	ULONG tracktime;
-	int speed;
-	int midispeed;
-	int midiformat;
-	int resolution;
-	int miditracks;
-	int divider;
-	int tempo;
-	int percussion;
-	long deltatime;
-} MIDHANDLE;
-
-static void mid_message(const char *s1, const char *s2)
-{
-	char txt[256];
-	if( SDL_strlen(s1) + SDL_strlen(s2) > 255 ) return;
-	SDL_snprintf(txt, sizeof (txt), s1, s2);
-	SDL_LogInfo(SDL_LOG_CATEGORY_AUDIO, "load_mid > %s\n", txt);
-}
-
-static ULONG miditicks(MIDHANDLE *h, ULONG modtick)
-{
-	return modtick * h->divider / ROWSPERNOTE / h->speed;
-}
-
-static ULONG modticks(MIDHANDLE *h, ULONG miditick)
-{
-	return miditick * ROWSPERNOTE * h->speed / h->divider;
-}
-
-static void mid_adjust_for_optimal_tempo(MIDHANDLE *h, int maxtempo)
-{
-	// the tempo is adjusted so that the maximum tempo is 255
-	// this way we have the biggest change that very short notes get played
-	// and we make sure the tempo doesn't become too large or too small
-	// if the piece in hand isn't so weird it changes tempo from 20 to 255, that is.
-	// tempo is only registered in first track (h->track) because it is a global event
-	MIDEVENT *e;
-	int d, t;
-	if( maxtempo < 1 ) return;
-	d = h->divider;
-	t = maxtempo;
-	h->divider = (t * d) / 255;
-	while( (h->midispeed = miditicks(h, h->speed)) < h->speed ) {
-		++t;
-		h->divider = (t * d) / 255;
-	}
-	if( h->track ) {
-		for( e=h->track->head; e; e=e->next ) {
-			if( e->fx == tmpo )
-				e->fxparam = (255 * e->fxparam ) / t;
-		}
-	}
-}
-
-// =====================================================================================
-static MIDEVENT *mid_new_event(MIDHANDLE *h)
-// =====================================================================================
-{
-    MIDEVENT   *retval;
-
-    retval = (MIDEVENT *)_mm_calloc(h->trackhandle, 1,sizeof(MIDEVENT));
-		retval->next      = NULL;
-    retval->tracktick = h->tracktime;
-		retval->flg       = 0;
-		retval->note      = 0;
-		retval->volume    = 0;
-		retval->smpno     = 0;
-		retval->fx        = none;
-		retval->fxparam   = 0;
-    return retval;
-}
-
-// =====================================================================================
-static MIDTRACK *mid_new_track(MIDHANDLE *h, int mch, int pos)
-// =====================================================================================
-{
-    MIDTRACK *retval;
-    retval = (MIDTRACK *)_mm_calloc(h->trackhandle, 1,sizeof(MIDTRACK));
-		retval->next       = NULL;
-    retval->vpos       = pos;
-		retval->instr      = 1;
-		retval->chan       = mch;
-		retval->head       = NULL;
-		retval->tail       = NULL;
-		retval->workevent  = NULL;
-		retval->vtracktick = 0;
-		retval->volume     = h->track? h->track->volume: 120;
-		retval->balance    = 64;
-    return retval;
-}
-
-static int mid_numtracks(MIDHANDLE *h)
-{
-	int n;
-	MIDTRACK *t;
-	n=0;
-	for( t = h->track; t; t=t->next )
-		n++;
-	return n;
-}
-
-// find out how many midichannel we have
-static int mid_numchans(MIDHANDLE *h)
-{
-	int i,c,n;
-	MIDTRACK *t;
-	c = 0;
-	for( t = h->track; t; t=t->next )
-		c |= (1<<t->chan);
-	n = 0;
-	for( i=0; i<16; i++ )
-		if( c & (1<<i) ) n++;
-	return n;
-}
-
-// find out which ordinal a midichannel has
-static int mid_ordchan(MIDHANDLE *h, int mch)
-{
-	int i,c,n;
-	MIDTRACK *t;
-	c = 0;
-	for( t = h->track; t; t=t->next )
-		c |= (1<<t->chan);
-	n = 0;
-	for( i=0; i<mch; i++ )
-		if( c & (1<<i) ) n++;
-	return n;
-}
-
-static void mid_rewind_tracks(MIDHANDLE *h)
-{
-	MIDTRACK *tr;
-	h->tracktime = 0;
-	for( tr = h->track; tr; tr = tr->next ) {
-		tr->vpos       = 0xff;
-		tr->workevent  = tr->head;
-		tr->vtracktick = 0;
-	}
-}
-
-static void mid_update_track(MIDTRACK *tr)
-{
-	MIDEVENT *e;
-	e = tr->workevent;
-	if( e->flg )	{
-		if( e->volume ) tr->vpos = e->note;
-		else tr->vpos = 0xff;
-		tr->volume = e->volume;
-		tr->vtracktick = e->tracktick;
-	}
-	if( e->fx == prog ) tr->instr = e->fxparam;
-}
-
-static void mid_sync_track(MIDTRACK *tr, ULONG tracktime)
-{
-	MIDEVENT *e;
-	e = tr->workevent;
-	if( e && e->tracktick > tracktime ) e = tr->head; // start again....
-	for( ; e && e->tracktick <= tracktime; e=e->next ) {
-		tr->workevent = e;
-		mid_update_track(tr);
-	}
-}
-
-// =====================================================================================
-static MIDTRACK *mid_find_track(MIDHANDLE *h, int mch, int pos)
-// =====================================================================================
-{
-	MIDTRACK *tr;
-	for( tr=h->track; tr; tr=tr->next ) {
-		mid_sync_track(tr, h->tracktime);
-		if( tr->chan == mch && tr->vpos == pos )
-			return tr;
-	}
-	return NULL;
-}
-
-// =====================================================================================
-static MIDTRACK *mid_locate_track(MIDHANDLE *h, int mch, int pos)
-// =====================================================================================
-{
-	MIDTRACK *tr, *prev, *trunused;
-	MIDEVENT *e;
-	int instrno = 1;
-	int polyphony;
-	int vol = 0, bal = 0;
-	int numtracks;
-	ULONG tmin;
-	prev = NULL;
-	trunused = NULL;
-	polyphony = 0;
-	numtracks = 0;
-	tmin = h->midispeed; // minimal distance between note events in track
-	// look up track with desired channel and pos (note)
-	for( tr=h->track; tr; tr=tr->next ) {
-		mid_sync_track(tr, h->tracktime);
-		if( tr->chan == mch ) {
-			if( tr->vpos == pos )
-				return tr;
-			if( tr->vpos == 0xff ) {
-				// check if track with silence is quiet long enough
-				if( h->tracktime > tr->vtracktick + tmin ) trunused = tr;
-			}
-			else vol = tr->volume;
-			instrno = tr->instr;
-			bal = tr->balance;
-			polyphony++;
-		}
-		numtracks++;
-		prev = tr;
-	}
-	if( trunused ) {
-		trunused->vpos = pos;
-		return trunused;
-	}
-	if( polyphony > MAX_POLYPHONY || (polyphony > 0 && numtracks > MAX_TRACKS) ) { // do not use up too much channels
-		for( tr=h->track; tr; tr=tr->next ) {
-			if( tr->chan == mch ) {
-				e = tr->workevent;
-				if( h->tracktime > e->tracktick + tmin ) {
-					tmin = h->tracktime - e->tracktick;
-					trunused = tr;
-				}
-			}
-		}
-		if( trunused ) {
-			trunused->vpos = pos;
-			return trunused;
-		}
-	}
-	if( numtracks > MAX_TRACKS ) { // we can not allocate new tracks
-		tmin = 0;
-		for( tr=h->track; tr; tr=tr->next ) {
-			if( tr->chan == mch ) {
-				e = tr->workevent;
-				if( h->tracktime >= e->tracktick + tmin ) {
-					tmin = h->tracktime - e->tracktick;
-					trunused = tr;
-				}
-			}
-		}
-		if( trunused ) {
-			trunused->vpos = pos;
-			return trunused;
-		}
-		tmin = 0;
-		for( tr=h->track; tr; tr=tr->next ) {
-			e = tr->workevent;
-			if( h->tracktime >= e->tracktick + tmin ) {
-				tmin = h->tracktime - e->tracktick;
-				trunused = tr;
-			}
-		}
-		if( trunused ) {
-			trunused->vpos = pos;
-			trunused->chan = mch;
-			return trunused;
-		}
-	}
-	tr = mid_new_track(h, mch, pos);
-	tr->instr  = instrno;
-	tr->volume = vol;
-	tr->balance = bal;
-	if( prev ) prev->next = tr;
-	else	h->track = tr;
-	return tr;
-}
-
-static void	mid_add_event(MIDHANDLE *h, MIDTRACK *tp, MIDEVENT *e)
-{
-	MIDEVENT *ew, *ep;
-	ep = NULL;
-	ew = tp->workevent;
-	if( ew && ew->tracktick > e->tracktick ) ew = tp->head; // start again from the beginning...
-	for( ; ew && ew->tracktick <= e->tracktick; ew = ew->next ) {
-		ep = ew;
-		tp->workevent = ew;
-		mid_update_track(tp);
-	}
-	if( ep ) {
-		ep->next = e;
-		e->next = ew;
-	}
-	else {
-		e->next = tp->head;
-		tp->head = e;
-	}
-	if( !e->next )
-		tp->tail = e;
-	tp->workevent = e;
-	mid_update_track(tp);
-}
-
-static void mid_add_tempo_event(MIDHANDLE *h, int tempo)
-{
-	MIDEVENT *e;
-	e = mid_new_event(h);
-	e->flg = 0;
-	e->fx = tmpo;
-	e->fxparam = tempo;
-	mid_add_event(h, h->track, e);
-}
-
-static void mid_add_partbreak(MIDHANDLE *h)
-{
-	MIDEVENT *e;
-	e = mid_new_event(h);
-	e->flg = 0;
-	e->fx = fxbrk;
-	mid_add_event(h, h->track, e);
-}
-
-static void mid_add_noteoff(MIDHANDLE *h, MIDTRACK *tp)
-{
-	MIDEVENT *e;
-	e = mid_new_event(h);
-	e->flg = 1;
-	e->note = tp->vpos;
-	e->smpno = tp->instr;
-	mid_add_event(h, tp, e);
-}
-
-static void mid_add_noteon(MIDHANDLE *h, MIDTRACK *tp, int n, int vol)
-{
-	MIDEVENT *e;
-	e = mid_new_event(h);
-	e->flg = 1;
-	e->note = n;
-	e->smpno = tp->instr;
-	e->volume = vol;
-	mid_add_event(h, tp, e);
-}
-
-static BYTE modtremolo(int midimod)
-{
-	int m;
-	if( midimod == 0 ) return 0;
-	if( midimod > 63 ) {
-		m = (128 - midimod) / 4;
-		if( m==0 ) m = 1;
-		return m|0xf0; // find slide down
-	}
-	m = midimod / 4;
-	if( m==0 ) m = 1;
-	return (m<<4)|0x0f; // find slide up
-}
-
-// =====================================================================================
-static void mid_mod_wheel(MIDHANDLE *h, int mch, int mod)
-// =====================================================================================
-{
-	MIDTRACK *tr;
-	MIDEVENT *e;
-	for( tr=h->track; tr; tr=tr->next ) {
-		if( tr->chan == mch ) {
-			mid_sync_track(tr, h->tracktime);
-			if( tr->vpos != 0xff ) { // only on tracks with notes on...
-				e = mid_new_event(h);
-				e->flg = 0;
-				e->fx = modwheel;
-				e->fxparam = modtremolo(mod);
-				mid_add_event(h, tr, e);
-			}
-		}
-	}
-}
-
-// =====================================================================================
-static void mid_main_volume(MIDHANDLE *h, int mch, int vol)
-// =====================================================================================
-{
-	MIDTRACK *tr;
-	MIDEVENT *e;
-	for( tr=h->track; tr; tr=tr->next ) {
-		if( tr->chan == mch ) {
-			e = mid_new_event(h);
-			e->flg = 0;
-			e->fx = mainvol;
-			e->fxparam = vol;
-			mid_add_event(h, tr, e);
-		}
-	}
-}
-
-// transform 0..63..127 to left..center..right in 2n+1 areas
-static int modpan(int midipan, int n)
-{
-	int npan, area, x;
-	x    = 2 * n + 1;
-	area = (midipan * x * (PAN_RIGHT - PAN_LEFT))>>7;
-	npan = (PAN_LEFT * x + area) / x;
-	return npan;
-}
-
-// =====================================================================================
-static void mid_pan(MIDHANDLE *h, int mch, int pan)
-// =====================================================================================
-{
-	MIDTRACK *tr;
-	int hits;
-	hits = 0;
-	for( tr=h->track; tr; tr=tr->next ) {
-		if( tr->chan == mch ) {
-			hits++;
-			tr->balance = pan;
-		}
-	}
-	if( !hits ) {
-		tr = mid_locate_track(h, mch, 0xff);
-		tr->balance = pan;
-	}
-}
-
-// =====================================================================================
-static void mid_add_program(MIDHANDLE *h, int mch, int pr)
-// =====================================================================================
-{
-	MIDTRACK *tr;
-	MIDEVENT *e;
-	int hits;
-	hits = 0;
-	for( tr=h->track; tr; tr=tr->next ) {
-		if( tr->chan == mch ) {
-			hits++;
-			e = mid_new_event(h);
-			e->flg = 0;
-			e->fx = prog;
-			e->fxparam = pat_gmtosmp(pr + 1);
-			mid_add_event(h, tr, e);
-		}
-	}
-	if( !hits ) {
-		tr = mid_locate_track(h, mch, 0xff);
-		e = mid_new_event(h);
-		e->flg = 0;
-		e->fx = prog;
-		e->fxparam = pat_gmtosmp(pr + 1);
-		mid_add_event(h, tr, e);
-	}
-}
-
-// =====================================================================================
-static void mid_all_notes_off(MIDHANDLE *h, int mch)
-// =====================================================================================
-{
-	MIDTRACK *tr;
-	for( tr=h->track; tr; tr=tr->next ) {
-		if( tr->chan == mch || mch == -1 ) {
-			mid_sync_track(tr, h->tracktime);
-			if( tr->vpos != 0xff )
-				mid_add_noteoff(h, tr);
-		}
-	}
-}
-
-static void mid_add_sync(MIDHANDLE *h, MIDTRACK *tp)
-{
-	MIDEVENT *e;
-	e = mid_new_event(h);
-	e->flg = 0;
-	e->fx = fxsync;
-	mid_add_event(h, tp, e);
-}
-
-static BYTE mid_to_mod_wheel(unsigned int midwheel)
-{
-	unsigned int i;
-	if( midwheel == 0 ) return 0;
-	i = midwheel >> WHEELSHIFT;
-	return i+1;
-}
-
-static void mid_add_wheel(MIDHANDLE *h, MIDTRACK *tp, int wheel)
-{
-	MIDEVENT *e;
-	e = mid_new_event(h);
-	e->flg = 0;
-	if( wheel < 0 ) {
-		e->fx = wheeldown;
-		e->fxparam = mid_to_mod_wheel(-wheel);
-	}
-	else {
-		e->fx = wheelup;
-		e->fxparam = mid_to_mod_wheel(wheel);
-	}
-	mid_add_event(h, tp, e);
-}
-
-static void mid_add_pitchwheel(MIDHANDLE *h, int mch, int wheel)
-{
-	MIDTRACK *tr;
-	int hits;
-	hits = 0;
-	for( tr=h->track; tr; tr=tr->next ) {
-		if( tr->chan == mch ) {
-			hits++;
-			mid_sync_track(tr, h->tracktime);
-			if( tr->vpos != 0xff ) // only on tracks with notes on...
-				mid_add_wheel(h, tr, wheel);
-		}
-	}
-	if( !hits ) { // special case in midiformat 1 events in first track...
-		tr = mid_locate_track(h, mch, 0xff);
-		mid_add_wheel(h, tr, wheel);
-	}
-}
-
-static uint32_t mid_read_long(MIDHANDLE *h)
-{
-	BYTE buf[4];
-	mmreadUBYTES(buf, 4, h->mmf);
-	return (buf[0]<<24)|(buf[1]<<16)|(buf[2]<<8)|buf[3];
-}
-
-static short int mid_read_short(MIDHANDLE *h)
-{
-	BYTE buf[2];
-	mmreadUBYTES(buf, 2, h->mmf);
-	return (buf[0]<<8)|buf[1];
-}
-
-static BYTE mid_read_byte(MIDHANDLE *h)
-{
-	return mmreadUBYTE(h->mmf);
-}
-
-static int mid_read_delta(MIDHANDLE *h)
-{
-	BYTE bits;
-	int i, d;
-	d = 0;
-	for( i=0; i<4; ) {
-		bits = mid_read_byte(h);
-		i++;
-		d = (d<<7)|(bits&0x7f);
-		if( !(bits & 0x80) )
-			break;
-	}
-	h->deltatime = d;
-	return i;
-}
-
-// =====================================================================================
-BOOL CSoundFile_TestMID(const BYTE *lpStream, DWORD dwMemLength)
-// =====================================================================================
-{
-	char id[5];
-	MIDHANDLE h;
-	MMFILE mm;
-	mm.mm = (char *)lpStream;
-	mm.sz = dwMemLength;
-	h.mmf = &mm;
-	mmfseek(h.mmf,0,SEEK_SET);
-	mmreadSBYTES(id, 4, h.mmf);
-	id[4] = '\0';
-	return !SDL_strcmp(id,"MThd") && mid_read_long(&h) == 6;
-}
-
-// =====================================================================================
-static MIDHANDLE *MID_Init(void)
-{
-	MIDHANDLE *retval;
-	retval = (MIDHANDLE *)SDL_calloc(1,sizeof(MIDHANDLE));
-	if( !retval ) return NULL;
-	retval->track      = NULL;
-	retval->percussion = 0;
-	return retval;
-}
-
-static void MID_CleanupTrack(MIDTRACK *tp)
-{
-	MIDEVENT *ep, *en;
-	if( tp ) {
-		for( ep=tp->head; ep; ep = en ) {
-			en=ep->next;
-			SDL_free(ep);
-		}
-		tp->head = NULL;
-	}
-}
-
-// =====================================================================================
-static void MID_CleanupTracks(MIDHANDLE *handle)
-// =====================================================================================
-{
-	MIDTRACK *tp, *tn;
-	if(handle) {
-		for( tp=handle->track; tp; tp = tn ) {
-			tn=tp->next;
-			MID_CleanupTrack(tp);
-		}
-		handle->track = NULL;
-	}
-}
-
-// =====================================================================================
-static void MID_Cleanup(MIDHANDLE *handle)
-// =====================================================================================
-{
-	if(handle) {
-		MID_CleanupTracks(handle);
-		SDL_free(handle);
-		handle = 0;
-	}
-}
-
-static int mid_is_global_event(MIDEVENT *e)
-{
-	return (e->fx == tmpo || e->fx == fxbrk); 
-}
-
-static MIDEVENT *mid_next_global(MIDEVENT *e)
-{
-	for( ; e && !mid_is_global_event(e); e=e->next ) ;
-	return e;
-}
-
-static MIDEVENT *mid_next_fx(MIDEVENT *e)
-{
-	for( ; e && e->fx == none; e=e->next ) ;
-	return e;
-}
-
-static int mid_is_note_event(MIDEVENT *e)
-{
-#ifdef LOOPED_NOTES_OFF
-	return (e->flg == 0);
-#else
-	if( e->flg == 0 ) return 0;
-	if( e->volume ) return 1;
-	return pat_smplooped(e->smpno); // let non looping samples die out...
-#endif
-}
-
-static MIDEVENT *mid_next_note(MIDEVENT *e)
-{
-	for( ; e && !mid_is_note_event(e); e=e->next ) ;
-	return e;
-}
-
-static int MID_ReadPatterns(MODCOMMAND *pattern[], WORD psize[], MIDHANDLE *h, int numpat, int channels)
-// =====================================================================================
-{
-	int pat,row,i,ch;
-	BYTE n,ins,vol;
-	MIDTRACK *t;
-	MIDEVENT *e, *en, *ef, *el;
-	ULONG tt1, tt2;
-	MODCOMMAND *m;
-	int patbrk, tempo;
-	if( numpat > MAX_PATTERNS ) numpat = MAX_PATTERNS;
-
-	// initialize start points of event list in tracks
-	for( t = h->track; t; t = t->next ) t->workevent = t->head;
-	for( pat = 0; pat < numpat; pat++ ) {
-		pattern[pat] = CSoundFile_AllocatePattern(64, channels);
-		if( !pattern[pat] ) return 0;
-		psize[pat] = 64;
-		for( row = 0; row < 64; row++ ) {
-			tt1 = miditicks(h, (pat * 64 + row ) * h->speed);
-			tt2 = tt1 + h->midispeed;
-			ch = 0;
-			tempo = 0;
-			patbrk = 0;
-			if ( h->track )
-			for( e=mid_next_global(h->track->workevent); e && e->tracktick < tt2; e=mid_next_global(e->next) ) {
-				if( e && e->tracktick >= tt1 ) {	// we have a controller event in this row
-					switch( e->fx ) {
-						case tmpo:
-							tempo = e->fxparam;
-							break;
-						case fxbrk:
-							patbrk = 1;
-							break;
-					}
-				}
-			}
-			for( t = h->track; t; t = t->next ) {
-				m = &pattern[pat][row * channels + ch];
-				m->param   = 0;
-				m->command = CMD_NONE;
-				for( e=mid_next_fx(t->workevent); e && e->tracktick < tt2; e=mid_next_fx(e->next) ) {
-					if( e && e->tracktick >= tt1 ) {	// we have a controller event in this row
-						switch( e->fx ) {
-							case modwheel:
-								m->param   = e->fxparam;
-								m->command = CMD_VOLUMESLIDE;
-								break;
-							case wheelup:
-								m->param   = e->fxparam|0x10;
-								m->command = CMD_XFINEPORTAUPDOWN;
-								break;
-							case wheeldown:
-								m->param   = e->fxparam|0x20;
-								m->command = CMD_XFINEPORTAUPDOWN;
-								break;
-						}
-					}
-				}
-				for( e=mid_next_note(t->workevent); e && e->tracktick < tt1; e=mid_next_note(e->next) )
-					t->workevent = e;
-				i = 0;
-				ef = NULL;
-				en = e;
-				el = e;
-				for( ; e && e->tracktick < tt2; e=mid_next_note(e->next) ) {	// we have a note event in this row
-					t->workevent = e;
-					i++;
-					if( e->volume ) {
-						if( !ef ) ef = e;
-						el = e;
-					}
-				}
-				if( i ) {
-					if( i == 1 || ef == el || !ef ) { // only one event in this row or a note on with some note off
-						if( ef ) e = ef;
-						else e = en;
-						el = t->workevent;
-						n   = pat_modnote(e->note);
-						ins = e->smpno;
-						if( e->volume == 0 ) {
-							m->param = (BYTE)modticks(h, e->tracktick - tt1);
-							if( m->param ) { // note cut
-								m->command = CMD_S3MCMDEX;
-								m->param  |= 0xC0;
-							}
-							else {
-								m->param   = 0;
-								m->command = CMD_KEYOFF;
-							}
-							vol = 0;
-						}
-						else {
-							vol = e->volume/2;
-							if( el->volume == 0 ) {
-								m->param = (BYTE)modticks(h, el->tracktick - tt1);
-								if( m->param ) { // note cut
-									m->command = CMD_S3MCMDEX;
-									m->param  |= 0xC0;
-								}
-							}
-							else {
-								m->param = (BYTE)modticks(h, e->tracktick - tt1);
-								if( m->param ) { // note delay
-									m->command = CMD_S3MCMDEX;
-									m->param  |= 0xD0;
-								}
-							}
-						}
-						m->instr  = ins;
-						m->note   = n; // <- normal note
-						m->volcmd = VOLCMD_VOLUME;
-						m->vol    = vol;
-					}
-					else { 
-						// two notes in one row, use FINEPITCHSLIDE runonce effect
-						// start first note on first tick and framedly runonce on seconds note tick
-						// use volume and instrument of last note
-						n   = pat_modnote(ef->note);
-						i   = pat_modnote(el->note);
-						ins = el->smpno;
-						vol = el->volume/2;
-						if( vol > 64 ) vol = 64;
-						m->instr  = ins;
-						m->note   = n; // <- normal note
-						m->volcmd = VOLCMD_VOLUME;
-						m->vol    = vol;
-						m->param  = ((i > n)?i-n:n-i);
-						if( m->param < 16 ) {
-							if( m->param ) {
-								m->command = CMD_XFINEPORTAUPDOWN;
-								m->param |= (i > n)? 0x10: 0x20;
-							}
-							else {	// retrigger same note...
-								m->command = CMD_RETRIG;
-								m->param = (BYTE)modticks(h, el->tracktick - tt1);
-							}
-						}
-						else
-							m->command = (i > n)? CMD_PORTAMENTOUP: CMD_PORTAMENTODOWN;
-					}
-				}
-				if( m->param == 0 && m->command == CMD_NONE ) {
-					if( tempo ) {
-						m->command = CMD_TEMPO;
-						m->param   = tempo;
-						tempo = 0;
-					}
-					else {
-						if( patbrk ) {
-							m->command = CMD_PATTERNBREAK;
-							patbrk = 0;
-						}
-					}
-				}
-				ch++;
-			}
-			if( tempo || patbrk ) return 1;
-		}
-	}
-	return 0;
-}
-
-static ULONG mid_next_tracktick(MIDEVENT *e)
-{
-	MIDEVENT *en;
-	en = e->next;
-	if( en ) return en->tracktick;
-	return 0x7fffffff; // practically indefinite
-}
-
-// cut off alle events that follow the given event
-static void mid_stripoff(MIDTRACK *tp, MIDEVENT *e)
-{
-	MIDEVENT *ep, *en;
-	for( ep=e->next; ep; ep = en ) {
-		en=ep->next;
-		SDL_free(ep);
-	}
-	e->next  = NULL;
-	tp->tail = e;
-	tp->workevent = tp->head;
-	mid_sync_track(tp, e->tracktick);
-}
-
-static void mid_notes_to_percussion(MIDTRACK *tp, ULONG adjust, ULONG tmin)
-{
-	MIDEVENT *e, *lno = 0;
-	int n = 0,v;
-	ULONG ton, toff = 0, tnext;
-	v = 0x7f; // as loud as it gets
-	ton = 0;
-	for( e=tp->head; e; e=e->next ) {
-		if( e->tracktick < adjust ) e->tracktick = 0;
-		else e->tracktick -= adjust;
-		if( e->flg == 1 ) {
-			if( e->volume > 0 ) {
-				n = e->note;
-				e->smpno = pat_gmtosmp(pat_gm_drumnr(n));
-				e->note = pat_gm_drumnote(n);
-				e->volume = (v * e->volume) / 128;
-				if( v && !e->volume ) e->volume = 1;
-				ton = e->tracktick;
-			}
-			else {
-				toff = ton + tmin;
-				if( toff > e->tracktick ) {
-					tnext = mid_next_tracktick(e);
-					if( toff + tmin < tnext ) e->tracktick = toff;
-					else {
-						if( toff < tnext ) e->tracktick = toff - 1;
-						else e->tracktick = tnext - 1;
-					}
-				}
-				toff = e->tracktick;
-				lno = e;
-			}
-		}
-		else {
-			if( e->fx == mainvol ) {
-				v = e->fxparam;
-				if( !v && ton > toff ) {
-					e->flg = 1;
-					e->volume = 0;
-					e->note = pat_gm_drumnote(n);
-					toff = e->tracktick;
-					lno = e;
-				}
-			}
-		}
-	}
-	if( ton > toff ) {
-		char info[32];
-		SDL_snprintf(info,sizeof (info),"%ld > %ld note %d", (long)ton, (long)toff, n);
-		mid_message("drum track ends with note on (%s)", info);
-	}
-	if( lno && lno->next ) mid_stripoff(tp, lno);
-}
-
-static void mid_prog_to_notes(MIDTRACK *tp, ULONG adjust, ULONG tmin)
-{
-	MIDEVENT *e, *lno = 0;
-	int i = 0, n = 0, v = 0x7f;
-	ULONG ton, toff = 0, tnext;
-	ton = 0;
-	for( e=tp->head; e; e=e->next ) {
-		if( e->tracktick < adjust ) e->tracktick = 0;
-		else e->tracktick -= adjust;
-		if( e->flg == 1 ) {
-			if( !i ) i = pat_gmtosmp(1); // happens in eternal2.mid
-			e->smpno = i;
-			n = e->note;
-			if( e->volume > 0 ) {
-				e->volume = (v * e->volume) / 128;
-				if( v && !e->volume ) e->volume = 1;
-				ton = e->tracktick;
-			}
-			else {
-				toff = ton + tmin;
-				if( toff > e->tracktick ) {
-					tnext = mid_next_tracktick(e);
-					if( toff + tmin < tnext ) e->tracktick = toff;
-					else {
-						if( toff < tnext ) e->tracktick = toff - 1;
-						else e->tracktick = tnext - 1;
-					}
-				}
-				toff = e->tracktick;
-				lno = e;
-			}
-		}
-		else {
-			if( e->fx == prog ) i = e->fxparam;
-			if( e->fx == mainvol ) {
-				v = e->fxparam;
-				if( !v && ton > toff ) {
-					e->flg = 1;
-					e->volume = 0;
-					e->note = n;
-					toff = e->tracktick;
-					lno = e;
-				}
-			}
-		}
-	}
-	if( ton > toff ) {
-		char info[40];
-		SDL_snprintf(info,sizeof (info),"channel %d, %ld > %ld note %d", tp->chan + 1, (long)ton, (long)toff, n);
-		mid_message("melody track ends with note on (%s)", info);
-	}
-	if( lno && lno->next ) mid_stripoff(tp, lno);
-}
-
-static int midiword(BYTE *b)
-{
-	int i;
-	i = (b[0]&0x7f)|((b[1]&0x7f)<<7);
-	return i;
-}
-
-static int midishort(BYTE *b)
-{
-	return midiword(b) - 0x2000;
-}
-
-ULONG mid_first_noteonevent_tick(MIDEVENT *e)
-{
-	while( e && (e->flg == 0 || e->volume == 0) ) e=e->next;
-	if( !e ) return 0x7fffffff;
-	return e->tracktick;
-}
-
-// =====================================================================================
-BOOL CSoundFile_ReadMID(CSoundFile *_this, const BYTE *lpStream, DWORD dwMemLength)
-{
-	static int avoid_reentry = 0;
-	MIDHANDLE *h;
-	MMFILE mm;
-	int ch, dmulti, maxtempo, panlow, panhigh, numchans, numtracks;
-	MIDTRACK *ttp;
-	uint32_t t, numpats;
-	char buf[256];
-	uint32_t miditracklen;
-	BYTE runningstatus;
-	BYTE cmd;
-	BYTE midibyte[2];
-	long metalen, delta;
-	BYTE *p;
-	while( avoid_reentry ) SDL_Delay(1);
-	avoid_reentry = 1;
-	if( !CSoundFile_TestMID(lpStream, dwMemLength) ) {
-		avoid_reentry = 0;
-		return FALSE;
-	}
-	h = MID_Init();
-	if( !h ) {
-		avoid_reentry = 0;
-		return FALSE;
-	}
-	h->mmf = &mm;
-	mm.mm = (char *)lpStream;
-	mm.sz = dwMemLength;
-	mm.pos = 0;
-	pat_resetsmp();
-	pat_init_patnames();
-	mmfseek(h->mmf,8,SEEK_SET);
-	h->midiformat	= mid_read_short(h);
-	h->miditracks = mid_read_short(h);
-	h->resolution = mid_read_short(h);
-	// at this point the h->mmf is positioned at first miditrack
-	if( h->midiformat == 0 ) h->miditracks = 1;
-	if( h->resolution & 0x8000 )
-		h->divider = ((h->resolution & 0x7f00)>>8)*(h->resolution & 0xff);
-	else
-		h->divider = h->resolution;
-	h->divider <<= 2; // ticks per quartnote ==> ticks per note
-	if (!h->divider) h->divider = 1;
-	h->tempo = 122;
-	_this->m_nDefaultTempo = 0;
-	h->tracktime = 0;
-	h->speed = 6;
-	if (h->miditracks == 0) {
-		MID_Cleanup(h);
-		avoid_reentry = 0;
-		return FALSE;
-	}
-	p = (BYTE *)SDL_getenv(ENV_MMMID_SPEED);
-	if( p && SDL_isdigit(*p) && p[0] != '0' && p[1] == '\0' ) {
-		// transform speed
-		t = *p - '0';
-		h->speed *= t;
-		h->divider *= t;
-		h->speed /= 6;
-		h->divider /= 6;
-	}
-	// calculate optimal delta multiplier dmulti keeping tempo adjustments
-	// from 10 to 255 in mind (hoping there will be no midi's with tempo's
-	// lower than 10, that is sooo sick...)
-	// this is necessary for the tracks to patterns routine
-	dmulti = 1;
-	maxtempo = h->divider;
-	while( (h->midispeed = miditicks(h, h->speed)) * 10 < 255 * h->speed ) {
-		++dmulti;
-		h->divider = maxtempo * dmulti;
-	}
-	h->tp = NULL;
-	SDL_memset(buf,0,sizeof(buf));
-	maxtempo = 0;
-	panlow   = 64;
-	panhigh  = 64;
-	for( t=0; t<(uint32_t)h->miditracks; t++ ) {
-		mmreadSBYTES(buf,4,h->mmf);
-		buf[4] = '\0';
-		if( SDL_strcmp(buf,"MTrk") ) {
-			mid_message("invalid track-chunk '%s' is not 'MTrk'",buf);
-			MID_Cleanup(h);
-			avoid_reentry = 0;
-			return FALSE;
-		}
-		miditracklen = mid_read_long(h);
-		runningstatus = 0;
-		if( t && h->midiformat == 1 ) mid_rewind_tracks(h); // tracks sound simultaneously
-		while( miditracklen > 0 ) {
-			miditracklen -= mid_read_delta(h);
-			midibyte[0] = mid_read_byte(h);
-			miditracklen--;
-			if( midibyte[0] & 0x80 ) {
-				runningstatus = midibyte[0];
-				switch( runningstatus ) {
-					case 0xf1:
-					case 0xf4:
-					case 0xf5:
-					case 0xf6:
-					case 0xf7:
-					case 0xf8:
-					case 0xf9:
-					case 0xfa:
-					case 0xfb:
-					case 0xfc:
-					case 0xfd:
-					case 0xfe:
-						break;
-					default:
-						midibyte[0] = mid_read_byte(h);
-						miditracklen--;
-						break;
-				}
-			}
-			h->tracktime += dmulti * h->deltatime;
-			ch = runningstatus & 0x0f;
-			cmd = runningstatus & 0xf0;
-			switch( cmd ) {
-				case 0x80: // note off
-					midibyte[1] = mid_read_byte(h);
-					miditracklen--;
-					ttp = mid_find_track(h, ch, midibyte[0]);
-					if( ttp ) mid_add_noteoff(h, ttp);
-					break;
-				case 0x90: // note on
-					midibyte[1] = mid_read_byte(h);
-					miditracklen--;
-					if( midibyte[1] ) {
-						ttp = mid_locate_track(h, ch, midibyte[0]);
-						mid_add_noteon(h, ttp, midibyte[0], midibyte[1]);
-					}
-					else {
-						ttp = mid_find_track(h, ch, midibyte[0]);
-						if( ttp ) mid_add_noteoff(h, ttp);
-					}
-					break;
-				case 0xa0: // polyphonic key pressure
-					midibyte[1] = mid_read_byte(h);
-					miditracklen--;
-					break;
-				case 0xb0: // control change
-					midibyte[1] = mid_read_byte(h);
-					miditracklen--;
-					switch(midibyte[0]) {
-						case 0x01: // mod wheel
-							mid_mod_wheel(h, ch, midibyte[1]);
-							break;
-						case 0x07: // main volume
-							mid_main_volume(h, ch, midibyte[1]);
-							break;
-						case 0x0a: // pan
-							if( midibyte[1] < panlow )  panlow  = midibyte[1];
-							if( midibyte[1] > panhigh ) panhigh = midibyte[1];
-							mid_pan(h, ch, midibyte[1]);
-							break;
-						case 0x0b: // expression
-							break;
-						case 0x7b: 
-							if( midibyte[1] == 0x00 ) // all notes off
-								mid_all_notes_off(h, ch);
-							break;
-						default:
-							break;
-					}
-					break;
-				case 0xc0: // program change
-					mid_add_program(h, ch, midibyte[0]);
-					break;
-				case 0xd0: // channel pressure
-					break;
-				case 0xe0: // pitch wheel change
-					midibyte[1] = mid_read_byte(h);
-					miditracklen--;
-					mid_add_pitchwheel(h, ch, midishort(midibyte));
-					break;
-				case 0xf0: // system & realtime
-					switch( runningstatus ) {
-						case 0xf0:	// sysex
-							while( midibyte[0] != 0xf7 ) {
-								midibyte[0] = mid_read_byte(h);
-								miditracklen--;
-							}
-							break;
-						case 0xf2:	// song position pointer
-							midibyte[1] = mid_read_byte(h);
-							miditracklen--;
-							break;
-						case 0xf7:
-							delta = h->deltatime;
-							miditracklen -= mid_read_delta(h);
-							metalen = h->deltatime;
-							while( metalen > 0 ) {
-								midibyte[1] = mid_read_byte(h);
-								metalen--;
-								miditracklen--;
-							}
-							h->deltatime = delta;
-							break;
-						case 0xff: // meta event
-							delta = h->deltatime;
-							miditracklen -= mid_read_delta(h);
-							metalen = h->deltatime;
-							if( metalen > 31 ) metalen = 31;
-							if( metalen ) {
-								mmreadSBYTES(buf, metalen, h->mmf);
-								miditracklen -= metalen;
-							}
-							buf[metalen] = '\0';
-							metalen = h->deltatime - metalen;
-							while( metalen > 0 ) {
-								midibyte[1] = mid_read_byte(h);
-								metalen--;
-								miditracklen--;
-							}
-							h->deltatime = delta;
-							switch( midibyte[0] ) {
-								case 0x51: // type: tempo
-									p=(BYTE *)buf;
-									delta = (p[0]<<16)|(p[1]<<8)|p[2];
-									if( delta )
-										h->tempo = 60000000 / delta;
-									if( _this->m_nDefaultTempo == 0 ) _this->m_nDefaultTempo = h->tempo;
-									else {
-										ttp = h->track;
-										if( !ttp ) mid_locate_track(h, 0, 0xff);
-										mid_add_tempo_event(h,h->tempo);
-									}
-									if( h->tempo > maxtempo ) maxtempo = h->tempo;
-									break;
-								case 0x2f: // type: end of track
-									if( miditracklen > 0 ) {
-										SDL_snprintf(buf,sizeof (buf), "%u", miditracklen);
-										mid_message("Meta event not at end of track, %s bytes left in track", buf);
-										miditracklen = 0;
-									}
-									break;
-								default:
-									break;
-							}
-							break;
-						default:
-							break;
-					}
-					break;
-				default:   // no running status, just skip it...
-					break;
-			}
-			if( miditracklen < 1 && (runningstatus != 0xff || midibyte[0] != 0x2f) ) {
-				delta = mmftell(h->mmf);
-				mmreadSBYTES(buf,4,h->mmf);
-				buf[4] = '\0';
-				if( SDL_strcmp(buf,"MTrk") ) {
-					miditracklen = 0x7fffffff;
-					mid_message("Meta event not at end of track, %s bytes left in track", "superfluous");
-				}
-				else
-					mid_message("Meta event not at end of track, %s bytes left in track", "no");
-				mmfseek(h->mmf,delta,SEEK_SET);
-			}
-		}
-	}
-	// get the lowest event time and the used channels
-	delta = 0x7fffffff;
-	metalen = 0; // use as bit bucket for used channels
-	for( ttp=h->track; ttp; ttp=ttp->next ) {
-		metalen |= (1<<ttp->chan);
-		if( ttp->head ) {
-			ULONG tt;
-			tt = mid_first_noteonevent_tick(ttp->head);
-			if( tt < (ULONG)delta )
-				delta = tt;
-		}
-	}
-	if( metalen & 0x03ff ) {
-		if( (metalen & 0x0f00) == 0x0400 ) 
-			h->percussion = 10; // buggy sng2mid uses channel 10
-		else
-			h->percussion = 9;
-	}
-	else h->percussion = 15;
-	// last but not least shut off all pending events, transform drumnotes when appropriate
-	// strip off silences at begin and end and get the greatest tracktime
-	h->tracktime = 0;
-	metalen = h->midispeed;
-	for( ttp=h->track; ttp; ttp=ttp->next ) {
-		if( ttp->chan == h->percussion )
-			mid_notes_to_percussion(ttp, delta, metalen);
-		else
-			mid_prog_to_notes(ttp, delta, metalen);
-		if( ttp->tail && ttp->tail->tracktick > h->tracktime )
-			h->tracktime = ttp->tail->tracktick;
-	}
-
-	h->tracktime += h->divider >> 2; // add one quartnote to the song for silence
-	if ( h->track )
-		mid_add_partbreak(h);
-	numchans = mid_numchans(h);
-	if( panlow > 48 || panhigh < 80 ) {
-		for( ttp=h->track; ttp; ttp=ttp->next ) {
-			ttp->balance = ((0x40*numchans+0x80*mid_ordchan(h, ttp->chan))/numchans)&0x7f;
-		}
-	}
-	// set module variables
-	numtracks = mid_numtracks(h);
-	if( _this->m_nDefaultTempo == 0 ) _this->m_nDefaultTempo = h->tempo;
-	if( maxtempo == 0 ) maxtempo = h->tempo;
-	if( maxtempo != 255 ) {
-		mid_adjust_for_optimal_tempo(h, maxtempo);
-	}
-	if( maxtempo > 0 ) _this->m_nDefaultTempo = (255 * _this->m_nDefaultTempo) / maxtempo;
-
-	numpats = 1 + (modticks(h, h->tracktime) / h->speed / 64 );
-	if (numpats > MAX_PATTERNS) numpats = MAX_PATTERNS;
-
-	_this->m_nType         = MOD_TYPE_MID;
-	_this->m_nDefaultSpeed = h->speed;
-	_this->m_nChannels     = numtracks;
-	_this->m_dwSongFlags   = SONG_LINEARSLIDES;
-	_this->m_nMinPeriod    = 28 << 2;
-	_this->m_nMaxPeriod    = 1712 << 3;
-	if (_this->m_nChannels == 0)
-		return FALSE;
-	// orderlist
-	for(t=0; t < numpats; t++)
-		_this->Order[t] = t;
-	if( !PAT_Load_Instruments(_this) ) {
-		avoid_reentry = 0;
-		return FALSE;
-	}
-	// ==============================
-	// Load the pattern info now!
-	if( MID_ReadPatterns(_this->Patterns, _this->PatternSize, h, numpats, _this->m_nChannels) ) {
-		// :^(  need one more channel to handle the global events ;^b
-		_this->m_nChannels++;
-		h->tp = mid_new_track(h, h->track->chan, 0xff);
-		for( ttp=h->track; ttp->next; ttp=ttp->next ) ;
-		ttp->next = h->tp;
-		mid_add_sync(h, h->tp);
-		for( t=0; t<numpats; t++ ) {
-			CSoundFile_FreePattern(_this->Patterns[t]);
-			_this->Patterns[t] = NULL;
-		}
-		MID_ReadPatterns(_this->Patterns, _this->PatternSize, h, numpats, _this->m_nChannels);
-	}
-	// ============================================================
-	// set panning positions
-	t = 0;
-	for( ttp=h->track; ttp; ttp=ttp->next ) {
-		_this->ChnSettings[t].nPan    = modpan(ttp->balance, numchans / 2);
-		_this->ChnSettings[t].nVolume = 64;
-		t++;
-	}
-	MID_Cleanup(h);	// we dont need it anymore
-	avoid_reentry = 0; // it is safe now, I'm finished
-	return TRUE;
-}
-