paplayer: drop obsolete codecs from lib

1 files changed, 0 insertions, 2020 deletions

diff --git a/lib/libmodplug/src/load_mid.cpp b/lib/libmodplug/src/load_mid.cpp
deleted file mode 100644
index 5a84b3500b..0000000000
--- a/lib/libmodplug/src/load_mid.cpp
+++ /dev/null
@@ -1,2020 +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 "stdafx.h"
-
-#ifdef NEWMIKMOD
-#include "mikmod.h"
-#include "uniform.h"
-#include "itshare.h" // for STMEM_PITCHSLIDE
-typedef UBYTE BYTE;
-typedef UWORD WORD;
-#define MAX_POLYPHONY 12  // max notes in one midi channel
-#define MAX_TRACKS    63  // max mod tracks
-#define WHEELSHIFT    11  // how many bits the 13bit midi wheel value must shift right 
-#else
-#include "stdafx.h"
-#include "sndfile.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 
-#endif
-
-#include "load_pat.h"
-
-#define ROWSPERNOTE 16
-#define ENV_MMMID_SPEED	"MMMID_SPEED"
-#define ENV_MMMID_DEBUG "MMMID_DEBUG"
-#define ENV_MMMID_VERBOSE "MMMID_VERBOSE"
-
-/**************************************************************************
-**************************************************************************/
-#ifdef NEWMIKMOD
-static char  MID_Version[] = "Musical Instrument Digital Interface";
-#endif
-
-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;
-
-#ifdef NEWMIKMOD
-
-#define MMFILE						MMSTREAM
-#define mmfseek(f,p,w)		_mm_fseek(f,p,w)
-#define mmftell(x)				_mm_ftell(x)
-#define mmreadUBYTE(f)	_mm_read_UBYTE(f)
-#define mmreadSBYTES(buf,sz,f)	_mm_read_SBYTES(buf,sz,f)
-#define mmreadUBYTES(buf,sz,f)	_mm_read_UBYTES(buf,sz,f)
-
-#else
-
-#define MMSTREAM										FILE
-#define _mm_fseek(f,pos,whence)			fseek(f,pos,whence)
-#define _mm_read_UBYTES(buf,sz,f)		fread(buf,sz,1,f)
-#define _mm_read_SBYTES(buf,sz,f)		fread(buf,sz,1,f)
-#define DupStr(h,buf,sz)						strdup(buf)
-#define _mm_calloc(h,n,sz)					calloc(n,sz)
-#define _mm_recalloc(h,buf,sz,elsz)	realloc(buf,sz)
-#undef  _mm_free
-#define _mm_free(h,p)								free(p)
-
-typedef struct {
-	char *mm;
-	int sz;
-	int pos;
-} MMFILE;
-
-static void mmfseek(MMFILE *mmfile, long p, int whence)
-{
-	switch(whence) {
-		case SEEK_SET:
-			mmfile->pos = p;
-			break;
-		case SEEK_CUR:
-			mmfile->pos += p;
-			break;
-		case SEEK_END:
-			mmfile->pos = mmfile->sz + p;
-			break;
-	}
-}
-
-static long mmftell(MMFILE *mmfile)
-{
-	return mmfile->pos;
-}
-
-static BYTE mmreadUBYTE(MMFILE *mmfile)
-{
-	BYTE b;
-	b = (BYTE)mmfile->mm[mmfile->pos];
-	mmfile->pos++;
-	return b;
-}
-
-static void mmreadUBYTES(BYTE *buf, long sz, MMFILE *mmfile)
-{
-	memcpy(buf, &mmfile->mm[mmfile->pos], sz);
-	mmfile->pos += sz;
-}
-
-static void mmreadSBYTES(char *buf, long sz, MMFILE *mmfile)
-{
-	memcpy(buf, &mmfile->mm[mmfile->pos], sz);
-	mmfile->pos += sz;
-}
-
-#endif
-
-/**************************************************************************
-**************************************************************************/
-
-typedef struct _MIDHANDLE
-{
-#ifdef NEWMIKMOD
-	MM_ALLOC *allochandle;
-	MM_ALLOC *trackhandle;
-#endif
-	MMFILE *mmf;
-	MIDTRACK *track;
-	MIDTRACK *tp;
-	ULONG tracktime;
-	const char *debug;
-	const char *verbose;
-	int speed;
-	int midispeed;
-	int midiformat;
-	int resolution;
-	int miditracks;
-	int divider;
-	int tempo;
-	int percussion;
-	long deltatime;
-} MIDHANDLE;
-
-static void mid_dump_tracks(MIDHANDLE *h)
-{
-	MIDTRACK *tr;
-	MIDEVENT *e;
-	int t;
-	printf("tracktime  = %ld\n", (long)(h->tracktime));
-	printf("speed      = %d\n", h->speed);
-	printf("midispeed  = %d\n", h->midispeed);
-	printf("midiformat = %d\n", h->midiformat);
-	printf("resolution = %d\n", h->resolution);
-	printf("miditracks = %d\n", h->miditracks);
-	printf("divider    = %d\n", h->divider);
-	printf("tempo      = %d\n", h->tempo);
-	printf("percussion = %d\n", h->percussion);
-	printf("deltatime  = %ld\n", h->deltatime);
-	t = 0;
-	for( tr=h->track; tr; tr = tr->next ) {
-		t++;
-		printf("TRACK %2d chan=%d note=0x%02x vol=%d pan=0x%02x instr=%d\n", t, tr->chan + 1, tr->vpos, tr->balance, tr->volume, tr->instr);
-		for( e=tr->head; e; e=e->next ) {
-			printf("%2d %6ld %s %3d %3d %3d ",
-			       t, (long)(e->tracktick),
-			       e->flg? "NOTE": "CTRL", e->note, e->volume, e->smpno);
-			switch(	e->fx ) {
-				case fxbrk: printf("fxbrk\n");break;
-				case fxsync: printf("fxsync\n");break;
-				case prog:	printf("prog %d\n", e->fxparam);break;
-				case mainvol:	printf("mainvol %d\n", e->fxparam);break;
-				case modwheel:	printf("modwheel %d\n", e->fxparam);break;
-				case wheeldown:	printf("wheeldown %d\n", e->fxparam);break;
-				case wheelup:	printf("wheelup %d\n", e->fxparam);break;
-				case tmpo:	printf("tmpo %d\n", e->fxparam);break;
-				default: printf("\n");break;
-			}
-		}
-	}
-}
-
-static void mid_message(const char *s1, const char *s2)
-{
-	char txt[256];
-	if( strlen(s1) + strlen(s2) > 255 ) return;
-	sprintf(txt, s1, s2);
-#ifdef NEWMIKMOD
-	_mmlog(txt);
-#else
-	fprintf(stderr, "load_mid > %s\n", txt);
-#endif
-}
-
-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->verbose && t > maxtempo )
-		printf("Adjusted maximum tempo from %d to %d to get %d miditicks per patternrow\n",
-			maxtempo, 2 * maxtempo - t, h->midispeed);
-	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;
-	if( h->debug ) printf("%ld %d all notes off\n",(long)(h->tracktime), mch+1);
-	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);
-		}
-	}
-}
-
-#ifndef NEWMIKMOD
-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);
-}
-#endif
-
-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 long int 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;
-}
-
-// =====================================================================================
-#ifdef NEWMIKMOD
-BOOL MID_Test(MMSTREAM *mmfile)
-#else
-BOOL CSoundFile::TestMID(const BYTE *lpStream, DWORD dwMemLength)
-#endif
-// =====================================================================================
-{
-	char id[5];
-	MIDHANDLE h;
-#ifdef NEWMIKMOD
-	h.mmf = mmfile;
-#else
-	MMFILE mm;
-	mm.mm = (char *)lpStream;
-	mm.sz = dwMemLength;
-	h.mmf = &mm;
-#endif
-	mmfseek(h.mmf,0,SEEK_SET);
-	mmreadSBYTES(id, 4, h.mmf);
-	id[4] = '\0';
-	return !strcmp(id,"MThd") && mid_read_long(&h) == 6;
-}
-
-// =====================================================================================
-static MIDHANDLE *MID_Init(void)
-{
-	MIDHANDLE *retval;
-#ifdef NEWMIKMOD
-	MM_ALLOC *allochandle;
-	
-	allochandle = _mmalloc_create("Load_MID", NULL);
-	retval = (MIDHANDLE *)_mm_calloc(allochandle, 1,sizeof(MIDHANDLE));
-	if( !retval ) return NULL;
-	retval->allochandle = allochandle;
-	allochandle = _mmalloc_create("Load_ABC_tracks", NULL);
-	retval->trackhandle = allochandle;
-#else
-	retval = (MIDHANDLE *)calloc(1,sizeof(MIDHANDLE));
-	if( !retval ) return NULL;
-#endif
-	retval->track      = NULL;
-	retval->percussion = 0;
-	retval->debug      = NULL;
-	return retval;
-}
-
-#ifndef NEWMIKMOD
-static void MID_CleanupTrack(MIDTRACK *tp)
-{
-	MIDEVENT *ep, *en;
-	if( tp ) {
-		for( ep=tp->head; ep; ep = en ) {
-			en=ep->next;
-			free(ep);
-		}
-		tp->head = NULL;
-	}
-}
-#endif
-
-// =====================================================================================
-static void MID_CleanupTracks(MIDHANDLE *handle)
-// =====================================================================================
-{
-#ifdef NEWMIKMOD
-	if(handle && handle->trackhandle) {
-		_mmalloc_close(handle->trackhandle);
-		handle->trackhandle = 0;
-	}
-#else
-	MIDTRACK *tp, *tn;
-	if(handle) {
-		for( tp=handle->track; tp; tp = tn ) {
-			tn=tp->next;
-			MID_CleanupTrack(tp);
-		}
-		handle->track = NULL;
-	}
-#endif
-}
-
-// =====================================================================================
-static void MID_Cleanup(MIDHANDLE *handle)
-// =====================================================================================
-{
-#ifdef NEWMIKMOD
-	if(handle && handle->allochandle) {
-		MID_CleanupTracks(handle);
-		_mmalloc_close(handle->allochandle);
-		handle->allochandle = 0;
-	}
-#else
-	if(handle) {
-		MID_CleanupTracks(handle);
-		free(handle);
-		handle = 0;
-	}
-#endif
-}
-
-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;
-}
-
-// =====================================================================================
-#ifdef NEWMIKMOD
-static void MID_ReadPatterns(UNIMOD *of, MIDHANDLE *h, int numpat)
-// =====================================================================================
-{
-	int pat,row,i,ch,trkset;
-	BYTE n,ins,vol;
-	MIDTRACK *t;
-	MIDEVENT *e, *en, *ef, *el;
-	ULONG tt1, tt2;
-	UNITRK_EFFECT eff;
-
-	// 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++ ) {
-		utrk_reset(of->ut);
-		for( row = 0; row < 64; row++ ) {
-			tt1 = miditicks(h, (pat * 64 + row ) * h->speed);
-			tt2 = tt1 + h->midispeed;
-			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:
-							eff.effect   = UNI_GLOB_TEMPO;
-							eff.param.u  = e->fxparam;
-							eff.framedly = UFD_RUNONCE;
-							utrk_write_global(of->ut, &eff, PTMEM_TEMPO);
-							break;
-						case fxbrk:
-							eff.effect   = UNI_GLOB_PATBREAK;
-							eff.param.u  = 0;
-							eff.framedly = UFD_RUNONCE;
-							utrk_write_global(of->ut, &eff, UNIMEM_NONE);
-							break;
-					}
-				}
-			}
-			ch = 0;
-			for( t = h->track; t; t = t->next ) {
-				trkset = 0;
-				e = NULL;
-				for( el=mid_next_fx(t->workevent); el && el->tracktick < tt2; el=mid_next_fx(el->next) ) {
-					if( el && el->tracktick >= tt1 ) {
-						switch( el->fx ) {
-							case modwheel:
-							case wheelup:
-							case wheeldown:
-								e = el;
-							default:
-								break;
-						}
-					}
-				}
-				if( e )	{	// we have a controller event in this row
-					switch( e->fx ) {
-						case modwheel:
-							if( !trkset ) {
-								utrk_settrack(of->ut, ch);
-								trkset = 1;
-							}
-							eff.effect   = UNI_VOLSLIDE;
-							eff.framedly = UFD_RUNONCE;
-							if( (e->fxparam & 0x0f) == 0x0f )
-								eff.param.s = (e->fxparam >> 3)&0x1f;
-							else
-								eff.param.s = -((e->fxparam & 0x0f)*2);
-							utrk_write_local(of->ut, &eff, STMEM_VOLSLIDE);
-							break;
-						case wheelup:
-							if( !trkset ) {
-								utrk_settrack(of->ut, ch);
-								trkset = 1;
-							}
-							eff.effect   = UNI_PITCHSLIDE;
-							eff.framedly = UFD_RUNONCE;
-							eff.param.s = e->fxparam;
-							utrk_write_local(of->ut, &eff, STMEM_PITCHSLIDE);
-							break;
-						case wheeldown:
-							if( !trkset ) {
-								utrk_settrack(of->ut, ch);
-								trkset = 1;
-							}
-							eff.effect   = UNI_PITCHSLIDE;
-							eff.framedly = UFD_RUNONCE;
-							eff.param.s = -(int)(e->fxparam);
-							utrk_write_local(of->ut, &eff, STMEM_PITCHSLIDE);
-							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( !trkset ) {
-						utrk_settrack(of->ut, ch);
-						trkset = 1;
-					}
-					if( i == 1 || ef == el || !ef ) { // only one event in this row
-						if( ef ) e = ef;
-						else e = en;
-						el  = t->workevent;
-						n   = pat_modnote(e->note);
-						ins = e->smpno;
-						eff.framedly = modticks(h, e->tracktick - tt1);
-						eff.param.u      = 0;
-						eff.param.byte_a = n;
-						eff.param.byte_b = ins;
-						vol = e->volume;
-						if( vol == 0 ) {
-							eff.effect  = UNI_NOTEKILL;
-							utrk_write_local(of->ut, &eff, UNIMEM_NONE);
-						}
-						else {
-							if( el->volume == 0 ) {
-								eff.framedly     = modticks(h, el->tracktick - tt1);
-								eff.effect       = UNI_NOTEKILL;
-								utrk_write_local(of->ut, &eff, UNIMEM_NONE);
-							}
-							else {
-								if( eff.framedly ) {
-									eff.effect       = UNI_NOTEDELAY;
-									utrk_write_local(of->ut, &eff, UNIMEM_NONE);
-								}
-							}
-						}
-						utrk_write_inst(of->ut, ins);
-						utrk_write_note(of->ut, n); // <- normal note
-						pt_write_effect(of->ut, 0xc, 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;
-						eff.effect    = UNI_PITCHSLIDE;
-						eff.framedly  = modticks(h, el->tracktick - tt1)|UFD_RUNONCE;
-						eff.param.s   = ((i > n)?i-n:n-i);
-						utrk_write_inst(of->ut, ins);
-						utrk_write_note(of->ut, n); // <- normal note
-						pt_write_effect(of->ut, 0xc, vol);
-						utrk_write_local(of->ut, &eff, (i > n)? PTMEM_PITCHSLIDEUP: PTMEM_PITCHSLIDEDN);
-					}
-				}
-				ch++;
-			}
-			utrk_newline(of->ut);
-		}
-		if(!utrk_dup_pattern(of->ut,of)) return;
-	}
-}
-
-#else
-
-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;
-			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;
-}
-
-#endif
-
-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)
-{
-#ifndef NEWMIKMOD
-	MIDEVENT *ep, *en;
-	for( ep=e->next; ep; ep = en ) {
-		en=ep->next;
-		free(ep);
-	}
-#endif
-	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];
-		sprintf(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];
-		sprintf(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;
-}
-
-// =====================================================================================
-#ifdef NEWMIKMOD
-BOOL MID_Load(MIDHANDLE *h, UNIMOD *of, MMSTREAM *mmfile)
-#else
-BOOL CSoundFile::ReadMID(const BYTE *lpStream, DWORD dwMemLength)
-#endif
-{
-	static int avoid_reentry = 0;
-#ifdef NEWMIKMOD
-#define m_nDefaultTempo	of->inittempo
-#else
-	MIDHANDLE *h;
-	MMFILE mm;
-#endif
-	int ch, dmulti, maxtempo, panlow, panhigh, numchans, numtracks;
-	MIDTRACK *ttp;
-	uint32_t t, numpats;
-	char buf[256];
-	long miditracklen;
-	BYTE runningstatus;
-	BYTE cmd;
-	BYTE midibyte[2];
-	long metalen, delta;
-	BYTE *p;
-	while( avoid_reentry ) sleep(1);
-	avoid_reentry = 1;
-#ifdef NEWMIKMOD
-	h->mmf = mmfile;
-#else
-	if( !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;
-#endif
-	h->debug = getenv(ENV_MMMID_DEBUG);
-	h->verbose = getenv(ENV_MMMID_VERBOSE);
-	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
-	h->tempo = 122;
-	m_nDefaultTempo = 0;
-	h->tracktime = 0;
-	h->speed = 6;
-	p = (BYTE *)getenv(ENV_MMMID_SPEED);
-	if( p && 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;
-	memset(buf,0,sizeof(buf));
-#ifdef NEWMIKMOD
-	of->songname = NULL;
-#else
-	strcpy(m_szNames[0], "");
-#endif
-	maxtempo = 0;
-	panlow   = 64;
-	panhigh  = 64;
-	if( h->verbose ) {
-		printf("Scanning MIDI with format: %d resolution: %d tracks: %d\n",
-			h->midiformat,
-			h->resolution,
-			h->miditracks);
-	}
-	if( h->verbose && dmulti > 1 ) {
-		printf("Multiplying resolution and deltatimes by %d to get %d miditicks per patternrow\n",
-			dmulti, h->midispeed);
-	}
-	for( t=0; t<(uint32_t)h->miditracks; t++ ) {
-		if( h->verbose ) printf("Parsing track %d\n", t+1);
-		mmreadSBYTES(buf,4,h->mmf);
-		buf[4] = '\0';
-		if( strcmp(buf,"MTrk") ) {
-			mid_message("invalid track-chunk '%s' is not 'MTrk'",buf);
-			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);
-					if( h->debug )
-						printf("%2d %08ld       Note off: ch %d 0x%02x 0x%02x\n",
-						       t, (long)(h->tracktime),
-						       ch + 1, midibyte[0], midibyte[1]);
-					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]);
-						if( h->debug )
-							printf("%2d %08ld Note  on: ch %d 0x%02x 0x%02x\n",
-							       t, (long)(h->tracktime),
-							       ch + 1, midibyte[0], midibyte[1]);
-					}
-					else {
-						ttp = mid_find_track(h, ch, midibyte[0]);
-						if( ttp ) mid_add_noteoff(h, ttp);
-						if( h->debug )
-							printf("%2d %08ld note off: ch %d 0x%02x\n",
-							t, (long)(h->tracktime),
-							ch + 1, midibyte[0]);
-					}
-					break;
-				case 0xa0: // polyphonic key pressure
-					midibyte[1] = mid_read_byte(h);
-					miditracklen--;
-					if( h->debug )
-						printf("%2d %08ld polyphonic key pressure: ch %d 0x%02x 0x%02x\n", t, (long)(h->tracktime), ch + 1, midibyte[0], midibyte[1]);
-					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;
-					}
-					if( h->debug )
-						printf("%2d %08ld control change: ch %d 0x%02x 0x%02x\n",
-						t, (long)(h->tracktime), ch + 1, midibyte[0], midibyte[1]);
-					break;
-				case 0xc0: // program change
-					mid_add_program(h, ch, midibyte[0]);
-					if( h->debug )
-						printf("%2d %08ld program change: ch %d %d\n",
-						t, (long)(h->tracktime), ch + 1, midibyte[0]);
-					break;
-				case 0xd0: // channel pressure
-					if( h->debug )
-						printf("%2d %08ld channel pressure: ch %d 0x%02x\n", t, (long)(h->tracktime), ch + 1, midibyte[0]);
-					break;
-				case 0xe0: // pitch wheel change
-					midibyte[1] = mid_read_byte(h);
-					miditracklen--;
-					if( h->debug )
-						printf("%2d %08ld pitch wheel change: ch %d %d\n",
-						t, (long)(h->tracktime), ch + 1, midishort(midibyte));
-					mid_add_pitchwheel(h, ch, midishort(midibyte));
-					break;
-				case 0xf0: // system & realtime
-					switch( runningstatus ) {
-						case 0xf0:	// sysex
-							if( h->debug ) printf("%2d %08ld sysex: 0x%02x",
-								t, (long)(h->tracktime), midibyte[0]);
-							while( midibyte[0] != 0xf7 ) {
-								midibyte[0] = mid_read_byte(h);
-								miditracklen--;
-								if( h->debug ) printf(" %02X", midibyte[0]);
-							}
-							if( h->debug ) printf("\n");
-							break;
-						case 0xf2:	// song position pointer
-							midibyte[1] = mid_read_byte(h);
-							miditracklen--;
-							if( h->debug )
-								printf("%2d %08ld song position pointer: %d", 
-								t, (long)(h->tracktime), midishort(midibyte));
-							break;
-						case 0xf7:
-							delta = h->deltatime;
-							miditracklen -= mid_read_delta(h);
-							metalen = h->deltatime;
-							if( h->debug )
-								printf("%2d %08ld sysex continued: %ld",
-								t, (long)(h->tracktime), metalen);
-							while( metalen > 0 ) {
-								midibyte[1] = mid_read_byte(h);
-								metalen--;
-								miditracklen--;
-								if( h->debug ) printf(" %02X", midibyte[1]);
-							}
-							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 0x03: // type: track name
-									if( h->debug )
-										printf("%2d %08ld META trackname:%s\n", t, (long)(h->tracktime), buf);
-#ifdef NEWMIKMOD
-									if( !of->songname )
-										of->songname = DupStr(of->allochandle, buf, strlen(buf));
-#else
-									if( m_szNames[0][0] == '\0' )
-										strcpy(m_szNames[0], buf);
-#endif
-									break;
-								case 0x51: // type: tempo
-									p=(BYTE *)buf;
-									delta = (p[0]<<16)|(p[1]<<8)|p[2];
-									if( delta )
-										h->tempo = 60000000 / delta;
-									if( h->debug ) printf("%2d %08ld META tempo:%d\n", t, (long)(h->tracktime), h->tempo);
-									if( m_nDefaultTempo == 0 ) m_nDefaultTempo = h->tempo;
-									else {
-										ttp = h->track;
-										if( !ttp ) 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( h->debug ) printf("%2d %08ld META end of track\n", t, (long)(h->tracktime));
-									if( miditracklen > 0 ) {
-										sprintf(buf, "%ld", miditracklen);
-										mid_message("Meta event not at end of track, %s bytes left in track", buf);
-										miditracklen = 0;
-									}
-									break;
-								default:
-									if( h->debug ) printf("%2d %08ld META type 0x%02x\n", t, (long)(h->tracktime), midibyte[0]);
-									break;
-							}
-							break;
-						default:
-							if( h->debug ) printf("%2d %08ld System type 0x%02x\n", t, (long)(h->tracktime), midibyte[0]);
-							break;
-					}
-					break;
-				default:   // no running status, just skip it...
-					if( h->debug ) printf("%2d %08ld unknown runningstatus: 0x%02x skipped:0x%02x\n", t, (long)(h->tracktime), runningstatus, midibyte[0]);
-					break;
-			}
-			if( miditracklen < 1 && (runningstatus != 0xff || midibyte[0] != 0x2f) ) {
-				delta = mmftell(h->mmf);
-				mmreadSBYTES(buf,4,h->mmf);
-				buf[4] = '\0';
-				if( 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);
-			}
-		}
-	}
-	if( h->verbose ) printf("Determining percussion channel\n");
-	// 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;
-	if( h->verbose )
-		printf("Percussion channel is %d\nStripping off silences and other optimalisations\n", h->percussion + 1);
-	// 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
-	mid_add_partbreak(h);
-	if( h->debug )
-		mid_dump_tracks(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( m_nDefaultTempo == 0 ) m_nDefaultTempo = h->tempo;
-	if( maxtempo == 0 ) maxtempo = h->tempo;
-	if( maxtempo != 255 ) {
-		if( h->verbose ) printf("Adjusting tempo %d to 255\n", maxtempo);
-		mid_adjust_for_optimal_tempo(h, maxtempo);
-	}
-	if( maxtempo > 0 ) m_nDefaultTempo = (255 * m_nDefaultTempo) / maxtempo;
-	numpats = 1 + (modticks(h, h->tracktime) / h->speed / 64 );
-	if( h->verbose ) printf("Generating %d patterns with speed %d\n", numpats, h->speed);
-#ifdef NEWMIKMOD
-	if( !of->songname ) of->songname = DupStr(of->allochandle, "Untitled", 8);
-	of->memsize     = STMEM_LAST;      // Number of memory slots to reserve!
-	of->modtype     = _mm_strdup(of->allochandle, MID_Version);
-	of->numpat      = numpats;
-	of->numpos      = of->numpat;
-	of->reppos      = 0;
-	of->initspeed   = h->speed;
-	of->numchn      = numtracks;
-	of->numtrk      = of->numpat * of->numchn;
-	of->initvolume  = 64;
-	of->pansep      = 128;
-	// orderlist
-	if(!AllocPositions(of, of->numpos)) {
-		avoid_reentry = 0;
-		return FALSE;
-	}
-	for(t=0; t<of->numpos; t++)
-		of->positions[t] = t;
-	if( !PAT_Load_Instruments(of) ) {
-		avoid_reentry = 0;
-		return FALSE;
-	}
-	// ==============================
-	// Load the pattern info now!
-	if(!AllocTracks(of)) {
-		avoid_reentry = 0;
-		return FALSE;
-	}
-	if(!AllocPatterns(of)) {
-		avoid_reentry = 0;
-		return FALSE;
-	}
-	of->ut = utrk_init(of->numchn, h->allochandle);
-	utrk_memory_reset(of->ut);
-	utrk_local_memflag(of->ut, PTMEM_PORTAMENTO, TRUE, FALSE);
-	MID_ReadPatterns(of, h, numpats);
-	// ============================================================
-	// set panning positions
-	t = 0;
-	for( ttp=h->track; ttp; ttp=ttp->next ) {
-		of->panning[t] = modpan(ttp->balance, numchans / 2);
-		t++;
-	}
-#else
-	m_nType         = MOD_TYPE_MID;
-	m_nDefaultSpeed = h->speed;
-	m_nChannels     = numtracks;
-	m_dwSongFlags   = SONG_LINEARSLIDES;
-	m_nMinPeriod    = 28 << 2;
-	m_nMaxPeriod    = 1712 << 3;
-	// orderlist
-	for(t=0; t < numpats; t++)
-		Order[t] = t;
-	if( !PAT_Load_Instruments(this) ) {
-		avoid_reentry = 0;
-		return FALSE;
-	}
-	// ==============================
-	// Load the pattern info now!
-	if( MID_ReadPatterns(Patterns, PatternSize, h, numpats, m_nChannels) ) {
-		// :^(  need one more channel to handle the global events ;^b
-		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++ ) {
-			FreePattern(Patterns[t]);
-			Patterns[t] = NULL;
-		}
-		MID_ReadPatterns(Patterns, PatternSize, h, numpats, m_nChannels);
-	}
-	// ============================================================
-	// set panning positions
-	t = 0;
-	for( ttp=h->track; ttp; ttp=ttp->next ) {
-		ChnSettings[t].nPan    = modpan(ttp->balance, numchans / 2);
-		ChnSettings[t].nVolume = 64;
-		t++;
-	}
-	MID_Cleanup(h);	// we dont need it anymore
-#endif
-	if( h->verbose ) printf("Done\n");
-	avoid_reentry = 0; // it is safe now, I'm finished
-	return TRUE;
-}
-
-#ifdef NEWMIKMOD
-// =====================================================================================
-CHAR *MID_LoadTitle(MMSTREAM *mmfile)
-// =====================================================================================
-{
-	int t;
-	char buf[24];
-	long miditracklen;
-	BYTE runningstatus;
-	BYTE cmd;
-	BYTE midibyte[2];
-	long metalen;
-	MIDHANDLE hh, *h;
-	h = &hh;
-	h->mmf = mmfile;
-	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;
-	h->tracktime = 0;
-	for( t=0; t<h->miditracks; t++ ) {
-		mmreadSBYTES(buf,4,h->mmf);
-		miditracklen = mid_read_long(h);
-		runningstatus = 0;
-		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;
-				}
-			}
-			cmd = runningstatus & 0xf0;
-			switch( cmd ) {
-				case 0x80: // note off
-				case 0x90: // note on
-				case 0xa0: // polyphonic key pressure
-				case 0xb0: // control change
-				case 0xe0: // pitch wheel change
-					midibyte[1] = mid_read_byte(h);
-					miditracklen--;
-				case 0xc0: // program change
-				case 0xd0: // channel pressure
-					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:
-							miditracklen -= mid_read_delta(h);
-							metalen = h->deltatime;
-							while( metalen > 0 ) {
-								midibyte[1] = mid_read_byte(h);
-								metalen--;
-								miditracklen--;
-							}
-							break;
-						case 0xff: // meta event
-							miditracklen -= mid_read_delta(h);
-							metalen = h->deltatime;
-							if( metalen > 21 ) metalen = 21;
-							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--;
-							}
-							switch( midibyte[0] ) {
-								case 0x03: // type: track name
-									return DupStr(NULL, buf, strlen(buf));
-									break;
-								case 0x2f: // type: end of track
-									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) ) {
-				metalen = mmftell(h->mmf);
-				mmreadSBYTES(buf,4,h->mmf);
-				buf[4] = '\0';
-				if( strcmp(buf,"MTrk") ) miditracklen = 0x7fffffff;
-				mmfseek(h->mmf,metalen,SEEK_SET);
-			}
-		}
-	}
-	return DupStr(NULL, "Untitled" ,8);
-}
-
-MLOADER load_mid =
-{
-    "MID",
-    "Musical Instrument Digital Interface",
-    0x30,
-    NULL,
-    MID_Test,
-    (void *(*)(void))MID_Init,
-    (void (*)(ML_HANDLE *))MID_Cleanup,
-    /* Every single loader seems to need one of these! */
-    (BOOL (*)(ML_HANDLE *, UNIMOD *, MMSTREAM *))MID_Load,
-    MID_LoadTitle
-};
-#endif