moved DUMB to dynamic plugin

184 files changed, 50326 insertions, 0 deletions

diff --git a/plugins/dumb/Makefile.am b/plugins/dumb/Makefile.am
new file mode 100644
index 00000000..5beff7a9
--- /dev/null
+++ b/plugins/dumb/Makefile.am
@@ -0,0 +1,106 @@
+dumbpath=@top_srcdir@/plugins/dumb/dumb-kode54
+
+EXTRA_DIST = $(dumbpath)/readme.txt $(dumbpath)/ChangeLog $(dumbpath)/licence.txt $(dumbpath)/release.txt $(dumbpath)/todo.txt
+
+pkglib_LTLIBRARIES = dumb.la
+
+AM_CFLAGS = $(CFLAGS) -I$(dumbpath)/include
+dumb_la_LDFLAGS = -module
+
+dumb_la_SOURCES =\
+dumb-kode54/src/it/readam.c\
+dumb-kode54/src/it/readstm.c\
+dumb-kode54/src/it/loads3m.c\
+dumb-kode54/src/it/loadxm.c\
+dumb-kode54/src/it/ptmeffect.c\
+dumb-kode54/src/it/loadstm.c\
+dumb-kode54/src/it/readxm.c\
+dumb-kode54/src/it/itorder.c\
+dumb-kode54/src/it/loadpsm.c\
+dumb-kode54/src/it/itload.c\
+dumb-kode54/src/it/loadasy2.c\
+dumb-kode54/src/it/readasy.c\
+dumb-kode54/src/it/loadasy.c\
+dumb-kode54/src/it/read669.c\
+dumb-kode54/src/it/readdsmf.c\
+dumb-kode54/src/it/reads3m.c\
+dumb-kode54/src/it/readriff.c\
+dumb-kode54/src/it/load6692.c\
+dumb-kode54/src/it/read6692.c\
+dumb-kode54/src/it/readmod2.c\
+dumb-kode54/src/it/loadriff2.c\
+dumb-kode54/src/it/xmeffect.c\
+dumb-kode54/src/it/loadmod2.c\
+dumb-kode54/src/it/itread.c\
+dumb-kode54/src/it/itunload.c\
+dumb-kode54/src/it/loadmtm2.c\
+dumb-kode54/src/it/loadptm.c\
+dumb-kode54/src/it/itload2.c\
+dumb-kode54/src/it/loadmtm.c\
+dumb-kode54/src/it/loadoldpsm.c\
+dumb-kode54/src/it/loadstm2.c\
+dumb-kode54/src/it/readstm2.c\
+dumb-kode54/src/it/readptm.c\
+dumb-kode54/src/it/itrender.c\
+dumb-kode54/src/it/readoldpsm.c\
+dumb-kode54/src/it/reads3m2.c\
+dumb-kode54/src/it/readpsm.c\
+dumb-kode54/src/it/itread2.c\
+dumb-kode54/src/it/loads3m2.c\
+dumb-kode54/src/it/loadpsm2.c\
+dumb-kode54/src/it/loadxm2.c\
+dumb-kode54/src/it/loadptm2.c\
+dumb-kode54/src/it/readxm2.c\
+dumb-kode54/src/it/itmisc.c\
+dumb-kode54/src/it/loadoldpsm2.c\
+dumb-kode54/src/it/readmod.c\
+dumb-kode54/src/it/loadmod.c\
+dumb-kode54/src/it/loadriff.c\
+dumb-kode54/src/it/readmtm.c\
+dumb-kode54/src/it/load669.c\
+dumb-kode54/src/core/rendduh.c\
+dumb-kode54/src/core/readduh.c\
+dumb-kode54/src/core/duhlen.c\
+dumb-kode54/src/core/loadduh.c\
+dumb-kode54/src/core/unload.c\
+dumb-kode54/src/core/duhtag.c\
+dumb-kode54/src/core/register.c\
+dumb-kode54/src/core/rawsig.c\
+dumb-kode54/src/core/dumbfile.c\
+dumb-kode54/src/core/rendsig.c\
+dumb-kode54/src/core/makeduh.c\
+dumb-kode54/src/core/atexit.c\
+dumb-kode54/src/helpers/clickrem.c\
+dumb-kode54/src/helpers/silence.c\
+dumb-kode54/src/helpers/stdfile.c\
+dumb-kode54/src/helpers/resample.c\
+dumb-kode54/src/helpers/riff.c\
+dumb-kode54/src/helpers/memfile.c\
+dumb-kode54/src/helpers/sampbuf.c\
+dumb-kode54/src/helpers/barray.c\
+dumb-kode54/studio/include/guitop.h\
+dumb-kode54/studio/include/dumbgui.h\
+dumb-kode54/studio/include/options.h\
+dumb-kode54/studio/include/subclip.h\
+dumb-kode54/studio/include/main.h\
+dumb-kode54/studio/include/guiproc.h\
+dumb-kode54/studio/include/dumbmenu.h\
+dumb-kode54/studio/include/dumbdesk.h\
+dumb-kode54/src/tools/it/modulus.h\
+dumb-kode54/include/internal/it.h\
+dumb-kode54/include/internal/dumb.h\
+dumb-kode54/include/internal/barray.h\
+dumb-kode54/include/internal/riff.h\
+dumb-kode54/include/internal/aldumb.h\
+dumb-kode54/include/dumb.h\
+dumb-kode54/include/aldumb.h\
+dumb-kode54/winamp/in_duh.h\
+dumb-kode54/winamp/in2.h\
+dumb-kode54/winamp/resource.h\
+dumb-kode54/winamp/out.h\
+dumb-kode54/winamp/gui.h\
+dumb-kode54/src/helpers/resample.inc\
+dumb-kode54/src/helpers/resamp2.inc\
+dumb-kode54/src/helpers/resamp3.inc\
+cdumb.c
+
diff --git a/plugins/dumb/cdumb.c b/plugins/dumb/cdumb.c
new file mode 100644
index 00000000..d60c7397
--- /dev/null
+++ b/plugins/dumb/cdumb.c
@@ -0,0 +1,823 @@
+/*
+    DeaDBeeF - ultimate music player for GNU/Linux systems with X11
+    Copyright (C) 2009-2010 Alexey Yakovenko <waker@users.sourceforge.net>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "dumb.h"
+#include "internal/it.h"
+#include "deadbeef.h"
+
+//#define trace(...) { fprintf(stderr, __VA_ARGS__); }
+#define trace(fmt,...)
+
+static DB_decoder_t plugin;
+static DB_functions_t *deadbeef;
+
+typedef struct {
+    DB_fileinfo_t info;
+    DUH *duh;
+    DUH_SIGRENDERER *renderer;
+} dumb_info_t;
+
+//#define DUMB_RQ_ALIASING
+//#define DUMB_RQ_LINEAR
+//#define DUMB_RQ_CUBIC
+//#define DUMB_RQ_N_LEVELS
+extern int dumb_resampling_quality;
+extern int dumb_it_max_to_mix;
+
+static int
+cdumb_startrenderer (DB_fileinfo_t *_info);
+
+static DUH*
+open_module(const char *fname, const char *ext, int *start_order, int *is_it, int *is_dos, const char **filetype);
+
+static DB_fileinfo_t *
+cdumb_init (DB_playItem_t *it) {
+    trace ("cdumb_init %s\n", it->fname);
+    DB_fileinfo_t *_info = malloc (sizeof (dumb_info_t));
+    dumb_info_t *info = (dumb_info_t *)_info;
+    memset (_info, 0, sizeof (dumb_info_t));
+
+    int start_order = 0;
+	int is_dos, is_it;
+    const char *ext = it->fname + strlen (it->fname) - 1;
+    while (*ext != '.' && ext > it->fname) {
+        ext--;
+    }
+    ext++;
+    const char *ftype;
+    info->duh = open_module(it->fname, ext, &start_order, &is_it, &is_dos, &ftype);
+
+    dumb_it_do_initial_runthrough (info->duh);
+
+    _info->plugin = &plugin;
+    _info->bps = 16;
+    _info->channels = 2;
+    _info->samplerate = deadbeef->conf_get_int ("synth.samplerate", 48000);
+    _info->readpos = 0;
+
+    if (cdumb_startrenderer (_info) < 0) {
+        plugin.free (_info);
+        return NULL;
+    }
+
+    trace ("cdumb_init success (ptr=%p)\n", _info);
+    return _info;
+}
+
+static int
+cdumb_startrenderer (DB_fileinfo_t *_info) {
+    dumb_info_t *info = (dumb_info_t *)_info;
+    // reopen
+    if (info->renderer) {
+        duh_end_sigrenderer (info->renderer);
+        info->renderer = NULL;
+    }
+    info->renderer = duh_start_sigrenderer (info->duh, 0, 2, 0);
+    if (!info->renderer) {
+        return -1;
+    }
+
+    DUMB_IT_SIGRENDERER *itsr = duh_get_it_sigrenderer (info->renderer);
+    dumb_it_set_loop_callback (itsr, &dumb_it_callback_terminate, NULL);
+    dumb_it_set_resampling_quality (itsr, 2);
+    dumb_it_set_xm_speed_zero_callback (itsr, &dumb_it_callback_terminate, NULL);
+    dumb_it_set_global_volume_zero_callback (itsr, &dumb_it_callback_terminate, NULL);
+    return 0;
+}
+
+static void
+cdumb_free (DB_fileinfo_t *_info) {
+    trace ("cdumb_free %p\n", _info);
+    dumb_info_t *info = (dumb_info_t *)_info;
+    if (info) {
+        if (info->renderer) {
+            duh_end_sigrenderer (info->renderer);
+            info->renderer = NULL;
+        }
+        if (info->duh) {
+            unload_duh (info->duh);
+            info->duh = NULL;
+        }
+        free (info);
+    }
+}
+
+static int
+cdumb_read (DB_fileinfo_t *_info, char *bytes, int size) {
+    trace ("cdumb_read req %d\n", size);
+    dumb_info_t *info = (dumb_info_t *)_info;
+    int length = size / 4;
+    long ret;
+    ret = duh_render (info->renderer, 16, 0, 1, 65536.f / _info->samplerate, length, bytes);
+    _info->readpos += ret / (float)_info->samplerate;
+    trace ("cdumb_read %d\n", ret*4);
+    return ret*4;
+}
+
+static int
+cdumb_seek (DB_fileinfo_t *_info, float time) {
+    trace ("cdumb_read seek %f\n", time);
+    dumb_info_t *info = (dumb_info_t *)_info;
+    if (time < _info->readpos) {
+        if (cdumb_startrenderer (_info) < 0) {
+            return -1;
+        }       
+    }
+    else {
+        time -= _info->readpos;
+    }
+    int pos = time * _info->samplerate;
+    duh_sigrenderer_generate_samples (info->renderer, 0, 65536.0f / _info->samplerate, pos, NULL);
+    _info->readpos = duh_sigrenderer_get_position (info->renderer) / 65536.f;
+    return 0;
+}
+
+static const char * exts[]=
+{
+	"mod","mdz",
+	"s3m","s3z",
+	"stm","stz",
+	"it","itz",
+	"xm","xmz",
+	"ptm","ptz",
+	"mtm","mtz",
+	"669",
+	"psm",
+	"umx",
+	"am","j2b",
+	"dsm",
+	"amf",
+	NULL
+};
+
+// derived from mod.cpp of foo_dumb source code
+static DUH * open_module(const char *fname, const char *ext, int *start_order, int *is_it, int *is_dos, const char** filetype)
+{
+    *filetype = NULL;
+	DUH * duh = 0;
+
+	*is_it = 0;
+	*is_dos = 1;
+
+    uint8_t ptr[2000];
+    DB_FILE *fp = deadbeef->fopen (fname);
+    if (!fp) {
+        return NULL;
+    }
+    int size = deadbeef->fread (ptr, 1, 2000, fp);
+    deadbeef->fclose (fp);
+
+	DUMBFILE * f = dumbfile_open (fname);
+	if (!f) {
+        return NULL;
+    }
+
+// {{{ no umr yet
+#if 0
+    if (size >= 4 &&
+		ptr[0] == 0xC1 && ptr[1] == 0x83 &&
+		ptr[2] == 0x2A && ptr[3] == 0x9E)
+	{
+		umr_mem_reader memreader(ptr, size);
+		umr::upkg pkg;
+		if (pkg.open(&memreader))
+		{
+			for (int i = 1, j = pkg.ocount(); i <= j; i++)
+			{
+				char * classname = pkg.oclassname(i);
+				if (classname && !strcmp(pkg.oclassname(i), "Music"))
+				{
+					char * type = pkg.otype(i);
+					if (!type) continue;
+					/*
+					if (!stricmp(type, "it"))
+					{
+					is_it = true;
+					ptr += memdata.offset = pkg.object_offset(i);
+					size = memdata.size = memdata.offset + pkg.object_size(i);
+					duh = dumb_read_it_quick(f);
+					break;
+					}
+					else if (!stricmp(type, "s3m"))
+					{
+					memdata.offset = pkg.object_offset(i);
+					memdata.size = memdata.offset + pkg.object_size(i);
+					duh = dumb_read_s3m_quick(f);
+					break;
+					}
+					else if (!stricmp(type, "xm"))
+					{
+					memdata.offset = pkg.object_offset(i);
+					memdata.size = memdata.offset + pkg.object_size(i);
+					duh = dumb_read_xm_quick(f);
+					break;
+					}
+					*/
+					// blah, type can't be trusted
+					if (!stricmp(type, "it") || !stricmp(type, "s3m") || !stricmp(type, "xm"))
+					{
+						ptr += memdata.offset = pkg.object_offset(i);
+						size = memdata.size = memdata.offset + pkg.object_size(i);
+						if (size >= 4 && ptr[0] == 'I' && ptr[1] == 'M' && ptr[2] == 'P' && ptr[3] == 'M')
+						{
+							is_it = true;
+							duh = dumb_read_it_quick(f);
+						}
+						else if (size >= 42 && ptr[38] == 'F' && ptr[39] == 'a' && ptr[40] == 's' && ptr[41] == 't')
+						{
+							duh = dumb_read_xm_quick(f);
+						}
+						else if (size >= 48 && ptr[44] == 'S' && ptr[45] == 'C' && ptr[46] == 'R' && ptr[47] == 'M')
+						{
+							duh = dumb_read_s3m_quick(f);
+						}
+
+						break;
+					}
+				}
+			}
+		}
+	}
+	else
+#endif
+// end of umr code
+// }}}
+	if (size >= 4 &&
+		ptr[0] == 'I' && ptr[1] == 'M' &&
+		ptr[2] == 'P' && ptr[3] == 'M')
+	{
+		*is_it = 1;
+		duh = dumb_read_it_quick(f);
+		*filetype = "IT";
+	}
+	else if (size >= 17 && !memcmp(ptr, "Extended Module: ", 17))
+	{
+		duh = dumb_read_xm_quick(f);
+		*filetype = "XM";
+	}
+	else if (size >= 0x30 &&
+		ptr[0x2C] == 'S' && ptr[0x2D] == 'C' &&
+		ptr[0x2E] == 'R' && ptr[0x2F] == 'M')
+	{
+		duh = dumb_read_s3m_quick(f);
+		*filetype = "S3M";
+	}
+	else if (size >= 1168 &&
+		/*ptr[28] == 0x1A &&*/ ptr[29] == 2 &&
+		( ! strncasecmp( ( const char * ) ptr + 20, "!Scream!", 8 ) ||
+		! strncasecmp( ( const char * ) ptr + 20, "BMOD2STM", 8 ) ||
+		! strncasecmp( ( const char * ) ptr + 20, "WUZAMOD!", 8 ) ) )
+	{
+		duh = dumb_read_stm_quick(f);
+		*filetype = "STM";
+	}
+	else if (size >= 2 &&
+		((ptr[0] == 0x69 && ptr[1] == 0x66) ||
+		(ptr[0] == 0x4A && ptr[1] == 0x4E)))
+	{
+		duh = dumb_read_669_quick(f);
+		*filetype = "669";
+	}
+	else if (size >= 0x30 &&
+		ptr[0x2C] == 'P' && ptr[0x2D] == 'T' &&
+		ptr[0x2E] == 'M' && ptr[0x2F] == 'F')
+	{
+		duh = dumb_read_ptm_quick(f);
+		*filetype = "PTM";
+	}
+	else if (size >= 4 &&
+		ptr[0] == 'P' && ptr[1] == 'S' &&
+		ptr[2] == 'M' && ptr[3] == ' ')
+	{
+		duh = dumb_read_psm_quick(f, *start_order);
+		*start_order = 0;
+		*filetype = "PSM";
+	}
+	else if (size >= 4 &&
+		ptr[0] == 'P' && ptr[1] == 'S' &&
+		ptr[2] == 'M' && ptr[3] == 254)
+	{
+		duh = dumb_read_old_psm_quick(f);
+		*filetype = "PSM";
+	}
+	else if (size >= 3 &&
+		ptr[0] == 'M' && ptr[1] == 'T' &&
+		ptr[2] == 'M')
+	{
+		duh = dumb_read_mtm_quick(f);
+		*filetype = "MTM";
+	}
+	else if ( size >= 4 &&
+		ptr[0] == 'R' && ptr[1] == 'I' &&
+		ptr[2] == 'F' && ptr[3] == 'F')
+	{
+		duh = dumb_read_riff_quick(f);
+		*filetype = "RIFF";
+	}
+	else if ( size >= 32 &&
+		!memcmp( ptr, "ASYLUM Music Format", 19 ) &&
+		!memcmp( ptr + 19, " V1.0", 5 ) )
+	{
+		duh = dumb_read_asy_quick(f);
+		*filetype = "ASY";
+	}
+
+	if (!duh)
+	{
+        dumbfile_close(f);
+        f = dumbfile_open (fname);
+		*is_dos = 0;
+		duh = dumb_read_mod_quick (f, (!strcasecmp (ext, exts[0]) || !strcasecmp (ext, exts[1])) ? 0 : 1);
+		*filetype = "MOD";
+	}
+
+    if (f) {
+        dumbfile_close(f);
+    }
+
+// {{{ no volume ramping
+#if 0
+	// XXX test
+	if (duh)
+	{
+		int ramp_mode = 0; // none
+		if (ramp_mode)
+		{
+			DUMB_IT_SIGDATA * itsd = duh_get_it_sigdata(duh);
+			if (itsd)
+			{
+				if (ramp_mode > 2)
+				{
+					if ( ( itsd->flags & ( IT_WAS_AN_XM | IT_WAS_A_MOD ) ) == IT_WAS_AN_XM )
+						ramp_mode = 2;
+					else
+						ramp_mode = 1;
+				}
+				for (int i = 0, j = itsd->n_samples; i < j; i++)
+				{
+					IT_SAMPLE * sample = &itsd->sample[i];
+					if ( sample->flags & IT_SAMPLE_EXISTS && !( sample->flags & IT_SAMPLE_LOOP ) )
+					{
+						double rate = 1. / double( sample->C5_speed );
+						double length = double( sample->length ) * rate;
+						if ( length >= .1 )
+						{
+							int k, l = sample->length;
+							if ( ramp_mode == 1 && ( ( rate * 16. ) < .01 ) )
+							{
+								if (sample->flags & IT_SAMPLE_16BIT)
+								{
+									k = l - 15;
+									signed short * data = (signed short *) sample->data;
+									if (sample->flags & IT_SAMPLE_STEREO)
+									{
+										for (int shift = 1; k < l; k++, shift++)
+										{
+											data [k * 2] >>= shift;
+											data [k * 2 + 1] >>= shift;
+										}
+									}
+									else
+									{
+										for (int shift = 1; k < l; k++, shift++)
+										{
+											data [k] >>= shift;
+										}
+									}
+								}
+								else
+								{
+									k = l - 7;
+									signed char * data = (signed char *) sample->data;
+									if (sample->flags & IT_SAMPLE_STEREO)
+									{
+										for (int shift = 1; k < l; k++, shift++)
+										{
+											data [k * 2] >>= shift;
+											data [k * 2 + 1] >>= shift;
+										}
+									}
+									else
+									{
+										for (int shift = 1; k < l; k++, shift++)
+										{
+											data [k] >>= shift;
+										}
+									}
+								}
+							}
+							else
+							{
+								int m = int( .01 * double( sample->C5_speed ) + .5 );
+								k = l - m;
+								if (sample->flags & IT_SAMPLE_16BIT)
+								{
+									signed short * data = (signed short *) sample->data;
+									if (sample->flags & IT_SAMPLE_STEREO)
+									{
+										for (; k < l; k++)
+										{
+											data [k * 2] =     MulDiv( data [k * 2],     l - k, m );
+											data [k * 2 + 1] = MulDiv( data [k * 2 + 1], l - k, m );
+										}
+									}
+									else
+									{
+										for (; k < l; k++)
+										{
+											data [k] =     MulDiv( data [k],     l - k, m );
+										}
+									}
+								}
+								else
+								{
+									signed char * data = (signed char *) sample->data;
+									if (sample->flags & IT_SAMPLE_STEREO)
+									{
+										for (; k < l; k++)
+										{
+											data [k * 2] =     MulDiv( data [k * 2],     l - k, m );
+											data [k * 2 + 1] = MulDiv( data [k * 2 + 1], l - k, m );
+										}
+									}
+									else
+									{
+										for (; k < l; k++)
+										{
+											data [k] =     MulDiv( data [k],     l - k, m );
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+#endif
+// }}}
+
+// {{{ no autochip
+#if 0
+	if (duh && cfg_autochip)
+	{
+		int size_force = cfg_autochip_size_force;
+		int size_scan = cfg_autochip_size_scan;
+		int scan_threshold_8 = ((cfg_autochip_scan_threshold * 0x100) + 50) / 100;
+		int scan_threshold_16 = ((cfg_autochip_scan_threshold * 0x10000) + 50) / 100;
+		DUMB_IT_SIGDATA * itsd = duh_get_it_sigdata(duh);
+
+		if (itsd)
+		{
+			for (int i = 0, j = itsd->n_samples; i < j; i++)
+			{
+				IT_SAMPLE * sample = &itsd->sample[i];
+				if (sample->flags & IT_SAMPLE_EXISTS)
+				{
+					int channels = sample->flags & IT_SAMPLE_STEREO ? 2 : 1;
+					if (sample->length < size_force) sample->max_resampling_quality = 0;
+					else if (sample->length < size_scan)
+					{
+						if ((sample->flags & (IT_SAMPLE_LOOP|IT_SAMPLE_PINGPONG_LOOP)) == IT_SAMPLE_LOOP)
+						{
+							int loop_start = sample->loop_start * channels;
+							int loop_end = sample->loop_end * channels;
+							int s1, s2;
+							if (sample->flags & IT_SAMPLE_16BIT)
+							{
+								s1 = ((signed short *)sample->data)[loop_start];
+								s2 = ((signed short *)sample->data)[loop_end - channels];
+								if (abs(s1 - s2) > scan_threshold_16)
+								{
+									sample->max_resampling_quality = 0;
+									continue;
+								}
+								if (channels == 2)
+								{
+									s1 = ((signed short *)sample->data)[loop_start + 1];
+									s2 = ((signed short *)sample->data)[loop_end - 1];
+									if (abs(s1 - s2) > scan_threshold_16)
+									{
+										sample->max_resampling_quality = 0;
+										continue;
+									}
+								}
+							}
+							else
+							{
+								s1 = ((signed char *)sample->data)[loop_start];
+								s2 = ((signed char *)sample->data)[loop_end - channels];
+								if (abs(s1 - s2) > scan_threshold_8)
+								{
+									sample->max_resampling_quality = 0;
+									continue;
+								}
+								if (channels == 2)
+								{
+									s1 = ((signed char *)sample->data)[loop_start + 1];
+									s2 = ((signed char *)sample->data)[loop_end - 1];
+									if (abs(s1 - s2) > scan_threshold_8)
+									{
+										sample->max_resampling_quality = 0;
+										continue;
+									}
+								}
+							}
+						}
+						if ((sample->flags & (IT_SAMPLE_SUS_LOOP|IT_SAMPLE_PINGPONG_SUS_LOOP)) == IT_SAMPLE_SUS_LOOP)
+						{
+							int sus_loop_start = sample->sus_loop_start * channels;
+							int sus_loop_end = sample->sus_loop_end * channels;
+							int s1, s2;
+							if (sample->flags & IT_SAMPLE_16BIT)
+							{
+								s1 = ((signed short *)sample->data)[sus_loop_start];
+								s2 = ((signed short *)sample->data)[sus_loop_end - channels];
+								if (abs(s1 - s2) > scan_threshold_16)
+								{
+									sample->max_resampling_quality = 0;
+									continue;
+								}
+								if (channels == 2)
+								{
+									s1 = ((signed short *)sample->data)[sus_loop_start + 1];
+									s2 = ((signed short *)sample->data)[sus_loop_end - 1];
+									if (abs(s1 - s2) > scan_threshold_16)
+									{
+										sample->max_resampling_quality = 0;
+										continue;
+									}
+								}
+							}
+							else
+							{
+								s1 = ((signed char *)sample->data)[sus_loop_start];
+								s2 = ((signed char *)sample->data)[sus_loop_end - channels];
+								if (abs(s1 - s2) > scan_threshold_8)
+								{
+									sample->max_resampling_quality = 0;
+									continue;
+								}
+								if (channels == 2)
+								{
+									s1 = ((signed char *)sample->data)[sus_loop_start + 1];
+									s2 = ((signed char *)sample->data)[sus_loop_end - 1];
+									if (abs(s1 - s2) > scan_threshold_8)
+									{
+										sample->max_resampling_quality = 0;
+										continue;
+									}
+								}
+							}
+						}
+
+						int k, l = sample->length * channels;
+						if (sample->flags & IT_SAMPLE_LOOP) l = sample->loop_end * channels;
+						if (sample->flags & IT_SAMPLE_16BIT)
+						{
+							for (k = channels; k < l; k += channels)
+							{
+								if (abs(((signed short *)sample->data)[k - channels] - ((signed short *)sample->data)[k]) > scan_threshold_16)
+								{
+									break;
+								}
+							}
+							if (k < l)
+							{
+								sample->max_resampling_quality = 0;
+								continue;
+							}
+							if (channels == 2)
+							{
+								for (k = 2 + 1; k < l; k += 2)
+								{
+									if (abs(((signed short *)sample->data)[k - 2] - ((signed short *)sample->data)[k]) > scan_threshold_16)
+									{
+										break;
+									}
+								}
+							}
+							if (k < l)
+							{
+								sample->max_resampling_quality = 0;
+								continue;
+							}
+						}
+						else
+						{
+							for (k = channels; k < l; k += channels)
+							{
+								if (abs(((signed char *)sample->data)[k - channels] - ((signed char *)sample->data)[k]) > scan_threshold_8)
+								{
+									break;
+								}
+							}
+							if (k < l)
+							{
+								sample->max_resampling_quality = 0;
+								continue;
+							}
+							if (channels == 2)
+							{
+								for (k = 2 + 1; k < l; k += 2)
+								{
+									if (abs(((signed char *)sample->data)[k - 2] - ((signed char *)sample->data)[k]) > scan_threshold_8)
+									{
+										break;
+									}
+								}
+							}
+							if (k < l)
+							{
+								sample->max_resampling_quality = 0;
+								continue;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+#endif
+// }}}
+
+// {{{ no trim
+#if 0
+	if ( duh && cfg_trim )
+	{
+		if ( dumb_it_trim_silent_patterns( duh ) < 0 )
+		{
+			unload_duh( duh );
+			duh = 0;
+		}
+	}
+#endif
+// }}}
+
+	return duh;
+}
+
+static const char *convstr (const char* str, int sz) {
+    static char out[2048];
+    int i;
+    for (i = 0; i < sz; i++) {
+        if (str[i] != ' ') {
+            break;
+        }
+    }
+    if (i == sz) {
+        out[0] = 0;
+        return out;
+    }
+
+    // check for utf8 (hack)
+    if (deadbeef->junk_iconv (str, sz, out, sizeof (out), "utf-8", "utf-8") >= 0) {
+        return out;
+    }
+
+    if (deadbeef->junk_iconv (str, sz, out, sizeof (out), "utf-8", "iso8859-1") >= 0) {
+        return out;
+    }
+
+    trace ("cdumb: failed to detect charset\n");
+    return NULL;
+}
+
+static DB_playItem_t *
+cdumb_insert (DB_playItem_t *after, const char *fname) {
+    const char *ext = fname + strlen (fname) - 1;
+    while (*ext != '.' && ext > fname) {
+        ext--;
+    }
+    ext++;
+    int start_order = 0;
+    int is_it;
+    int is_dos;
+    const char *ftype;
+    DUH* duh = open_module(fname, ext, &start_order, &is_it, &is_dos, &ftype);
+    if (!duh) {
+        return NULL;
+    }
+    DB_playItem_t *it = deadbeef->pl_item_alloc ();
+    it->decoder_id = deadbeef->plug_get_decoder_id (plugin.plugin.id);
+    it->fname = strdup (fname);
+    DUMB_IT_SIGDATA * itsd = duh_get_it_sigdata(duh);
+    if (itsd->name[0])     {
+        int tl = sizeof(itsd->name);
+        int i;
+        for (i = 0; i < tl && itsd->name[i] && itsd->name[i] == ' '; i++);
+        if (i == tl || !itsd->name[i]) {
+            deadbeef->pl_add_meta (it, "title", NULL);
+        }
+        else {
+            deadbeef->pl_add_meta (it, "title", convstr ((char*)&itsd->name, sizeof(itsd->name)));
+        }
+    }
+    else {
+        deadbeef->pl_add_meta (it, "title", NULL);
+    }
+    dumb_it_do_initial_runthrough (duh);
+    deadbeef->pl_set_item_duration (it, duh_get_length (duh)/65536.0f);
+    it->filetype = ftype;
+//    printf ("duration: %f\n", _info->duration);
+    after = deadbeef->pl_insert_item (after, it);
+    deadbeef->pl_item_unref (it);
+    unload_duh (duh);
+
+    return after;
+}
+
+static DUMBFILE_SYSTEM dumb_vfs;
+
+static int
+dumb_vfs_skip (void *f, long n) {
+    return deadbeef->fseek (f, n, SEEK_CUR);
+}
+
+static int
+dumb_vfs_getc (void *f) {
+    uint8_t c;
+    deadbeef->fread (&c, 1, 1, f);
+    return (int)c;
+}
+
+static long
+dumb_vfs_getnc (char *ptr, long n, void *f) {
+    return deadbeef->fread (ptr, 1, n, f);
+}
+
+static void
+dumb_vfs_close (void *f) {
+    deadbeef->fclose (f);
+}
+
+static void
+dumb_register_db_vfs (void) {
+    dumb_vfs.open = (void *(*)(const char *))deadbeef->fopen;
+    dumb_vfs.skip = dumb_vfs_skip;
+    dumb_vfs.getc = dumb_vfs_getc;
+    dumb_vfs.getnc = dumb_vfs_getnc;
+    dumb_vfs.close = dumb_vfs_close;
+    register_dumbfile_system (&dumb_vfs);
+}
+
+int
+cgme_start (void) {
+    dumb_register_db_vfs ();
+    return 0;
+}
+
+int
+cgme_stop (void) {
+    dumb_exit ();
+    return 0;
+}
+
+static const char *filetypes[] = { "IT", "XM", "S3M", "STM", "669", "PTM", "PSM", "MTM", "RIFF", "ASY", "MOD", NULL };
+
+// define plugin interface
+static DB_decoder_t plugin = {
+    DB_PLUGIN_SET_API_VERSION
+    .plugin.version_major = 0,
+    .plugin.version_minor = 1,
+    .plugin.type = DB_PLUGIN_DECODER,
+    .plugin.id = "stddumb",
+    .plugin.name = "DUMB module player",
+    .plugin.descr = "module player based on DUMB library",
+    .plugin.author = "Alexey Yakovenko",
+    .plugin.email = "waker@users.sourceforge.net",
+    .plugin.website = "http://deadbeef.sf.net",
+    .plugin.start = cgme_start,
+    .plugin.stop = cgme_stop,
+    .init = cdumb_init,
+    .free = cdumb_free,
+    .read_int16 = cdumb_read,
+    .seek = cdumb_seek,
+    .insert = cdumb_insert,
+    .exts = exts,
+    .filetypes = filetypes
+};
+
+DB_plugin_t *
+dumb_load (DB_functions_t *api) {
+    deadbeef = api;
+    return DB_PLUGIN (&plugin);
+}
diff --git a/plugins/dumb/dumb-kode54/ChangeLog b/plugins/dumb/dumb-kode54/ChangeLog
new file mode 100644
index 00000000..26d9632e
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/ChangeLog
@@ -0,0 +1,1959 @@
+2003-11-08 11:20  aegis

+

+	* src/Makefile.am: fix automake build

+

+2003-09-06 22:41  entheh

+

+	* include/dumb.h, include/internal/it.h, make/Makefile.inc,

+	src/helpers/resample.c, src/helpers/resample.inc, src/it/itread.c,

+	src/it/itrender.c, src/it/readmod.c, src/it/reads3m.c,

+	src/it/readxm.c: 8-bit and 16-bit source resamplers created (dest

+	is always 32-bit with 24-bit range). Cubic way faster too - look-up

+	table idea stolen from ModPlugXMMS ;)

+

+2003-09-06 11:11  entheh

+

+	* src/core/rendsig.c: I did this ages ago.

+

+2003-07-19 03:00  entheh

+

+	* Makefile.ready, release.txt, include/dumb.h, make/Makefile.inc,

+	src/core/register.c, src/it/itrender.c, src/sigtypes/sample.c:

+	Stuff.

+

+2003-07-01 10:12  entheh

+

+	* include/dumb.h: Support for another compiler suite.

+

+2003-06-19 21:24  entheh

+

+	* src/helpers/resample.c: Crash bug fixed.

+

+2003-06-19 20:49  entheh

+

+	* src/it/: itrender.c, reads3m.c: Now we honour IT's pan separation

+	control.

+

+2003-06-19 17:31  entheh

+

+	* release.txt, src/it/itread.c, src/it/itrender.c,

+	src/it/readmod.c, src/it/reads3m.c, src/it/readxm.c: Fixed warnings

+	in the file loaders, and made an IT playback fix.

+

+2003-06-15 19:09  aegis

+

+	* vc6/: dumbout/dumbout.dsp, dumbplay/dumbplay.dsp,

+	playduh/playduh.dsp: adding project files I missed

+

+2003-06-15 19:08  aegis

+

+	* release.txt: updating release.txt

+

+2003-06-15 18:40  aegis

+

+	* configure.in, include/Makefile.am, include/internal/Makefile.am,

+	vc6/dumb.dsw, vc6/dumb2wav/dumb2wav.dsp: include the

+	include/internal directory in distributions, and build allegro

+	examples in VC6 build

+

+2003-06-15 18:36  aegis

+

+	* examples/dumb2wav.c: add a -l option to specify number of loops

+

+2003-06-12 17:34  aegis

+

+	* vc6/dumb_static/dumb_static.dsp: build dumbd_static.lib instead

+	of dumb_staticd.lib

+

+2003-06-12 03:19  aegis

+

+	* vc6/: dumb.dsw, aldumb/aldumb.dsp, dumb/dumb.dsp,

+	dumb2wav/dumb2wav.dsp, dumb_static/dumb_static.dsp: adding projects

+	for dumb_static (compiled with /MT) and dumb2wav

+

+2003-06-12 03:16  aegis

+

+	* examples/dumb2wav.c: all .wav files are little-endian so get rid

+	of the bigendian option

+

+2003-06-12 02:30  aegis

+

+	* make/Makefile.am: forgot to add this file...

+

+2003-06-12 02:14  aegis

+

+	* obj/mingw/release/tmpfile.txt, obj/msvc/debug/tmpfile.txt,

+	obj/msvc/release/tmpfile.txt, obj/unix/debug/tmpfile.txt,

+	obj/unix/release/tmpfile.txt, src/Makefile.am,

+	src/core/Makefile.am, src/helpers/Makefile.am, src/it/Makefile.am,

+	src/it/itread.c, src/it/readmod.c, src/it/reads3m.c,

+	src/it/readxm.c: automake build:	 include a bunch of extra

+	files in 'make dist'	     build examples so they actually run   

+	     copy Makefile.ready to Makefile in the default distribution

+	

+	Makefile.ready: 	support for SGI cc	   create output

+	directories in build rather than including them in CVS	       move

+	some compile flags to the beginning of the compile line

+	

+	Add dumb2wav example SGI LONG_LONG support Fix some issues with the

+	const tag arrays in itread.c and such

+	

+	:

+	-------------------------------------------------------------------

+	---

+

+2003-06-12 02:13  aegis

+

+	* Makefile.am, Makefile.ready, configure.in, docs/Makefile.am,

+	examples/Makefile.am, examples/dumb2wav.c, include/dumb.h,

+	lib/djgpp/tmpfile.txt, lib/mingw/tmpfile.txt, lib/msvc/tmpfile.txt,

+	lib/unix/tmpfile.txt, make/Makefile.inc,

+	obj/djgpp/debug/tmpfile.txt, obj/djgpp/release/tmpfile.txt,

+	obj/mingw/debug/tmpfile.txt: automake build:	     include a

+	bunch of extra files in 'make dist'	    build examples so they

+	actually run	     copy Makefile.ready to Makefile in the default

+	distribution

+	

+	Makefile.ready: 	support for SGI cc	   create output

+	directories in build rather than including them in CVS	       move

+	some compile flags to the beginning of the compile line

+	

+	Add dumb2wav example SGI LONG_LONG support Fix some issues with the

+	const tag arrays in itread.c and such

+

+2003-06-11 06:29  entheh

+

+	* include/dumb.h: Should compile with OpenWatcom now. I've yet to

+	look at the project files and decide whether to add them though :)

+

+2003-06-10 14:10  aegis

+

+	* configure.in: oops, forgot configure.in when committing the

+	automake build

+

+2003-06-07 07:14  entheh

+

+	* Makefile.ready: Small fix to compiling flags for icc.

+

+2003-06-06 12:26  entheh

+

+	* include/internal/it.h, src/it/itrender.c: XM Key Off effect now

+	works the way it should (I hope).

+

+2003-06-05 06:19  aegis

+

+	* Makefile.ready: fix Makefile.ready so it refers to itself when

+	recursively invoking make

+

+2003-06-04 02:16  aegis

+

+	* vc6/: dumb.dsp, dumb.dsw, aldumb/aldumb.dsp, dumb/dumb.dsp:

+	finishing VC6 build system

+

+2003-05-29 20:55  aegis

+

+	* release.txt: updating release.txt

+

+2003-05-29 20:55  aegis

+

+	* examples/Makefile.am: install examples

+

+2003-05-29 20:37  aegis

+

+	* Makefile, Makefile.am, Makefile.ready, bootstrap,

+	docs/Makefile.am, examples/Makefile.am, include/Makefile.am,

+	src/Makefile.am, src/core/Makefile.am, src/helpers/Makefile.am,

+	src/it/Makefile.am: initial pass of automake build

+

+2003-05-28 11:56  aegis

+

+	* vc6/: dumb.dsp, dumb.dsw: updating VC6 project:  the sigtypes

+	stuff doesn't compile yet though

+

+2003-05-17 09:33  entheh

+

+	* Makefile, release.txt, include/dumb.h, src/it/itrender.c: Bugfix:

+	Gxx didn't store effect value when no note was (previously)

+	playing. Also added support for the Intel C compiler for Linux.

+

+2003-04-27 11:49  entheh

+

+	* make/config.sh: Small fix. Thanks to Sam Hocevar from Debian for

+	pointing this out.

+

+2003-04-25 09:23  entheh

+

+	* release.txt, include/internal/it.h, src/it/itrender.c,

+	src/it/xmeffect.c: XM Kxx effect should work better now.

+

+2003-04-24 15:26  entheh

+

+	* docs/faq.txt, include/dumb.h, include/internal/it.h,

+	src/it/itmisc.c, src/it/itread.c, src/it/itunload.c,

+	src/it/readmod.c, src/it/reads3m.c, src/it/readxm.c: DUMB now loads

+	song message and other author data, and these can be retrieved.

+

+2003-04-23 00:14  entheh

+

+	* release.txt, docs/deprec.txt: Misc commits

+	

+	-------------------------------------------------------------------

+	---

+

+2003-04-18 03:00  entheh

+

+	* include/dumb.h, include/internal/it.h, src/it/itread.c,

+	src/it/itrender.c, winamp/in_duh.c: New envelope code. I don't

+	trust it fully yet, but it seems to work.

+

+2003-04-17 16:54  entheh

+

+	* Makefile, release.txt, include/dumb.h, include/internal/dumb.h,

+	include/internal/it.h, src/core/duhtag.c, src/core/makeduh.c,

+	src/core/unload.c, src/it/itread.c, src/it/itrender.c,

+	src/it/readmod.c, src/it/reads3m.c, src/it/readxm.c,

+	winamp/in_duh.c: Added a tagging system; using it for the song

+	title. Yay!

+

+2003-04-15 00:13  entheh

+

+	* include/internal/it.h, src/it/itrender.c, src/it/readxm.c,

+	src/it/xmeffect.c: Panning slides! Finally \o/

+

+2003-04-12 01:01  entheh

+

+	* Makefile, include/aldumb.h, src/allegro/alplay.c: Added

+	al_duh_get_volume(). Not documented yet.

+

+2003-04-12 00:12  entheh

+

+	* Makefile, todo.txt, src/it/readxm.c: XM files: map_sample[] was

+	uninitialised for instruments with no samples - led to strange

+	noises occasionally.

+

+2003-04-04 08:04  entheh

+

+	* winamp/in_duh.c: Winamp plug-in improved a bit.

+

+2003-04-03 16:26  entheh

+

+	* make/config.bat: Huge bugfix!

+

+2003-04-03 12:07  entheh

+

+	* Makefile: Bug fixed. Example programs will now be installed.

+

+2003-04-03 07:02  entheh

+

+	* vc6/dumb.dsp: Added the VC6 project file to CVS.

+

+2003-04-03 07:01  entheh

+

+	* readme.txt: Bah.

+

+2003-04-02 04:55  entheh

+

+	* Makefile, readme.txt, release.txt: The makefile now works for the

+	Mac.

+

+2003-04-02 04:00  entheh

+

+	* release.txt: OK, this time it really is ready for release ...

+

+2003-04-02 03:56  entheh

+

+	* Makefile, licence.txt, readme.txt, release.txt, todo.txt,

+	docs/deprec.txt, docs/dumb.txt, docs/faq.txt, docs/howto.txt,

+	docs/modplug.txt, examples/dumb.ini, examples/dumbout.c,

+	include/dumb.h, include/internal/it.h, src/core/rendsig.c,

+	src/helpers/resample.c, src/it/itrender.c: Ready for release!

+

+2003-03-30 12:05  entheh

+

+	* Makefile, release.txt, src/it/itread.c, src/it/itrender.c,

+	src/it/readmod.c, src/it/reads3m.c, src/it/readxm.c: No longer

+	installing the example programs when on Windows.

+

+2003-03-30 09:01  entheh

+

+	* Makefile, make/djgpp.inc, make/mingw.inc, make/unix.inc: Fix for

+	BeOS

+

+2003-03-30 08:22  entheh

+

+	* Makefile, Makefile.dj, Makefile.inc, Makefile.mgw, Makefile.uni,

+	config.bat, config.sh, readme.txt, make/Makefile.inc,

+	make/config.bat, make/config.sh, make/djgpp.inc, make/dumbask.c,

+	make/makefile.dj, make/makefile.lst, make/makefile.mgw,

+	make/makefile.uni, make/makefile.vc, make/mingw.inc, make/unix.inc,

+	src/misc/dumbask.c, src/misc/runner.c: Makefiles restructured a

+	bit. Should now support BeOS and Mac too :)

+

+2003-03-29 19:45  entheh

+

+	* Makefile, Makefile.dj, Makefile.inc, Makefile.mgw, Makefile.uni,

+	config.bat, config.sh, fix.bat, fix.sh, makeall.bat, makeall.sh,

+	makecore.bat, makecore.sh, release.txt, examples/dumbout.c,

+	include/dumb.h, include/internal/it.h, src/it/itrender.c,

+	src/misc/dumbask.c, src/misc/gccver.c: New makefile system! No

+	provision for MSVC yet ...

+

+2003-03-28 06:06  entheh

+

+	* make/makefile.mgw: -funroll-loops removed from makefiles.

+

+2003-03-28 05:29  entheh

+

+	* src/helpers/resample.c: Some optimisation. Still needs work!

+

+2003-03-27 04:13  entheh

+

+	* src/it/itrender.c: Pacified valgrind.

+

+2003-03-19 08:42  entheh

+

+	* examples/dumb.ini, include/dumb.h, src/helpers/clickrem.c,

+	src/helpers/resample.c: Blah, stuff.

+

+2003-03-16 01:13  entheh

+

+	* licence.txt, readme.txt, release.txt, docs/deprec.txt,

+	docs/duhspecs.txt, docs/dumb.txt, docs/dumbfull.txt, docs/faq.txt,

+	docs/fnptr.txt, docs/howto.txt, docs/modplug.txt, docs/ptr.txt,

+	docs/tutorial.txt, examples/dumbout.c, examples/dumbplay.c,

+	examples/playduh.c, include/aldumb.h, include/dumb.h,

+	include/internal/aldumb.h, include/internal/dumb.h,

+	include/internal/it.h, src/allegro/alplay.c, src/allegro/datduh.c,

+	src/allegro/datit.c, src/allegro/datmod.c, src/allegro/dats3m.c,

+	src/allegro/datunld.c, src/allegro/datxm.c, src/allegro/packfile.c,

+	src/core/atexit.c, src/core/duhlen.c, src/core/dumbfile.c,

+	src/core/loadduh.c, src/core/makeduh.c, src/core/rawsig.c,

+	src/core/readduh.c, src/core/register.c, src/core/rendduh.c,

+	src/core/rendsig.c, src/core/unload.c, src/helpers/clickrem.c,

+	src/helpers/memfile.c, src/helpers/resample.c,

+	src/helpers/sampbuf.c, src/helpers/silence.c,

+	src/helpers/stdfile.c, src/it/itload.c, src/it/itmisc.c,

+	src/it/itorder.c, src/it/itread.c, src/it/itrender.c,

+	src/it/itunload.c, src/it/loadmod.c, src/it/loads3m.c,

+	src/it/loadxm.c, src/it/readmod.c, src/it/reads3m.c,

+	src/it/readxm.c, src/it/xmeffect.c, src/sigtypes/combine.c,

+	src/sigtypes/sample.c, src/sigtypes/sequence.c,

+	src/sigtypes/sterpan.c, tools/cit.c, winamp/in2.h, winamp/in_duh.c,

+	winamp/in_duh.h, winamp/out.h: SHAZZAM! DUMB now has a decent name.

+	:D

+

+2003-03-16 00:36  entheh

+

+	* src/helpers/clickrem.c: Added a #warning to an evil piece of code

+

+2003-03-15 21:03  entheh

+

+	* src/helpers/clickrem.c: Click remover now copes with the huge

+	values.

+

+2003-03-15 19:53  entheh

+

+	* src/: core/rendduh.c, it/itread.c, it/readmod.c, it/reads3m.c,

+	it/readxm.c: 24-bit mixing YAAAAAAAY :D Click remover overflows -

+	will fix that later.

+

+2003-03-15 19:16  entheh

+

+	* examples/dumbout.c, src/helpers/resample.c: MULSC macro created

+	and tweaked for speed AND precision! Yaaaaay ^~ Thanks for the help

+	Bob :)

+

+2003-03-11 18:41  entheh

+

+	* src/it/itrender.c: Reinstating the vibrato I disabled while

+	playing with valgrind (oops).

+

+2003-03-11 00:02  entheh

+

+	* src/helpers/resample.c: Resamplers didn't quite Do The Right

+	Thing for click removal. Fixed.

+

+2003-03-10 22:49  entheh

+

+	* readme.txt, docs/deprec.txt, docs/faq.txt, docs/howto.txt,

+	examples/dumbout.c, include/dumb.h, include/internal/it.h,

+	src/core/makeduh.c, src/core/register.c, src/core/rendduh.c,

+	src/core/rendsig.c, src/helpers/clickrem.c, src/helpers/resample.c,

+	src/it/itread.c, src/it/itrender.c, src/it/itrender.old.c,

+	src/it/readmod.c, src/it/reads3m.c, src/it/readxm.c: Resamplers

+	reworked, finally! More to do, but it's bug-free and usable. :)

+

+2003-02-14 01:25  entheh

+

+	* readme.txt, docs/howto.txt, src/helpers/clickrem.c,

+	src/it/itrender.c: Removed an old #warning (and did some other

+	stuff it seems).

+

+2003-01-26 19:16  entheh

+

+	* release.txt, docs/dumb.txt, include/dumb.h, src/it/itrender.c:

+	dumb_it_sr_get_channel_state() now provides a more precise pan

+	value.

+

+2003-01-24 19:13  entheh

+

+	* docs/dumb.txt, include/dumb.h, src/it/itrender.c:

+	dumb_it_get_state() now returns more precise information on

+	filters.

+

+2003-01-21 06:40  entheh

+

+	* release.txt, docs/dumb.txt, examples/dumbplay.c,

+	include/aldumb.h, src/allegro/alplay.c, src/allegro/packfile.c:

+	Stuff... dumbfile_from_packfile() added, if nothing else.

+

+2003-01-15 19:43  entheh

+

+	* src/it/readmod.c: Committing what appears to be an MSVC warning

+	pacifier.

+

+2003-01-03 15:28  entheh

+

+	* include/internal/it.h, make/makefile.mgw, src/core/dumbfile.c,

+	src/it/itrender.c, src/it/readmod.c, src/it/xmeffect.c: Muted

+	channels supported, more accurate envelopes, several bugs fixed

+

+2003-01-03 15:03  entheh

+

+	* release.txt, docs/dumb.txt, examples/dumb.ini: Muted channels,

+	and lots of bugs fixed

+

+2002-12-24 06:41  entheh

+

+	* include/dumb.h, src/core/dumbfile.c, src/it/itrender.c: Fixed

+	some bugs.

+

+2002-12-20 21:51  entheh

+

+	* src/it/readxm.c: Fixed the bug I thought I fixed just now.

+

+2002-12-20 21:45  entheh

+

+	* examples/dumb.ini, make/makefile.mgw, make/makefile.vc,

+	src/allegro/alplay.c, src/it/readxm.c: Fixed a bug.

+

+2002-12-20 21:07  joe_programmer

+

+	* src/it/itrender.c: MSVC6 does'nt support C99 - fixed variable

+	declarations

+

+2002-12-20 01:49  entheh

+

+	* make/makefile.dj, make/makefile.mgw, src/it/itrender.c: Filter

+	instability fixed.

+

+2002-12-19 05:35  entheh

+

+	* readme.txt, release.txt, docs/deprec.txt, docs/dumb.txt,

+	docs/howto.txt, docs/modplug.txt, examples/dumb.ini,

+	include/dumb.h, include/internal/it.h, src/it/itmisc.c,

+	src/it/itread.c, src/it/itrender.c, src/it/xmeffect.c,

+	winamp/in_duh.c: Err... stuff

+

+2002-12-18 17:15  entheh

+

+	* docs/faq.txt: New stuff in FAQ.

+

+2002-12-18 17:06  entheh

+

+	* licence.txt, readme.txt, release.txt, docs/deprec.txt,

+	docs/dumb.txt, docs/faq.txt, docs/fnptr.txt, docs/howto.txt,

+	docs/modplug.txt, docs/ptr.txt, examples/dumbplay.c,

+	include/dumb.h, include/internal/it.h, make/makefile.lst,

+	src/core/rendduh.c, src/helpers/memfile.c, src/helpers/sampbuf.c,

+	src/it/itmisc.c, src/it/itread.c, src/it/itrender.c,

+	src/it/readmod.c, src/it/readxm.c, src/it/xmeffect.c: XM and MOD

+	support improved, and lots of docs written.

+

+2002-12-17 00:23  entheh

+

+	* release.txt, examples/dumbplay.c, examples/playit.c,

+	examples/playmod.c, examples/plays3m.c, examples/playxm.c,

+	include/aldumb.h, include/dumb.h, make/makefile.lst,

+	make/makefile.vc, src/allegro/datmod.c, src/core/loadduh.c,

+	src/it/itrender.c, src/it/readxm.c, src/misc/gccver.c: Lots o'

+	little changes. Notably the examples have been combined.

+

+2002-12-16 22:13  entheh

+

+	* include/dumb.h, make/makefile.dj, make/makefile.mgw,

+	make/makefile.uni, make/makefile.vc, src/misc/gccver.c: Improved

+	the makefiles and... stuff. GCC 2.x should be happy now.

+

+2002-12-13 23:25  entheh

+

+	* src/it/itrender.c: Filtered samples now have click removal

+	applied. Yay \o/

+

+2002-12-12 00:17  entheh

+

+	* examples/dumb.ini, include/dumb.h, include/internal/it.h,

+	make/makefile.lst, src/helpers/clickrem.c, src/helpers/resample.c,

+	src/it/itrender.c: Click removal! Incomplete though; not applied to

+	filtered samples...

+

+2002-12-09 17:25  entheh

+

+	* src/it/readxm.c: #warning removed. MSVC might just be happy now.

+

+2002-12-09 17:23  entheh

+

+	* src/it/itrender.c: Fixed some MSVC warnings, probably.

+

+2002-12-07 18:04  entheh

+

+	* src/core/rendduh.c: Readding file that got removed because I

+	thought I was going to rename it >_<

+

+2002-12-07 17:48  entheh

+

+	* examples/playit.c, include/aldumb.h, include/dumb.h,

+	src/allegro/alplay.c, src/core/rendduh.c, src/core/rendsig.c:

+	Deprecated some stuff, and added some stuff. \o/

+

+2002-12-01 09:08  entheh

+

+	* src/it/itrender.c, winamp/in_duh.c: Bugfix in tremor (Ixx)

+	handling.

+

+2002-11-26 06:39  entheh

+

+	* include/internal/it.h, src/it/itrender.c, src/it/readxm.c: Wow,

+	who'd have thought an XM file could contain that many samples!

+

+2002-11-26 00:20  entheh

+

+	* examples/playduh.c, examples/playit.c, examples/playmod.c,

+	examples/plays3m.c, examples/playxm.c, src/it/itrender.c,

+	src/it/readmod.c, src/it/reads3m.c, src/it/readxm.c,

+	src/it/xmeffect.c: Quite a few bugfixes.

+

+2002-11-22 06:46  entheh

+

+	* examples/playit.c, include/dumb.h, include/internal/it.h,

+	src/it/itmisc.c, src/it/itorder.c, src/it/itread.c,

+	src/it/itrender.c, src/it/itunload.c, src/it/readmod.c,

+	src/it/reads3m.c, src/it/readxm.c, winamp/config.rc,

+	winamp/in_duh.c: Uh... stuff :o

+

+2002-11-18 21:35  entheh

+

+	* docs/: faq.txt, howto.txt: Addition to the docs.

+

+2002-11-18 05:46  entheh

+

+	* src/it/itread.c: Bleh.

+

+2002-11-18 05:42  entheh

+

+	* src/it/itread.c: Added a "duplicate check" to the IT loader...

+	not the kind you're thinking of though :)

+

+2002-11-18 04:32  entheh

+

+	* examples/playit.c, include/aldumb.h, include/dumb.h,

+	src/allegro/alplay.c, src/core/rendduh.c, src/core/rendsig.c,

+	src/it/itrender.c: Extra API functions

+

+2002-11-16 23:17  entheh

+

+	* src/it/itrender.c: mmm, pie...

+

+2002-11-16 23:04  entheh

+

+	* release.txt, examples/dumb.ini, include/internal/it.h,

+	make/makefile.dj, make/makefile.lst, make/makefile.mgw,

+	make/makefile.uni, src/core/rendduh.c, src/core/rendsig.c,

+	src/helpers/memfile.c, src/it/itread.c, src/it/itrender.c,

+	src/it/itunload.c, src/it/readmod.c, src/it/reads3m.c,

+	src/it/readxm.c:

+	FILTERS!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

+

+2002-11-01 17:02  entheh

+

+	* include/internal/it.h, src/it/itread.c, src/it/itrender.c,

+	src/it/readmod.c, src/it/reads3m.c: DUMB now freezes (correctly I

+	hope) on speed=0 in XM and MOD files.

+

+2002-10-29 09:39  entheh

+

+	* include/internal/it.h, src/core/rawsig.c, src/it/itrender.c,

+	src/it/readxm.c: Sample vibrato :D

+

+2002-10-26 07:43  entheh

+

+	* src/core/rendsig.c: Some more safety; it shouldn't crash on low

+	memory or invalid start order now.

+

+2002-10-26 07:25  entheh

+

+	* examples/playit.c, include/dumb.h, src/it/itrender.c: Fixed

+	another bug :P

+

+2002-10-26 07:12  entheh

+

+	* examples/playit.c, src/it/itrender.c: Fixed bug.

+

+2002-10-26 06:56  entheh

+

+	* todo.txt, include/aldumb.h, include/dumb.h,

+	include/internal/it.h, make/makefile.lst, src/allegro/alplay.c,

+	src/core/rawsig.c, src/core/rendduh.c, src/core/rendsig.c,

+	src/it/itmisc.c, src/it/itrender.c, studio/include/dumbdesk.h,

+	studio/include/guiproc.h, studio/include/guitop.h,

+	studio/src/dumbdesk.c, studio/src/guitop.c, studio/src/main.c:

+	Added some rough & ready start-at-order functionality at short

+	order (no pun intended :)

+

+2002-10-20 05:42  entheh

+

+	* studio/: font0.bmp, font1.bmp, font2.bmp: Added binary files for

+	DUMB Studio

+

+2002-10-16 07:04  entheh

+

+	* examples/: dumb.ini, playit.c: Neatened the examples up a bit.

+

+2002-10-16 06:52  entheh

+

+	* fix.bat, readme.txt, release.txt, docs/dumb.txt,

+	docs/dumbfull.txt, docs/faq.txt, docs/fnptr.txt, docs/howto.txt,

+	include/aldumb.h, include/dumb.h, lib/mingw/tmpfile.txt,

+	lib/mingw32/tmpfile.txt, make/makefile.mgw,

+	obj/mingw/debug/tmpfile.txt, obj/mingw/release/tmpfile.txt,

+	obj/mingw32/debug/tmpfile.txt, obj/mingw32/release/tmpfile.txt,

+	src/allegro/alplay.c, src/it/itrender.c, src/it/readmod.c,

+	src/it/reads3m.c, src/it/readxm.c: Lotsa changes... notably mingw32

+	changed to mingw, and should be ready for release today.

+

+2002-10-05 01:55  jcugniere

+

+	* src/it/: reads3m.c, readxm.c: Prevented that silly test.pcm from

+	taking ALL the space on my c: drive ;)

+

+2002-09-27 04:55  entheh

+

+	* docs/fnptr.txt: Function pointer explanation fleshed out with the

+	whys and wherefores.

+

+2002-09-26 13:03  entheh

+

+	* src/it/: itrender.c, readxm.c: XM envelopes fixed

+

+2002-09-26 06:31  entheh

+

+	* include/internal/it.h, src/it/itrender.c: Improvements to the IT

+	and XM support, tone portamento handling in particular.  WARNING:

+	code restructured slightly; bugs possibly introduced in IT support.

+	If your IT file plays wrong yadda yadda yadda.

+

+2002-09-25 04:29  entheh

+

+	* include/dumb.h, include/internal/dumb.h, include/internal/it.h,

+	src/core/makeduh.c, src/core/readduh.c, src/core/register.c,

+	src/core/rendduh.c, src/core/rendsig.c, src/core/unload.c,

+	src/it/itorder.c, src/it/itread.c, src/it/itrender.c,

+	src/it/itunload.c, src/it/readmod.c, src/it/reads3m.c,

+	src/it/readxm.c: Change in terminology

+

+2002-09-24 14:14  entheh

+

+	* src/it/: itrender.c, readxm.c: :o

+

+2002-09-24 04:50  entheh

+

+	* todo.txt, docs/dumb.txt, include/aldumb.h, src/allegro/alplay.c:

+	Small addition to API; added info and proposal to todo.txt.

+

+2002-09-23 03:31  jcugniere

+

+	* examples/dumb.ini, include/internal/it.h, make/makefile.lst,

+	src/it/itorder.c, src/it/itread.c, src/it/itrender.c,

+	src/it/readmod.c, src/it/reads3m.c, src/it/readxm.c: Made non

+	existant patterns be considered as containing 64 empty rows.

+

+2002-09-22 05:49  entheh

+

+	* src/it/readxm.c: Now we correctly handle the weird case of

+	envelope on but n_nodes = 0 for XM files.

+

+2002-09-20 08:07  entheh

+

+	* src/it/readmod.c: Panning fixed; error checking cleaned up to

+	some extent.

+

+2002-09-20 02:29  entheh

+

+	* src/it/: loadmod.c, loadxm.c, readmod.c: Don't Convert Numbers To

+	BCD On Loading. To Do So Would Be DUMB. :P

+

+2002-09-19 01:08  jcugniere

+

+	* src/core/rendduh.c: fixed compilation problems related to

+	CHAR_BITS and FAST_MID

+

+2002-09-18 09:31  entheh

+

+	* readme.txt, release.txt, todo.txt, docs/dumb.txt,

+	examples/playmod.c, include/aldumb.h, include/dumb.h,

+	include/internal/it.h, make/makefile.lst, src/allegro/datmod.c,

+	src/it/loadmod.c, src/it/readmod.c, src/it/readxm.c,

+	src/it/xmeffect.c: First signs of .mod support :D

+

+2002-09-11 19:42  joe_programmer

+

+	* make/makefile.vc: Fix for MSVC install target

+

+2002-09-08 22:46  entheh

+

+	* src/it/itrender.c, winamp/in_duh.c: Seeking fixed; Winamp plug-in

+	improved in theory, but it crashes sometimes :x

+

+2002-09-08 10:50  entheh

+

+	* src/it/itrender.c: Seeking should now be quick :)

+

+2002-09-08 09:20  entheh

+

+	* src/it/itrender.c: Bug fixed. Odd that it only affected one IT

+	file. That's uninitialised variables for ya :)

+

+2002-09-08 08:26  entheh

+

+	* examples/playit.c, include/internal/it.h, src/it/itread.c,

+	src/it/itrender.c, src/it/itunload.c, src/it/reads3m.c,

+	src/it/readxm.c: Length of songs now being calculated. Shame it

+	gets it wrong ;)

+

+2002-09-08 07:46  joe_programmer

+

+	* src/core/rendduh.c: Optimized the convertors

+

+2002-09-08 04:09  entheh

+

+	* include/internal/it.h, src/it/itrender.c: _dumb_it_dup_sampinfo()

+	coded - first step towards length calculation and fast seeking

+

+2002-09-06 10:31  entheh

+

+	* studio/makedat: Datafile makefile updated.

+

+2002-09-06 09:59  entheh

+

+	* studio/: dumbdesk.c, dumbdesk.h, dumbgui.c, dumbgui.h,

+	dumbmenu.c, guiproc.c, guiproc.h, guitop.c, guitop.h, main.c,

+	main.h, options.c, options.h, subclip.c, subclip.h,

+	include/dumbdesk.h, include/dumbgui.h, include/dumbmenu.h,

+	include/guiproc.h, include/guitop.h, include/main.h,

+	include/options.h, include/subclip.h, src/dumbdesk.c,

+	src/dumbgui.c, src/dumbmenu.c, src/guiproc.c, src/guitop.c,

+	src/main.c, src/options.c, src/subclip.c: Moved studio stuff into

+	subdirs

+

+2002-09-05 14:55  entheh

+

+	* studio/: dumbdesk.c, dumbmenu.c, guiproc.h: Hmm

+

+2002-09-05 13:06  entheh

+

+	* studio/dumbmenu.c: The menu module compiles. It isn't used at all

+	though.

+

+2002-09-05 12:58  entheh

+

+	* studio/dumbmenu.c: Menu module committed; no testing done yet.

+

+2002-09-05 08:03  entheh

+

+	* studio/: datafile.h, makedat: Created a makefile for building the

+	datafile. (Binary files left out of repository.)

+

+2002-09-04 20:53  entheh

+

+	* studio/: datafile.h, dumbdesk.c, dumbdesk.h, dumbgui.c,

+	dumbgui.h, guiproc.c, guiproc.h, guitop.c, guitop.h, main.c,

+	main.h, options.c, options.h, subclip.c, subclip.h: DUMB Studio

+	added. Little more than a freaky GUI test so far...

+

+2002-09-04 16:49  entheh

+

+	* docs/dumb.txt, examples/dumb.ini, examples/playduh.c,

+	examples/playit.c, examples/plays3m.c, examples/playxm.c,

+	include/internal/it.h, make/makefile.uni: Various changes :o

+

+2002-08-26 02:37  entheh

+

+	* makeall.sh, makecore.sh: I thought I already fixed this :)

+

+2002-08-16 04:49  entheh

+

+	* examples/playit.c: Yay 2...

+

+2002-08-16 04:21  entheh

+

+	* examples/playit.c, make/makefile.uni: Yay...

+

+2002-08-12 02:20  entheh

+

+	* readme.txt, release.txt, docs/ptr.txt, examples/dumb.ini,

+	make/makefile.dj, make/makefile.mgw, make/makefile.vc: A few typos

+	corrected. Not much else. Actually I'm not sure.

+

+2002-08-10 17:44  entheh

+

+	* readme.txt, release.txt, docs/faq.txt, docs/fnptr.txt,

+	docs/ptr.txt: Last commit before 0.8.1 release...

+

+2002-08-10 16:03  entheh

+

+	* docs/dumb.txt, examples/dumb.ini, include/dumb.h,

+	make/makefile.dj, make/makefile.mgw, make/makefile.uni,

+	make/makefile.vc, src/it/readxm.c: Another bug fixed; should be

+	ready for a release soon...

+

+2002-08-06 12:57  entheh

+

+	* docs/howto.txt, examples/dumb.ini, make/makefile.lst,

+	src/allegro/datit.c, src/allegro/dats3m.c, src/allegro/datxm.c,

+	src/it/readxm.c: dumb_register_dat_xm() added (!) Also fixed a

+	Freudian slip in the docs, and added dumb_resampling_quality to

+	howto.txt.

+

+2002-07-30 07:02  entheh

+

+	* docs/: dumb.txt, howto.txt: Position about null pointers

+	clarified in the docs

+

+2002-07-29 19:02  entheh

+

+	* src/it/reads3m.c: S3M support made more robust; now handles some

+	buggy files.

+

+2002-07-29 08:28  entheh

+

+	* make/: makefile.dj, makefile.mgw, makefile.uni: Makefiles

+	updated.

+

+2002-07-29 07:57  entheh

+

+	* src/it/itrender.c: XM bug relating to invalid instruments fixed.

+

+2002-07-28 17:40  entheh

+

+	* docs/faq.txt, make/makefile.dj, make/makefile.vc,

+	src/it/readxm.c, winamp/gui.c, winamp/in_duh.c, winamp/in_duh.h:

+	Winamp plug-in up to date, and plays IT/XM/S3M ;D

+

+2002-07-10 09:17  jcugniere

+

+	* include/internal/it.h, src/it/itrender.c, src/it/readxm.c: fixed

+	a bug involving XM's fine volume slide down

+

+2002-06-16 17:59  entheh

+

+	* release.txt, src/it/readxm.c: Can now load XM files with stereo

+	samples

+

+2002-06-16 02:35  entheh

+

+	* release.txt, make/makefile.dj, make/makefile.mgw,

+	make/makefile.vc: 'make veryclean' fixed in DOS/Windows makefiles.

+

+2002-06-15 17:56  entheh

+

+	* readme.txt: Another change...

+

+2002-06-15 17:49  entheh

+

+	* licence.txt, release.txt, docs/faq.txt, docs/howto.txt: More

+	changes to the docs.

+

+2002-06-15 17:12  entheh

+

+	* fix.bat, fix.sh, readme.txt, docs/howto.txt: A few corrections to

+	the docs; fix scripts slightly improved.

+

+2002-06-14 15:13  entheh

+

+	* fix.bat, fix.sh, make/makefile.vc: Fix to the MSVC makefile

+

+2002-06-14 12:33  entheh

+

+	* readme.txt, release.txt, docs/dumb.txt, docs/faq.txt,

+	docs/howto.txt, examples/dumb.ini, examples/playit.c,

+	examples/plays3m.c, examples/playxm.c, include/aldumb.h,

+	make/makefile.dj, make/makefile.mgw, make/makefile.uni,

+	make/makefile.vc: Last commit before release - everything's working

+	:)

+

+2002-06-14 09:02  entheh

+

+	* makeall.sh, makecore.sh: Damn, it failed. Oh well, files added

+	back in.

+

+2002-06-14 08:58  entheh

+

+	* makeall.sh, makecore.sh: Make 'em executable, Phase 1

+

+2002-06-14 08:37  entheh

+

+	* makeall.sh, makecore.sh, readme.txt: Unix stuff should be ready.

+	Might still change to provide BeOS support though...

+

+2002-06-14 08:18  entheh

+

+	* readme.txt, docs/faq.txt: Getting there...

+

+2002-06-14 06:45  entheh

+

+	* release.txt, make/makefile.uni: Updated Unix/BeOS makefile,

+	thanks to networm (he's going in the credits soon :)

+

+2002-06-14 06:10  entheh

+

+	* makeall.bat, makecore.bat, release.txt, docs/faq.txt,

+	include/dumb.h, make/makefile.dj, make/makefile.lst,

+	make/makefile.mgw, make/makefile.uni, make/makefile.vc,

+	src/it/itread.c, src/it/itrender.c, src/it/readxm.c: Endianness

+	fixed, and work on the docs and makefiles preparing for release...

+

+2002-06-14 03:48  jcugniere

+

+	* src/it/itrender.c: Oops! fixed 2 stupid warnings...

+

+2002-06-13 12:34  jcugniere

+

+	* src/it/: itrender.c, readxm.c: more stuff on XM volpan

+

+2002-06-12 13:35  entheh

+

+	* include/internal/it.h, src/core/rendduh.c, src/it/itrender.c:

+	Added xm_volslide field for better handling of XM volume slides.

+

+2002-06-12 12:54  jcugniere

+

+	* src/it/: itrender.c, readxm.c: Trying to handle the XM volume

+	column more accurately.

+

+2002-05-30 13:36  entheh

+

+	* include/internal/dumb.h, src/it/itrender.c: Improvement to the XM

+	support.

+

+2002-05-07 10:49  jcugniere

+

+	* src/it/itrender.c: one liner to get volume properly initialized

+	with XM files

+

+2002-05-06 17:52  entheh

+

+	* src/it/itrender.c: Some uninitialised fields fixed for XM files.

+

+2002-05-06 11:37  jcugniere

+

+	* src/it/: itrender.c, readxm.c: Fixed premature fadeout

+

+2002-05-05 13:10  entheh

+

+	* include/internal/it.h, src/it/itrender.c, src/it/readxm.c: More

+	stuff

+

+2002-05-05 11:47  entheh

+

+	* src/it/: itrender.c, itrender.old.c: Stuff

+

+2002-05-04 13:46  jcugniere

+

+	* src/it/readxm.c: Removed some fixes from readxm.c, made obsolete

+	by ben's changes in itrender.c

+

+2002-04-21 09:54  entheh

+

+	* todo.txt, src/it/itrender.c, src/it/readxm.c,

+	src/sigtypes/sequence.c: Restructuring of the XM playing core. I've

+	done more harm than good... ostensibly ^_^ (look it up :P)

+

+2002-04-07 03:17  jcugniere

+

+	* include/internal/it.h, src/it/itrender.c, src/it/reads3m.c,

+	src/it/readxm.c: Fixed a stupid bug in the XM effects conversion.

+	Minor fixes to get more S3Ms to load.

+

+2002-03-26 10:30  jcugniere

+

+	* include/internal/it.h: Added a new IT_WAS_AN_XM signal flag, and

+	restart_position for XM compat.

+

+2002-03-26 10:27  jcugniere

+

+	* src/it/readxm.c: All effects are now supported (provided

+	itrender.c implements them ;). But volume effects are still

+	incorrect.

+

+2002-03-26 10:26  jcugniere

+

+	* src/it/reads3m.c: Added restart_position for XM compatibility.

+

+2002-03-26 10:25  jcugniere

+

+	* src/it/itrender.c: Modified the behavior of a few things when

+	IT_WAS_AN_XM is set. Hopefully I haven't broken anything for IT

+	files ;)

+

+2002-03-26 10:23  jcugniere

+

+	* src/it/itread.c: Added restart_position for XM compatibility

+

+2002-03-24 08:38  jcugniere

+

+	* src/it/readxm.c: Bug fixes.

+

+2002-03-21 11:44  jcugniere

+

+	* src/it/readxm.c: Some improvments on readxm.c.

+

+2002-03-14 12:50  jcugniere

+

+	* examples/playxm.c, src/it/loadxm.c, src/it/readxm.c: Added an XM

+	loader (still needs work).

+

+2002-03-14 12:46  jcugniere

+

+	* include/dumb.h, make/makefile.lst: Added an XM loader (still

+	needs work).

+

+2002-03-10 12:40  joe_programmer

+

+	* make/makefile.vc: Fixed Allegro incompatibility

+

+2002-03-03 10:21  joe_programmer

+

+	* src/it/itrender.c: Fixed some warnings

+

+2002-03-02 16:17  entheh

+

+	* include/dumb.h: MSVC compile fixed

+

+2002-03-02 13:31  entheh

+

+	* licence.txt, makeall.bat, makecore.bat, readme.txt, release.txt,

+	include/dumb.h, src/core/dumbfile.c: Hmm, possibly the last commit

+	before release?????????

+

+2002-03-02 12:23  entheh

+

+	* makeall.bat, makecore.bat: Fixed batch files.

+

+2002-03-02 12:17  entheh

+

+	* makeall.bat, makecore.bat: Added makeall.bat and makecore.bat, as

+	promised in readme.txt.

+

+2002-03-02 12:10  entheh

+

+	* readme.txt: readme.txt done.

+

+2002-03-02 10:57  entheh

+

+	* make/: makefile.dj, makefile.mgw, makefile.uni, makefile.vc:

+	Makefiles updated to allow for building without Allegro. Not tested

+	except DJGPP.

+

+2002-03-02 10:14  entheh

+

+	* readme.txt, docs/dumb.txt, include/dumb.h: Some constants added

+	and documented. First signs of content in the readme.

+

+2002-03-02 08:42  entheh

+

+	* lib/djgpp/tmpfile.txt, lib/mingw32/tmpfile.txt,

+	lib/msvc/tmpfile.txt, lib/unix/tmpfile.txt,

+	obj/djgpp/debug/tmpfile.txt, obj/djgpp/release/tmpfile.txt,

+	obj/mingw32/debug/tmpfile.txt, obj/mingw32/release/tmpfile.txt,

+	obj/msvc/debug/tmpfile.txt, obj/msvc/release/tmpfile.txt,

+	obj/unix/debug/tmpfile.txt, obj/unix/release/tmpfile.txt:

+	tmpfile.txt message changed, and some more added.

+

+2002-03-01 21:35  entheh

+

+	* include/dumb.h, make/makefile.lst: Detached default sigtype

+	stuff, since that's not to be released.

+

+2002-03-01 21:29  entheh

+

+	* readme.txt, docs/dumb.txt, docs/dumbfull.txt, docs/howto.txt,

+	docs/ptr.txt, include/aldumb.h, include/dumb.h,

+	src/allegro/datduh.c, src/allegro/datit.c, src/allegro/dats3m.c,

+	src/it/itread.c, src/it/itrender.c, src/it/itunload.c: Lots of

+	stuff, mostly work on docs. A few things neatened up.

+

+2002-02-22 21:09  entheh

+

+	* src/helpers/resample.c: High-quality resamplers are now more

+	accurate, thanks to a LONG_LONG trick that gcc optimises quite

+	nicely for us.

+

+2002-02-22 19:55  entheh

+

+	* src/helpers/resample.c: New comments at the top of resample.c,

+	and a compiler error fixed.

+

+2002-02-22 19:25  entheh

+

+	* docs/dumb.txt, docs/tutorial.txt, src/it/itread.c,

+	src/it/itrender.c, src/it/reads3m.c: Dunno what I did, but I'd

+	better commit it :)

+

+2002-02-22 14:42  joe_programmer

+

+	* src/helpers/resample.c: Volume scaling changed from float to int

+	(hope it works...)

+

+2002-02-17 03:41  entheh

+

+	* include/dumb.h, src/helpers/resample.c, src/it/itread.c,

+	src/it/itrender.c, src/it/reads3m.c: A few unresolved issues seen

+	to.

+

+2002-02-16 20:06  tjaden

+

+	* make/makefile.uni: Updated the Unix makefile (from the Mingw32

+	makefile)

+

+2002-02-16 15:10  entheh

+

+	* todo.txt: Stuff added to todo.txt

+

+2002-02-16 13:46  entheh

+

+	* include/dumb.h, make/makefile.lst, src/helpers/resample.c,

+	src/helpers/silence.c, src/it/itread.c, src/it/itrender.c,

+	src/it/reads3m.c, src/sigtypes/sample.c: Lots of work on S3M

+	support. Fundamental change; always mix into buffer, never write. 

+	Standard sigtypes probably aren't all reprogrammed correctly, but

+	they'll be stripped from the first release. Speaking of which...

+	not too long to wait now, I hope :)

+

+2002-02-06 17:28  entheh

+

+	* src/: allegro/datit.c, allegro/datunld.c, core/unload.c,

+	helpers/resample.c, it/itload.c, it/itread.c, it/itrender.c,

+	it/itunload.c, it/reads3m.c: S3M support improved upon, but it's

+	not right yet.

+

+2002-02-06 16:43  entheh

+

+	* make/: makefile.dj, makefile.lst: Makefiles updated slightly.

+

+2002-02-01 23:53  entheh

+

+	* examples/plays3m.c, include/dumb.h, make/makefile.lst,

+	src/it/itload.c, src/it/itread.c, src/it/loads3m.c,

+	src/it/reads3m.c: Hahaha S3M sounds GREAT! Utterly out of tune, but

+	GREAT! LOL, gotta show this to Louis :)

+

+2002-02-01 10:07  entheh

+

+	* include/internal/it.h: D'oh!

+

+2002-01-31 14:49  entheh

+

+	* docs/dumb.txt, include/dumb.h, make/makefile.lst, src/it/it.c,

+	src/it/itload.c, src/it/itread.c, src/it/itrender.c,

+	src/it/itunload.c: IT modularised, and dumb_it_max_to_mix

+	formalised. S3M soon!

+

+2002-01-30 17:51  entheh

+

+	* src/it/it.c: Amiga slides now programmed properly.

+

+2002-01-17 15:48  joe_programmer

+

+	* src/it/it.c: Bug fixes by entheh

+

+2002-01-11 13:21  entheh

+

+	* winamp/: in_duh.c, in_duh.h, winamp.dsp: Paranoima got the Winamp

+	plug-in up and running. Tx :)

+

+2002-01-11 12:01  entheh

+

+	* src/it/it.c, winamp/in_duh.c: Winamp plug-in updated to match new

+	API.

+

+2002-01-11 10:58  entheh

+

+	* examples/playit.c, src/it/it.c: Hmm, how to apply pan and pitch

+	envelopes in instruments that don't exist...  I AM SO DUMB oh and

+	windowes sux bcasu it lets yuo get awawy with nullptrs in dos!@~

+

+2002-01-11 02:09  entheh

+

+	* src/it/it.c: Pattern loop done.

+

+2002-01-08 16:57  entheh

+

+	* examples/playit.c, src/helpers/resample.c, src/it/it.c: IT loader

+	was faulty in more ways than one! Fixed now.  Only seven effects to

+	go!

+

+2002-01-07 17:05  entheh

+

+	* docs/dumb.txt, include/dumb.h, src/it/it.c: Pitch and panning

+	envelopes done, and a bug or two fixed.

+

+2002-01-06 17:17  entheh

+

+	* src/it/it.c: Note delay done. zasx.it should play perfectly now

+	:)

+

+2002-01-06 00:27  entheh

+

+	* src/it/it.c: Optimisations and 'damage limitation' in IT

+	playback; NEEDS TESTING.

+

+2002-01-02 02:39  entheh

+

+	* examples/playit.c, src/it/it.c: Added vibrato :) Also made the IT

+	loading code more robust, as it failed on one of my files. Testers

+	welcome :)

+

+2002-01-01 15:59  entheh

+

+	* docs/dumb.txt, src/allegro/alplay.c: Fixed a stupid bug in

+	alplay.c. Did something to dumb.txt, apparently...

+

+2001-12-31 20:44  entheh

+

+	* docs/dumb.txt: Extra info added to docs.

+

+2001-12-31 20:40  entheh

+

+	* docs/dumb.txt, examples/playduh.c, examples/playit.c,

+	include/aldumb.h, include/dumb.h, src/allegro/alplay.c,

+	src/core/rendduh.c: Additions to the renderer and Allegro player

+	APIs; docs updated.

+

+2001-12-30 17:31  entheh

+

+	* docs/dumb.txt: Modified docs to describe new dumb_[at]exit()

+	system.

+

+2001-12-30 16:25  entheh

+

+	* examples/playduh.c, examples/playit.c, include/dumb.h,

+	include/internal/dumb.h, make/makefile.lst, src/core/atexit.c,

+	src/core/main.c, src/core/readduh.c, src/core/register.c:

+	dumb_init() no longer exists. dumb_exit() just calls functions

+	registered by dumb_atexit().  Now to do the docs...

+

+2001-12-27 16:44  entheh

+

+	* docs/dumb.txt, docs/tutorial.txt, examples/playduh.c,

+	examples/playit.c, include/dumb.h, src/core/main.c,

+	src/core/register.c, src/core/rendduh.c, src/core/rendsig.c,

+	src/helpers/resample.c, src/it/it.c, src/sigtypes/combine.c,

+	src/sigtypes/sample.c, src/sigtypes/sequence.c,

+	src/sigtypes/sterpan.c: *** CHANGES TO THE API *** docs might not

+	be fully updated. Added tutorial.txt.

+

+2001-12-27 11:33  entheh

+

+	* docs/dumb.txt, include/dumb.h, src/it/it.c,

+	src/sigtypes/sequence.c: Fixed DJGPP compilation

+

+2001-12-26 22:16  joe_programmer

+

+	* make/: makefile.dj, makefile.mgw, makefile.vc: More bugs fixed in

+	the makefiles Also fixed up the DJGPP makefile

+

+2001-12-26 22:09  joe_programmer

+

+	* include/dumb.h, make/makefile.mgw, make/makefile.vc,

+	src/helpers/stdfile.c, src/it/it.c, src/sigtypes/sample.c,

+	src/sigtypes/sequence.c: Fixed warnings and errors in MSVC compile.

+	 Finished MSVC makefile.  Fixed Mingw makefile

+

+2001-12-26 21:33  joe_programmer

+

+	* include/dumb.h, make/makefile.lst, make/makefile.mgw,

+	src/it/it.c, src/sigtypes/sequence.c: Fixed Mingw32 makefile Added

+	some temp files so CVS doesn't lose the directory tree

+

+2001-12-26 16:51  joe_programmer

+

+	* lib/djgpp/tmpfile.txt, lib/mingw32/tmpfile.txt,

+	lib/msvc/tmpfile.txt, obj/djgpp/debug/tmpfile.txt,

+	obj/djgpp/release/tmpfile.txt, obj/msvc/debug/tmpfile.txt,

+	obj/msvc/release/tmpfile.txt: Added some temp files so CVS does'nt

+	lose the directory tree

+

+2001-12-26 09:40  entheh

+

+	* docs/fnptr.txt: fnptr.txt added.

+

+2001-12-26 09:26  entheh

+

+	* docs/dumb.txt, include/dumb.h, src/core/makeduh.c,

+	src/core/unload.c: A lot of work on the docs, but not finished.

+	Fixed some bugs in make_duh().

+

+2001-12-22 17:28  entheh

+

+	* docs/dumb.txt, examples/playit.c, include/aldumb.h,

+	include/dumb.h, src/allegro/packfile.c, src/core/dumbfile.c,

+	src/core/file.c, src/helpers/stdfile.c: Provided a stdio file input

+	module, amongst other things.

+

+2001-12-20 05:25  entheh

+

+	* include/aldumb.h, include/internal/aldumb.h,

+	src/allegro/datduh.c, src/allegro/datit.c, src/allegro/datunld.c,

+	src/allegro/packfile.c, src/it/it.c: register_dat_it() fixed.

+

+2001-12-19 12:12  entheh

+

+	* src/sigtypes/: combine.c, sample.c, sequence.c, sterpan.c:

+	Removed dumb_errno references from signal types. Dunno how I missed

+	them :o

+

+2001-12-17 08:57  entheh

+

+	* include/dumb.h, src/helpers/resample.c, src/it/it.c: IT files can

+	now be started from somewhere in the middle, and silent samples'

+	positions are advanced. New do_silent_resample() function for this

+	purpose.

+

+2001-12-16 17:45  entheh

+

+	* include/internal/aldumb.h, src/allegro/datduh.c,

+	src/allegro/packfile.c: Finished what I started ;)

+

+2001-12-16 17:18  entheh

+

+	* todo.txt, examples/playit.c, include/aldumb.h, include/dumb.h,

+	include/dumb/file.h, include/internal/allegro/file.h,

+	src/allegro/file.c, src/allegro/packfile.c, src/core/file.c,

+	src/core/loadduh.c, src/core/main.c, src/core/readduh.c,

+	src/it/it.c: More changes - now the port (e.g. Allegro) must

+	actively register its file handlers.  As for the IT support, note

+	retrig is now done.

+

+2001-12-16 06:11  entheh

+

+	* src/it/it.c: Some more IT effects... makefiles still out of date

+	though

+

+2001-12-14 13:32  entheh

+

+	* include/dumb.h, src/it/it.c: Did Amiga frequency slides =)

+

+2001-12-12 19:24  entheh

+

+	* todo.txt, examples/playduh.c, examples/playit.c,

+	include/aldumb.h, include/dintern.h, include/dumb.h,

+	include/minalleg.h, include/dumb/file.h, include/internal/dumb.h,

+	include/internal/allegro/file.h, src/combine.c, src/datduh.c,

+	src/getsig.c, src/it.c, src/llload.c, src/load.c, src/main.c,

+	src/play.c, src/register.c, src/render.c, src/resample.c,

+	src/sample.c, src/sequence.c, src/sterpan.c, src/unload.c,

+	src/allegro/alplay.c, src/allegro/datduh.c, src/allegro/file.c,

+	src/core/duhlen.c, src/core/loadduh.c, src/core/main.c,

+	src/core/makeduh.c, src/core/readduh.c, src/core/register.c,

+	src/core/rendduh.c, src/core/rendsig.c, src/core/unload.c,

+	src/helpers/resample.c, src/it/it.c, src/sigtypes/combine.c,

+	src/sigtypes/sample.c, src/sigtypes/sequence.c,

+	src/sigtypes/sterpan.c: NEW DIRECTORY STRUCTURE. Please do a new

+	checkout, but WARNING: NO MAKEFILES.  However, DUMB is now (almost)

+	separable from Allegro.

+

+2001-12-08 17:09  entheh

+

+	* src/it.c: Neatened up a bit... possible a bug-fix or two that I

+	don't remember doing...

+

+2001-12-07 21:38  tjaden

+

+	* make/makefile.uni: Use rm for make clean under Unices

+

+2001-12-07 21:37  tjaden

+

+	* fix.sh: New fix.sh script

+

+2001-12-07 21:33  entheh

+

+	* make/: makefile.lnx, makefile.uni: File renamed

+

+2001-12-07 19:54  entheh

+

+	* examples/unload.c, src/unload.c: Damn, that was DUMB. unload.c

+	was in the wrong place :o

+

+2001-12-07 19:39  entheh

+

+	* src/it.c: Fixed a bug affecting IT files that don't use

+	instruments. Most noticeable in that tone portamento didn't work.

+

+2001-12-07 13:56  entheh

+

+	* todo.txt, examples/unload.c, make/makefile.lst, src/combine.c,

+	src/getsig.c, src/it.c, src/llload.c, src/render.c, src/resample.c,

+	src/sample.c, src/sequence.c, src/sterpan.c: unload_duh() in

+	separate file; checked usage of free() and other stuff.

+

+2001-12-07 09:55  entheh

+

+	* todo.txt: Added to todo.txt

+

+2001-12-06 21:00  entheh

+

+	* todo.txt: Amendment to todo.txt.

+

+2001-12-06 20:12  entheh

+

+	* docs/dumb.txt: dumb.txt added.

+

+2001-12-06 19:08  entheh

+

+	* examples/playduh.c, examples/playit.c, make/makefile.lst,

+	src/main.c, winamp/in_duh.c: playit.c added. register_sigtype_*()

+	calls finally moved out of install_dumb().  That means you have to

+	call them yourself! See docs/dumb.txt.

+

+2001-12-06 18:24  entheh

+

+	* todo.txt, make/makefile.lst, src/it.c: More bugs fixed; DUMB more

+	faithful to IT. Added to todo.txt.

+

+2001-12-06 13:54  entheh

+

+	* todo.txt, src/it.c: More IT stuff done/fixed/whatever. We have

+	official permission to use sample decompression algorithms, but see

+	todo.txt.

+

+2001-12-05 12:55  entheh

+

+	* src/: it.c, resample.c: Revamped IT support has caught up with

+	cit.c. It even reproduces a bug in IT itself - the lengthy

+	experimentation payed off :) Also implemented a system to limit the

+	number of samples mixed simultaneously.

+

+2001-12-05 06:33  entheh

+

+	* src/: it.c, resample.c: More work on the IT support. Some IT

+	files actually sound nice now :)

+

+2001-12-04 19:13  entheh

+

+	* src/: sample.c, sequence.c: Unused parameter warnings fixed. I

+	now use -W as well as -Wall ;)

+

+2001-12-04 18:59  entheh

+

+	* include/dumb.h, src/it.c, src/llload.c, src/load.c: IT support

+	revamped. Now you load IT files directly. Not finished though. A

+	few other minor changes.

+

+2001-10-27 08:26  joe_programmer

+

+	* src/render.c, src/resample.c, tools/citbugs.txt: Entheh's new

+	resampling code

+

+2001-10-25 16:50  joe_programmer

+

+	* src/resample.c: entheh started a workaround for incorrect

+	multiplication generation code by C compilers. 36 bits were in fact

+	needed when only 32 were provided.  The low-pass (linear average)

+	filter is not yet completed.

+

+2001-10-21 15:40  joe_programmer

+

+	* todo.txt: Added some stuff

+

+2001-10-20 12:19  joe_programmer

+

+	* tools/citbugs.txt: Updated buglist

+

+2001-09-30 18:11  joe_programmer

+

+	* todo.txt: Updated todo

+

+2001-09-30 18:06  joe_programmer

+

+	* src/sample.c: Fixes to the loader. Samples are now properly

+	loaded, which akes the int code as good as the float code

+

+2001-09-30 17:00  joe_programmer

+

+	* todo.txt: Added todo.txt

+

+2001-09-30 10:43  joe_programmer

+

+	* include/dumb.h, src/combine.c, src/getsig.c, src/render.c,

+	src/resample.c, src/sample.c, src/sequence.c, src/sterpan.c,

+	winamp/config.rc, winamp/winamp.dsp: Converted all the floating

+	point code to integer math. 30% speed boost! Sounds like crap

+	though. I'll fix that later.

+

+2001-09-26 19:37  joe_programmer

+

+	* winamp/: config.rc, gui.c, resource.h: Fixes to the plug-in's UI

+

+2001-09-25 19:23  joe_programmer

+

+	* src/resample.c, winamp/config.rc: Minor changes to the UI

+

+2001-09-25 18:37  joe_programmer

+

+	* src/resample.c: Sped up the low pass filters

+

+2001-09-25 17:25  joe_programmer

+

+	* src/resample.c, winamp/config.rc, winamp/gui.c,

+	winamp/resource.h: Sped up the quadratic and cubic resamplers

+

+2001-09-25 16:54  joe_programmer

+

+	* src/resample.c: Added quadratic resampler

+

+2001-09-23 08:19  joe_programmer

+

+	* src/resample.c, winamp/config.rc, winamp/winamp.dsp: Slight

+	changes ot the plug-in presentation

+

+2001-09-22 11:36  joe_programmer

+

+	* include/minalleg.h, src/resample.c, winamp/config.rc,

+	winamp/gui.c, winamp/gui.h, winamp/in_duh.c, winamp/resource.h,

+	winamp/winamp.dsp: Plug-in supports threading priority, new plug-in

+	setup option, small speed-up in the cubic resampler

+

+2001-09-17 20:02  joe_programmer

+

+	* src/resample.c, winamp/config.rc, winamp/gui.c, winamp/in_duh.c,

+	winamp/resource.h, winamp/winamp.dsp: Minor speed tweaks.

+

+2001-09-16 18:49  joe_programmer

+

+	* tools/cit.c: Fixed yet another null dereferencing bug

+

+2001-09-16 12:13  joe_programmer

+

+	* winamp/: config.rc, gui.c, gui.h, in_duh.c, resource.h: Lots of

+	fixes ot the plugin

+

+2001-09-16 08:52  joe_programmer

+

+	* tools/cit.c: Fixed yet another null dereferencing bug

+

+2001-09-16 08:49  joe_programmer

+

+	* winamp/gui.c: Fixes to the plug-in

+

+2001-09-16 08:36  joe_programmer

+

+	* winamp/in_duh.c: Fixes to the plug-in

+

+2001-09-16 08:32  joe_programmer

+

+	* winamp/: config.rc, gui.c, gui.h, in_duh.c, in_duh.h, resource.h,

+	winamp.dsp: The plug-in works and is almost done now. Config screen

+	added, seeking also added

+

+2001-09-15 18:10  joe_programmer

+

+	* winamp/in_duh.h: Forgot to commit a file

+

+2001-09-15 18:08  joe_programmer

+

+	* winamp/in_duh.c: More fixes to the plug-in

+

+2001-09-15 15:47  joe_programmer

+

+	* tools/cit.c, winamp/in_duh.c, winamp/winamp.dsp: Winamp update:

+	Vis should work

+

+2001-09-15 14:38  joe_programmer

+

+	* include/minalleg.h, make/makefile.vc, src/main.c, tools/cit.c,

+	winamp/in2.h, winamp/in_duh.c, winamp/out.h, winamp/winamp.dsp:

+	Winamp plug-in works! (well, kinda)

+

+2001-09-15 13:29  joe_programmer

+

+	* make/makefile.lst, make/makefile.mgw, make/makefile.vc,

+	tools/cit.c: Updated makefiles, added drag&drop support to cit

+

+2001-09-15 11:48  joe_programmer

+

+	* examples/playduh.c, include/dumb.h, winamp/in_duh.c,

+	winamp/winamp.dsp: More Winamp changes. Plug-in is almost ready

+

+2001-09-15 09:25  joe_programmer

+

+	* include/minalleg.h, src/combine.c, src/getsig.c, src/llload.c,

+	src/load.c, src/main.c, src/play.c, src/register.c, src/render.c,

+	src/resample.c, src/sample.c, src/sequence.c, src/sterpan.c,

+	winamp/in2.h, winamp/in_duh.c, winamp/minalleg.c, winamp/out.h,

+	winamp/winamp.dsp, winamp/winamp.dsw: Winamp plug-in commit - not

+	finished yet

+

+2001-09-10 02:14  entheh

+

+	* docs/duhspecs.txt, tools/cit.c: Note Fade and New Note Actions

+	now supported. Argh! I never want to program that again. :P

+

+2001-09-09 14:25  entheh

+

+	* include/dumb.h, src/render.c: 8-bit bug fixed, but the code

+	hasn't been tested yet.

+

+2001-09-09 13:07  entheh

+

+	* include/dumb.h, src/play.c, src/render.c: Rendering and audio

+	stream playing are now separated into levels.  The rendering level

+	is available in dumb.h.  I've removed Bob's changes, so I hope it

+	won't set him back too much :)

+

+2001-09-08 20:23  joe_programmer

+

+	* src/play.c: Slight change to make winamp plugin easier to write

+	:)

+

+2001-09-07 23:38  entheh

+

+	* include/dintern.h, src/llload.c, tools/cit.c: The length of a DUH

+	file is now stored, in preparation for Winamp and/or looping

+	support.

+

+2001-09-05 19:16  entheh

+

+	* tools/cit.c: Panning bug fixed. Forgot default sample panning!

+	D'oh! :)

+

+2001-09-05 17:37  entheh

+

+	* tools/cit.c: Volume envelopes working properly now, and stereo

+	panning bug fixed.

+

+2001-09-05 11:10  entheh

+

+	* src/play.c, tools/cit.c: Volume envelopes... bleargh, zasx.duh

+	sounds pretty good now :)

+

+2001-09-04 21:12  entheh

+

+	* make/: makefile.dj, makefile.lst: Makefile update (untested)

+

+2001-09-04 19:46  entheh

+

+	* tools/cit.c: Portamento in the volume column is done, and

+	handling of 'Compatible Gxx' is in place.

+

+2001-09-04 12:56  entheh

+

+	* tools/cit.c: Pitch/Pan Separation is done.

+

+2001-09-03 09:24  entheh

+

+	* include/dumb.h, src/combine.c, src/main.c, src/sterpan.c,

+	tools/cit.c: Stereo sound now works, finally! Not all stereo stuff

+	is implemented though, and it'll suffer from the same bug as the

+	volume (see the citbugs.txt file).

+

+2001-09-02 19:34  entheh

+

+	* examples/playduh.c, include/dumb.h, src/combine.c, src/getsig.c,

+	src/main.c, src/play.c, src/sample.c, src/sequence.c: COMB signal

+	implemented. This will allow two mono signals to be combined into a

+	stereo one. SPAN (panning), and modifications to cit.c, still to do

+	before any stereo sound will be heard.

+

+2001-08-24 19:01  entheh

+

+	* include/dumb.h, src/getsig.c, src/play.c, src/resample.c,

+	src/sample.c, src/sequence.c: Support for multiple channels has

+	been added. Adding stereo sound support should be a breeze now, but

+	that'll have to wait for another day.

+

+2001-08-24 14:17  entheh

+

+	* include/dumb.h, tools/cit.c, tools/citbugs.txt: Dunno what this

+	commit is, but it seems it should've been done a long time ago :)

+

+2001-08-17 18:25  entheh

+

+	* docs/duhspecs.txt, src/sequence.c, tools/cit.c: A new compression

+	system is in use for the sequences. WARNING: OLDER DUH FILES WILL

+	CAUSE A CRASH. This is the price you pay for using a version of

+	DUMB prior to the first release :)

+

+2001-08-17 12:25  joe_programmer

+

+	* docs/duhspecs.txt: Proposal for new smaller format

+

+2001-08-17 01:49  entheh

+

+	* docs/duhspecs.txt: The DUH file format specification is now

+	documented :)

+

+2001-08-16 15:13  joe_programmer

+

+	* tools/cit.c: Fixed a NULL dereferencing bug

+

+2001-08-16 14:38  entheh

+

+	* tools/cit.c: Bug fixed (multisample instruments work) and more

+	flow control effects done

+

+2001-08-16 03:33  entheh

+

+	* src/resample.c, tools/cit.c, tools/citbugs.txt: Wahoo, resampling

+	fixed! Also did something to cit.c and added citbugs.txt.

+

+2001-08-15 22:15  joe_programmer

+

+	* src/resample.c: Fixed compilation warning

+

+2001-08-15 18:50  entheh

+

+	* include/dumb.h, src/sample.c, src/sequence.c, tools/cit.c:

+	Various stuff... cit.c improved, the sequence signal can now be

+	started halfway through...

+

+2001-08-14 23:32  entheh

+

+	* tools/cit.c: Yay, volume slides! :-)

+

+2001-08-14 16:06  entheh

+

+	* tools/cit.c: Some of the effects work! Yay! :-)

+

+2001-08-14 04:32  entheh

+

+	* tools/cit.c: cit.c has been revamped somewhat. It's a hell of a

+	lot uglier, and has lost some features. However, it is supposedly

+	more faithful to the IT standard.  Thank goodness the IT converter

+	is not to be the central attraction :-)

+

+2001-08-13 12:36  entheh

+

+	* tools/cit.c: cit.c now loads everything in the IT file. It has

+	been adapted to support everything described in the ittech.txt file

+	that comes with Impulse Tracker 2.14. However, the conversion is

+	still as awful as ever :-)

+

+2001-08-11 22:40  entheh

+

+	* tools/cit.c: Some of the "Damn, I need more information"-style

+	comments in cit.c have been replaced with information on what the

+	stuff really is :D

+

+2001-08-10 21:30  entheh

+

+	* examples/playduh.c: allegro_exit()/allegro_message() bug

+	partially fixed in playduh.c.  Still problems in case of usage(),

+	and failure on allegro_init().

+

+2001-08-10 20:07  entheh

+

+	* include/dumb.h, src/getsig.c, src/sequence.c: Removed the

+	MAX_SAMPLES limitation. STREAM_SIZE can be increased now.

+

+2001-08-10 19:31  entheh

+

+	* examples/playduh.c, include/dumb.h, src/play.c: A few

+	enhancements to the playback interface.

+

+2001-08-10 10:13  joe_programmer

+

+	* make/makefile.lst: Added new files

+

+2001-08-10 08:48  entheh

+

+	* include/dumb.h, src/play.c, src/resample.c, src/sample.c,

+	src/sequence.c, tools/cit.c: Looped samples :-)

+

+2001-08-09 11:15  entheh

+

+	* src/resample.c: Bug fixed! Resampling works

+

+2001-08-09 10:35  entheh

+

+	* include/dumb.h, src/play.c, src/resample.c, src/sample.c,

+	tools/cit.c: RESAMPLE_PICKUP stuff added, but there's a bug. Trying

+	to fix it...  Various other minor changes

+

+2001-08-06 18:06  entheh

+

+	* include/dumb.h, src/resample.c, src/sample.c, tools/cit.c:

+	Resampling code is in a separate file, and extensive comments have

+	been written for it. cit.c has very limited volume support now.

+

+2001-08-05 10:18  entheh

+

+	* tools/cit.c: A check in cit.c has gone from ASSERT to if :-)

+

+2001-08-03 23:23  joe_programmer

+

+	* tools/cit.c: Fix to the it->duh converter

+

+2001-08-03 23:12  entheh

+

+	* tools/cit.c: Bugfix, another bug has surfaced :/

+

+2001-08-03 22:39  entheh

+

+	* examples/playduh.c, include/dintern.h, include/dumb.h,

+	src/datduh.c, src/getsig.c, src/llload.c, src/load.c, src/main.c,

+	src/play.c, src/register.c, src/sample.c, src/sequence.c,

+	tools/cit.c: CIT (IT Compiler) working, just about. Tut tut, such a

+	name, so suggestive of monopolistic intentions... But anyway, the

+	new ASCII art and credits are at the top of every file!

+

+2001-08-03 11:46  entheh

+

+	* tools/cit.c: cit.c added. Currently unchanged from Bob's IT

+	loader, except that the header files have been hard-included, and

+	it now compiles as C rather than C++. Oh, and check out the new

+	ASCII art :-)

+

+2001-08-02 17:49  entheh

+

+	* src/sample.c: Changes to the sample signal so that no special

+	case is required at the end of a sample when resampling.

+

+2001-08-02 14:33  joe_programmer

+

+	* src/tools/it/: load_it.cpp, modulus.h, typedef.hpp: Added code to

+	load ITs from old IT player. needs a rewrite to work with dumb

+

+2001-08-01 19:33  entheh

+

+	* include/dumb.h, src/getsig.c, src/play.c, src/sample.c,

+	src/sequence.c: New sequencing format done.

+

+2001-08-01 15:13  entheh

+

+	* include/dintern.h, include/dumb.h, src/getsig.c, src/play.c,

+	src/register.c, src/sample.c, src/sequence.c: First signs of signal

+	parameters

+

+2001-07-28 14:40  entheh

+

+	* include/dintern.h, include/dumb.h, src/getsig.c, src/main.c,

+	src/play.c, src/sample.c, src/sequence.c: Some restructuring...

+

+2001-07-28 11:27  entheh

+

+	* src/: play.c, sample.c: Resampling fixed

+

+2001-07-28 11:16  joe_programmer

+

+	* src/sample.c: Fixes to the lowpass filter

+

+2001-07-28 10:54  joe_programmer

+

+	* src/sample.c: Attempt at fixing the low-pass filter

+

+2001-07-28 09:53  entheh

+

+	* examples/playduh.c, src/play.c, src/sample.c: Huh? uh, I don't

+	remember what I did.

+

+2001-07-28 09:44  joe_programmer

+

+	* src/sample.c: Fixes to the low-pass filter

+

+2001-07-28 09:33  joe_programmer

+

+	* src/sample.c: Added a dithering filter

+

+2001-07-28 09:08  joe_programmer

+

+	* src/sample.c: Cubic interpolation, and some form of high-pass

+	filter?

+

+2001-07-27 17:38  joe_programmer

+

+	* examples/playduh.c: Made the player work in the background

+

+2001-07-27 13:39  joe_programmer

+

+	* src/sample.c: Fixes to the lowpass filter

+

+2001-07-27 12:40  joe_programmer

+

+	* examples/playduh.c, src/sample.c: Hopefully fixed the crackiling

+	problem in the linear filter.

+

+2001-07-27 12:33  joe_programmer

+

+	* src/sample.c: Fixed the downsampling

+

+2001-07-27 12:21  joe_programmer

+

+	* src/sample.c: Bug fixed int he resampler

+

+2001-07-27 12:21  joe_programmer

+

+	* examples/playduh.c, make/makefile.vc, src/sample.c: Added linear

+	resampler and explerimental lowpass filter. Also fixed teh VC

+	makefile

+

+2001-07-25 08:33  entheh

+

+	* examples/playduh.c, include/dumb.h, src/getsig.c, src/play.c,

+	src/sample.c, src/sequence.c: Yay, for the first time it actually

+	plays MUSIC!!! :D

+

+2001-07-23 12:24  joe_programmer

+

+	* fix.bat, make/makefile.dj, make/makefile.lnx, make/makefile.lst,

+	make/makefile.mgw, make/makefile.vc: Fixes to the build scripts

+

+2001-07-23 11:28  joe_programmer

+

+	* fix.bat, make/makefile.dj, make/makefile.lnx, make/makefile.lst,

+	make/makefile.mgw, make/makefile.vc, src/misc/runner.c: Added

+	makefile system

+

+2001-07-23 10:11  entheh

+

+	* examples/playduh.c, include/dumb.h, src/getsig.c, src/llload.c,

+	src/main.c, src/play.c, src/register.c, src/sample.c,

+	src/sequence.c: [no log message]

+

+2001-07-21 08:04  entheh

+

+	* include/: dintern.h, dumb.h.ex: dumb.h.ex added, containing DUMB

+	struct stuff which will not be used for now.  Don't wanna lose

+	stuff though :-) dintern.h is now updated with the new signal

+	processing functions.  The package compiles.

+

+2001-07-21 06:43  entheh

+

+	* include/dintern.h, include/dumb.h, src/register.c:

+	Signal-handling functions are improved.

+

+2001-07-20 15:03  joe_programmer

+

+	* src/Shortcut to src.lnk: Removed file added by error

+

+2001-07-20 14:57  joe_programmer

+

+	* licence.txt, include/dintern.h, include/dumb.h, src/Shortcut to

+	src.lnk, src/datduh.c, src/llload.c, src/load.c, src/main.c,

+	src/register.c: Initial revision

+

+2001-07-20 14:57  joe_programmer

+

+	* licence.txt, include/dintern.h, include/dumb.h, src/Shortcut to

+	src.lnk, src/datduh.c, src/llload.c, src/load.c, src/main.c,

+	src/register.c: Initial checkin

+

diff --git a/plugins/dumb/dumb-kode54/Makefile.am b/plugins/dumb/dumb-kode54/Makefile.am
new file mode 100644
index 00000000..d4d3ceb8
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/Makefile.am
@@ -0,0 +1,6 @@
+SUBDIRS = docs include src examples make

+

+EXTRA_DIST = Makefile.ready

+

+dist-hook:

+	cp Makefile.ready $(distdir)/Makefile

diff --git a/plugins/dumb/dumb-kode54/Makefile.ready b/plugins/dumb/dumb-kode54/Makefile.ready
new file mode 100644
index 00000000..0ceac16d
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/Makefile.ready
@@ -0,0 +1,353 @@
+# Main Makefile for DUMB.

+

+# In theory, this Makefile can be used without modifications on DOS, Windows,

+# Linux, BeOS and Mac OS X. Caveats are as follows:

+

+# - For DOS and Windows users, COMSPEC (or ComSpec) must be set to point to

+#   command.com or cmd.exe. If they point to a Unix-style shell, this

+#   Makefile will die horribly.

+

+# - Users of other platforms must NOT set COMSPEC or ComSpec. They must be

+#   undefined.

+

+# Commands are as follows:

+

+#   make           - Build the library (does make config for you first time).

+#   make install   - Install the library and examples into the system.

+#   make uninstall - Remove the above.

+#   make config    - Do or redo the configuration.

+#   make clean     - Delete all object files; examples and libraries remain.

+#   make veryclean - Delete examples and libraries too.

+

+# TODO: consider whether to delete config.txt and/or dumbask(.exe)

+

+MAKEFILE = Makefile.ready

+

+.PHONY: all install uninstall clean veryclean config config-if-necessary

+

+PHONY_TARGETS := core allegro core-examples allegro-examples core-headers allegro-headers

+

+.PHONY: $(PHONY_TARGETS)

+.PHONY: $(PHONY_TARGETS:%=install-%)

+.PHONY: $(PHONY_TARGETS:%=uninstall-%)

+

+

+COMMA := ,

+

+ifdef USE_ICC

+CC := icc

+else

+ifdef USE_SGICC

+CC := cc

+else

+CC := gcc

+endif

+endif

+AR := ar

+

+

+# Configuration.

+# The configuration is done by an MS-DOS batch file if COMSPEC is set.

+# Otherwise it is done by a Unix shell script. A file called 'config.txt',

+# containing variables that control the build process, is created, and

+# included by this Makefile.

+

+

+ifeq "$(COMSPEC)" ""

+ifdef ComSpec

+COMSPEC := $(ComSpec)

+endif

+endif

+

+

+-include make/config.txt

+

+

+ifeq "$(OSTYPE)" "beos"

+

+INCLUDE_INSTALL_PATH := /boot/develop/headers

+LIB_INSTALL_PATH := /boot/develop/lib/x86

+BIN_INSTALL_PATH := /boot/home/config/bin

+# DEFAULT_PREFIX is not set, so config.sh will not prompt for PREFIX.

+LINK_MATH :=

+

+else

+

+ifdef PREFIX

+DEFAULT_PREFIX := $(PREFIX)

+else

+DEFAULT_PREFIX := /usr/local

+endif

+export DEFAULT_PREFIX

+INCLUDE_INSTALL_PATH := $(PREFIX)/include

+LIB_INSTALL_PATH := $(PREFIX)/lib

+BIN_INSTALL_PATH := $(PREFIX)/bin

+

+endif

+

+

+all: make-outdirs config-if-necessary

+	@$(MAKE) -f $(MAKEFILE) --no-print-directory $(ALL_TARGETS)

+	$(call ECHO,DUMB has been built. Run $(APOST)make install$(APOST) to install it.)

+

+install: make-outdirs config-if-necessary

+	@$(MAKE) -f $(MAKEFILE) --no-print-directory $(ALL_TARGETS:%=install-%)

+	$(call ECHO,DUMB has been installed.)

+	$(call ECHO,See readme.txt for details on the example programs.)

+	$(call ECHO,When you$(APOST)re ready to start using DUMB$(COMMA) see docs/howto.txt.)

+	$(call ECHO,Enjoy!)

+

+uninstall: make-outdirs config-if-necessary

+	@$(MAKE) -f $(MAKEFILE) --no-print-directory $(ALL_TARGETS:%=uninstall-%)

+	$(call ECHO,DUMB has been uninstalled.)

+

+

+ifdef COMSPEC

+# Assume DOS or Windows.

+SHELL := $(COMSPEC)

+CONFIG_COMMAND := make/config.bat

+DUMBASK_EXE := make/dumbask.exe

+else

+# Assume a Unix-compatible system.

+CONFIG_COMMAND := make/config.sh

+DUMBASK_EXE := make/dumbask

+endif

+

+# This will always configure.

+config: $(DUMBASK_EXE)

+	$(CONFIG_COMMAND)

+

+# This will only configure if the configuration file is absent. We don't use

+# config.txt as the target name, because Make then runs the config initially,

+# and again when it sees the 'config' target, so an initial 'make config'

+# causes the configuration to be done twice.

+ifeq "$(wildcard make/config.txt)" ""

+config-if-necessary: config

+else

+config-if-necessary:

+endif

+

+$(DUMBASK_EXE): make/dumbask.c

+	$(CC) $< -o $@

+

+

+ifdef PLATFORM

+

+

+# Build.

+

+

+CORE_MODULES :=            \

+    core/atexit.c          \

+    core/duhlen.c          \

+    core/duhtag.c          \

+    core/dumbfile.c        \

+    core/loadduh.c         \

+    core/makeduh.c         \

+    core/rawsig.c          \

+    core/readduh.c         \

+    core/register.c        \

+    core/rendduh.c         \

+    core/rendsig.c         \

+    core/unload.c          \

+    helpers/clickrem.c     \

+    helpers/memfile.c      \

+    helpers/resample.c     \

+    helpers/sampbuf.c      \

+    helpers/silence.c      \

+    helpers/stdfile.c      \

+    it/itload.c            \

+    it/itread.c            \

+    it/itrender.c          \

+    it/itunload.c          \

+    it/loads3m.c           \

+    it/reads3m.c           \

+    it/loadxm.c            \

+    it/readxm.c            \

+    it/loadmod.c           \

+    it/readmod.c           \

+    it/xmeffect.c          \

+    it/itorder.c           \

+    it/itmisc.c            \

+    sigtypes/sample.c

+

+ALLEGRO_MODULES :=         \

+    allegro/alplay.c       \

+    allegro/datduh.c       \

+    allegro/datit.c        \

+    allegro/datxm.c        \

+    allegro/dats3m.c       \

+    allegro/datmod.c       \

+    allegro/datunld.c      \

+    allegro/packfile.c

+

+CORE_EXAMPLES := examples/dumbout.c examples/dumb2wav.c

+ALLEGRO_EXAMPLES := examples/dumbplay.c

+

+CORE_HEADERS := include/dumb.h

+ALLEGRO_HEADERS := include/aldumb.h

+

+

+LIBDIR := lib/$(PLATFORM)

+OBJDIR_BASE := obj/$(PLATFORM)

+

+

+ifdef COMSPEC

+make-outdirs:

+	-mkdir $(subst, /, \\, $(LIBDIR))

+	-mkdir $(subst, /, \\, $(OBJDIR_BASE)\debug)

+	-mkdir $(subst, /, \\, $(OBJDIR_BASE)\release)

+else

+make-outdirs:

+	mkdir -p $(LIBDIR)

+	mkdir -p $(OBJDIR_BASE)/debug

+	mkdir -p $(OBJDIR_BASE)/release

+endif

+

+

+ifdef USE_ICC

+WFLAGS := -Wall -DDUMB_DECLARE_DEPRECATED

+WFLAGS_ALLEGRO :=

+OFLAGS := -O2

+DBGFLAGS := -DDEBUGMODE=1

+else

+ifdef USE_SGICC

+WFLAGS := -fullwarn -DDUMB_DECLARE_DEPRECATED

+WFLAGS_ALLEGRO :=

+OFLAGS := -n32 -O2 -use_readonly_const

+DBGFLAGS := -n32 -g3 -DDEBUGMODE=1

+else

+WFLAGS := -Wall -W -Wwrite-strings -Wstrict-prototypes -Wmissing-declarations -DDUMB_DECLARE_DEPRECATED

+WFLAGS_ALLEGRO := -Wno-missing-declarations

+OFLAGS := -O2 -ffast-math -fomit-frame-pointer

+DBGFLAGS := -DDEBUGMODE=1 -g3

+endif

+endif

+

+CFLAGS_RELEASE := -Iinclude $(WFLAGS) $(OFLAGS)

+CFLAGS_DEBUG := -Iinclude $(WFLAGS) $(DBGFLAGS)

+

+LDFLAGS := -s

+

+

+CORE_EXAMPLES_OBJ := $(addprefix examples/, $(notdir $(patsubst %.c, %.o, $(CORE_EXAMPLES))))

+ALLEGRO_EXAMPLES_OBJ := $(addprefix examples/, $(notdir $(patsubst %.c, %.o, $(ALLEGRO_EXAMPLES))))

+

+CORE_EXAMPLES_EXE := $(addprefix examples/, $(notdir $(patsubst %.c, %$(EXE_SUFFIX), $(CORE_EXAMPLES))))

+ALLEGRO_EXAMPLES_EXE := $(addprefix examples/, $(notdir $(patsubst %.c, %$(EXE_SUFFIX), $(ALLEGRO_EXAMPLES))))

+

+

+CORE_LIB_FILE_RELEASE := $(LIBDIR)/libdumb.a

+ALLEGRO_LIB_FILE_RELEASE := $(LIBDIR)/libaldmb.a

+

+CORE_LIB_FILE_DEBUG := $(LIBDIR)/libdumbd.a

+ALLEGRO_LIB_FILE_DEBUG := $(LIBDIR)/libaldmd.a

+

+

+core: $(CORE_LIB_FILE_RELEASE) $(CORE_LIB_FILE_DEBUG)

+allegro: $(ALLEGRO_LIB_FILE_RELEASE) $(ALLEGRO_LIB_FILE_DEBUG)

+

+core-examples: $(CORE_EXAMPLES_EXE)

+allegro-examples: $(ALLEGRO_EXAMPLES_EXE)

+

+core-headers:

+

+allegro-headers:

+

+install-core: core

+	$(call COPY,$(CORE_LIB_FILE_RELEASE),$(LIB_INSTALL_PATH))

+	$(call COPY,$(CORE_LIB_FILE_DEBUG),$(LIB_INSTALL_PATH))

+

+install-allegro: allegro

+	$(call COPY,$(ALLEGRO_LIB_FILE_RELEASE),$(LIB_INSTALL_PATH))

+	$(call COPY,$(ALLEGRO_LIB_FILE_DEBUG),$(LIB_INSTALL_PATH))

+

+ifeq "$(COMSPEC)" ""

+install-core-examples: core-examples

+	$(call COPY,$(CORE_EXAMPLES_EXE),$(BIN_INSTALL_PATH))

+

+install-allegro-examples: allegro-examples

+	$(call COPY,$(ALLEGRO_EXAMPLES_EXE),$(BIN_INSTALL_PATH))

+else

+# Don't install the examples on a Windows system.

+install-core-examples:

+install-allegro-examples:

+endif

+

+install-core-headers:

+	$(call COPY,$(CORE_HEADERS),$(INCLUDE_INSTALL_PATH))

+

+install-allegro-headers:

+	$(call COPY,$(ALLEGRO_HEADERS),$(INCLUDE_INSTALL_PATH))

+

+

+uninstall-core:

+	$(call DELETE,$(LIB_INSTALL_PATH)/$(notdir $(CORE_LIB_FILE_RELEASE)))

+	$(call DELETE,$(LIB_INSTALL_PATH)/$(notdir $(CORE_LIB_FILE_DEBUG)))

+

+uninstall-allegro:

+	$(call DELETE,$(LIB_INSTALL_PATH)/$(notdir $(ALLEGRO_LIB_FILE_RELEASE)))

+	$(call DELETE,$(LIB_INSTALL_PATH)/$(notdir $(ALLEGRO_LIB_FILE_DEBUG)))

+

+ifeq "$COMSPEC" ""

+uninstall-core-examples:

+	$(call DELETE,$(patsubst %,$(BIN_INSTALL_PATH)/%,$(notdir $(CORE_EXAMPLES_EXE))))

+

+uninstall-allegro-examples:

+	$(call DELETE,$(patsubst %,$(BIN_INSTALL_PATH)/%,$(notdir $(ALLEGRO_EXAMPLES_EXE))))

+else

+# The examples wouldn't have been installed on a Windows system.

+uninstall-core-examples:

+uninstall-allegro-examples:

+endif

+

+uninstall-core-headers:

+	$(call DELETE,$(patsubst %,$(INCLUDE_INSTALL_PATH)/%,$(notdir $(CORE_HEADERS))))

+

+uninstall-allegro-headers:

+	$(call DELETE,$(patsubst %,$(INCLUDE_INSTALL_PATH)/%,$(notdir $(ALLEGRO_HEADERS))))

+

+

+OBJDIR := $(OBJDIR_BASE)/release

+CFLAGS := $(CFLAGS_RELEASE)

+CORE_LIB_FILE := $(LIBDIR)/libdumb.a

+ALLEGRO_LIB_FILE := $(LIBDIR)/libaldmb.a

+include make/Makefile.inc

+

+OBJDIR := $(OBJDIR_BASE)/debug

+CFLAGS := $(CFLAGS_DEBUG)

+CORE_LIB_FILE := $(LIBDIR)/libdumbd.a

+ALLEGRO_LIB_FILE := $(LIBDIR)/libaldmd.a

+include make/Makefile.inc

+

+

+$(CORE_EXAMPLES_EXE): examples/%$(EXE_SUFFIX): examples/%.o $(CORE_LIB_FILE_RELEASE)

+	$(CC) $^ -o $@ $(LDFLAGS) $(LINK_MATH)

+

+$(ALLEGRO_EXAMPLES_EXE): examples/%$(EXE_SUFFIX): examples/%.o $(ALLEGRO_LIB_FILE_RELEASE) $(CORE_LIB_FILE_RELEASE)

+	$(CC) $^ -o $@ $(LDFLAGS) $(LINK_ALLEGRO)

+

+$(CORE_EXAMPLES_OBJ): examples/%.o: examples/%.c include/dumb.h

+	$(CC) $(CFLAGS_RELEASE) -c $< -o $@

+

+$(ALLEGRO_EXAMPLES_OBJ): examples/%.o: examples/%.c include/dumb.h include/aldumb.h

+	$(CC) $(CFLAGS_RELEASE) -Wno-missing-declarations -c $< -o $@

+

+

+clean:

+	$(call DELETE,$(call FIX,$(OBJDIR_BASE)/release/*.o))

+	$(call DELETE,$(call FIX,$(OBJDIR_BASE)/debug/*.o))

+	$(call DELETE,$(call FIX,examples/*.o))

+

+veryclean: clean

+	$(call DELETE,$(call FIX,$(CORE_LIB_FILE)))

+	$(call DELETE,$(call FIX,$(ALLEGRO_LIB_FILE)))

+	$(call DELETE,$(call FIX,$(CORE_EXAMPLES_EXE)))

+	$(call DELETE,$(call FIX,$(ALLEGRO_EXAMPLES_EXE)))

+

+

+else

+

+make-outdirs:  # don't make output before configuration

+

+endif # ifdef PLATFORM

diff --git a/plugins/dumb/dumb-kode54/bootstrap b/plugins/dumb/dumb-kode54/bootstrap
new file mode 100644
index 00000000..af1d538a
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/bootstrap
@@ -0,0 +1,8 @@
+#!/bin/sh

+

+set -x && \

+mkdir -p config && \

+aclocal && \

+libtoolize --force --copy && \

+automake --foreign --add-missing --copy && \

+autoconf

diff --git a/plugins/dumb/dumb-kode54/configure.in b/plugins/dumb/dumb-kode54/configure.in
new file mode 100644
index 00000000..b49ad577
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/configure.in
@@ -0,0 +1,60 @@
+dnl Boilerplace code.

+

+AC_INIT(include/dumb.h)

+AC_CONFIG_AUX_DIR(config)

+

+VERSION=0.9.2

+PACKAGE="dumb"

+

+AC_SUBST(VERSION)

+AC_SUBST(PACKAGE)

+

+AM_INIT_AUTOMAKE($PACKAGE, $VERSION)

+

+

+dnl Checks for options.

+

+AC_ARG_ENABLE(debug,

+    AC_HELP_STRING(--enable-debug, build debug),

+    CXXFLAGS="$CXXFLAGS -g"

+    AC_DEFINE(DEBUG))

+

+AC_ARG_ENABLE(deprec,

+    AC_HELP_STRING(--enable-deprec, enable deprecated functions),

+    AC_DEFINE(DUMB_DECLARE_DEPRECATED))

+

+

+dnl Checks for programs.

+

+AC_PROG_CC

+AC_PROG_CPP

+AM_PROG_LIBTOOL

+

+

+dnl Checks for libraries.

+

+dnl If building with gcc, use -Wall.

+if test "x$GCC" = "xyes" ; then

+   CFLAGS="$CFLAGS -Wall"

+fi

+

+dnl XXX check for allegro here

+

+

+dnl Checks for header files.

+

+AC_HEADER_STDC

+

+dnl AC_C_BIGENDIAN  ??

+

+

+dnl Output makefiles.

+

+AC_OUTPUT(

+        Makefile

+        docs/Makefile

+        include/Makefile

+        include/internal/Makefile

+        src/Makefile

+        examples/Makefile

+        make/Makefile)

diff --git a/plugins/dumb/dumb-kode54/docs/Makefile.am b/plugins/dumb/dumb-kode54/docs/Makefile.am
new file mode 100644
index 00000000..86ccd9b8
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/docs/Makefile.am
@@ -0,0 +1,11 @@
+EXTRA_DIST = \

+	deprec.txt \

+	duhspecs.txt \

+	dumb.txt \

+	dumbfull.txt \

+	faq.txt \

+	fnptr.txt \

+	howto.txt \

+	modplug.txt \

+	ptr.txt \

+	tutorial.txt

diff --git a/plugins/dumb/dumb-kode54/docs/deprec.txt b/plugins/dumb/dumb-kode54/docs/deprec.txt
new file mode 100644
index 00000000..6ab7b60a
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/docs/deprec.txt
@@ -0,0 +1,281 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * deprec.txt - Deprecated functions, why they        / / \  \

+ *              were deprecated, and what to do      | <  /   \_

+ *              instead.                             |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+**********************************************

+*** How the functions have been deprecated ***

+**********************************************

+

+

+   GCC 3.1 and later provide a very useful attribute. The following:

+

+      __attribute__((__deprecated__))

+

+   when written alongside a function prototype, variable declaration or type

+   definition, will result in a warning from GCC if any such part of the API

+   is used. The warning will even tell you where the declaration is, and I

+   have inserted comments by all the deprecated declarations, telling you

+   what to do.

+

+   Unfortunately, GCC 2.x and 3.0.x and MSVC do not have any means to

+   deprecate things. The approach I have taken with these compilers is to

+   avoid prototyping the deprecated parts of the API. This means you will get

+   warnings and errors, and they won't be very helpful. If your program

+   compiles, you may get strange crashes when you run it, since the compiler

+   needs the declarations in order to make sure function calls are carried

+   out correctly.

+

+   If you would like the deprecated parts of the API to be declared, you can

+   compile with the -DDUMB_DECLARE_DEPRECATED switch for GCC, or the

+   -D"DUMB_DECLARE_DEPRECATED" switch for MSVC. This will be accepted by

+   GCC 3.x but is unnecessary. Use this switch with other people's projects

+   if necessary, but please make the effort to update your own projects to

+   use the new API, as the deprecated parts may be removed in the future.

+

+   The rest of this file explains why some parts of the API were deprecated,

+   and how to adapt your code.

+

+

+**************************************

+*** What happened to DUH_RENDERER? ***

+**************************************

+

+

+   The DUH_RENDERER struct was designed for rendering audio to an end-user

+   format - 8-bit or 16-bit, signed or unsigned, with stereo samples

+   interleaved. In order for it to do this, it was built on top of the

+   hitherto undocumented DUH_SIGRENDERER struct, which rendered audio in

+   DUMB's internal 32-bit signed format with channels (left/right) stored

+   separately. The DUH_RENDERER struct contained a pointer to a

+   DUH_SIGRENDERER struct, along with some other data like the position and

+   number of channels.

+

+   There were then some developments in the API. The DUH_SIGRENDERER struct

+   also stored the position and the number of channels, so I decided to write

+   functions for returning these. Suddenly there was no need to store them in

+   the DUH_RENDERER struct. Before long, the DUH_RENDERER struct contained

+   nothing but a pointer to a DUH_SIGRENDERER.

+

+   I decided it would be a good idea to unify the structs. After all, there

+   really is no difference between the data stored in each, and it would be

+   easy to make duh_render(DUH_RENDERER *dr, ...) and

+   duh_render_signal(DUH_SIGRENDERER *sr, ...) work on the same type of

+   struct. (Note that duh_render_signal() is now deprecated too; see the next

+   section.) It took some deliberation, but I decided I didn't want functions

+   to be #defined (it prevents you from using these names for member

+   functions in C++ classes), and that meant they had to be defined

+   somewhere. Defining redundant functions is a source of bloat, inefficiency

+   and general inelegance. After weighing things up, I decided it was better

+   to deprecate the redundant functions and have people begin to use the more

+   efficient versions, and eventually the redundant functions will be able to

+   be removed.

+

+   So why did I choose to keep the more complicated name, DUH_SIGRENDERER?

+   The reason has to do with what DUMB will become in the future. Signals are

+   an inherent part of the DUH struct and how .duh files will be constructed.

+   It will be possible to have multiple signals in a single DUH struct, and

+   you will be able to choose which one you want to play (this is the 'sig'

+   parameter passed to duh_start_sigrenderer()). But don't hold your breath;

+   we still have a long way to go before .duh files will start to appear...

+

+

+typedef DUH_SIGRENDERER DUH_RENDERER;

+

+   Wherever you are using DUH_RENDERER in your program, simply replace it

+   with DUH_SIGRENDERER. An automated (case-sensitive!) search and replace

+   operation should get this done.

+

+

+DUH_RENDERER *duh_start_renderer(DUH *duh, int n_channels, long pos);

+

+   Use duh_start_sigrenderer() instead. It takes an extra parameter, 'sig',

+   which comes after 'duh' and before 'n_channels'; pass 0 for this. So an

+   example would be, replace:

+

+      sr = duh_start_renderer(duh, 2, 0);

+

+   with:

+

+      sr = duh_start_sigrenderer(duh, 0, 2, 0);

+

+

+int duh_renderer_get_n_channels(DUH_RENDERER *dr);

+long duh_renderer_get_position(DUH_RENDERER *dr);

+void duh_end_renderer(DUH_RENDERER *dr);

+

+   These are easy enough to fix; all you have to do is replace 'renderer'

+   with 'sigrenderer'. So the new functions are:

+

+      int duh_sigrenderer_get_n_channels(DUH_SIGRENDERER *sigrenderer);

+      long duh_sigrenderer_get_position(DUH_SIGRENDERER *sigrenderer);

+      void duh_end_sigrenderer(DUH_SIGRENDERER *sigrenderer);

+

+

+Note that duh_render() has NOT been deprecated. It now uses DUH_SIGRENDERER

+instead of DUH_RENDERER, but its functionality is unchanged. You do not have

+to change calls to this function in any way.

+

+

+DUH_RENDERER *duh_renderer_encapsulate_sigrenderer(DUH_SIGRENDERER *sr);

+DUH_SIGRENDERER *duh_renderer_get_sigrenderer(DUH_RENDERER *dr);

+DUH_SIGRENDERER *duh_renderer_decompose_to_sigrenderer(DUH_RENDERER *dr);

+

+   These functions did not exist in the last release of DUMB, so you are

+   probably not using them, but they are included here for completeness. All

+   you have to do here is unwrap the function, since the structs have been

+   unified. So, for instance, replace:

+

+      duh_renderer_encapsulate_sigrenderer(my_sigrenderer)

+

+   with:

+

+      my_sigrenderer

+

+   Simple!

+

+

+AL_DUH_PLAYER *al_duh_encapsulate_renderer(DUH_RENDERER *dr,

+                                       float volume, long bufsize, int freq);

+DUH_RENDERER *al_duh_get_renderer(AL_DUH_PLAYER *dp);

+DUH_RENDERER *al_duh_decompose_to_renderer(AL_DUH_PLAYER *dp);

+

+   Again, these functions were not in the last release, so you probably

+   aren't using them. Nevertheless, the fix is simple as always: simply

+   replace 'renderer' with 'sigrenderer'. So the new functions are:

+

+      AL_DUH_PLAYER *al_duh_encapsulate_sigrenderer(DUH_SIGRENDERER *sr,

+                                       float volume, long bufsize, int freq);

+      DUH_SIGRENDERER *al_duh_get_sigrenderer(AL_DUH_PLAYER *dp);

+      DUH_SIGRENDERER *al_duh_decompose_to_sigrenderer(AL_DUH_PLAYER *dp);

+

+

+*********************

+*** Miscellaneous ***

+*********************

+

+

+long duh_render_signal(DUH_SIGRENDERER *sigrenderer,

+                       float volume, float delta,

+                       long size, sample_t **samples);

+

+   This function used to return samples in DUMB's internal format. This

+   format consisted of 32-bit integers whose 'normal range' was -0x8000 to

+   0x7FFF (any samples outside this range would have to be clipped when sent

+   to the sound card).

+

+   DUMB's internal format has changed. DUMB still uses 32-bit integers, but

+   now the normal range is -0x800000 to 0x7FFFFF. The lowest eight bits are

+   discarded at the final stage by duh_render() when you ask for 16-bit

+   output. A new function, duh_sigrenderer_get_samples(), will return samples

+   in DUMB's new internal format. It takes exactly the same parameters, so

+   all you have to do to the call itself is change the name; however, you

+   will most likely have to change your code to account for the new

+   normalised range.

+

+   duh_render_signal() will still be able to give you the samples in DUMB's

+   old internal format, but it is inefficient. You should change your code as

+   soon as possible.

+

+

+typedef void (*DUH_SIGRENDERER_CALLBACK)(void *data, sample_t **samples,

+                                         int n_channels, long length);

+

+void duh_sigrenderer_set_callback(DUH_SIGRENDERER *sigrenderer,

+                              DUH_SIGRENDERER_CALLBACK callback, void *data);

+

+   This callback was intended to allow you to analyse the output. It was by

+   no means intended to let you modify the output. For this reason, the names

+   have been changed to DUH_SIGRENDERER_ANALYSER_CALLBACK and

+   duh_sigrenderer_set_analyser_callback, and the 'samples' parameter to your

+   callback should now be specified as follows:

+

+      const sample_t *const *samples

+

+   The first 'const' indicates that you must not modify the samples. The

+   second indicates that you must not modify the pointers to each channel.

+

+   There is a second reason why this change was necessary, and it is the one

+   described further up for duh_render_signal()'s entry: the format in which

+   the samples themselves are stored has changed. They are 256 times as

+   large, with a normal range from -0x800000 to 0x7FFFFF. You will most

+   likely need to change your code to account for this.

+

+   If you try to call the old function, it will print a message to stderr

+   directing you to this file, and it will not install the callback. You

+   shouldn't be able to get this far without a compiler warning (or, if you

+   don't have GCC 3.1 or later, some compiler errors).

+

+   If you wanted to use this callback to apply a DSP effect, don't worry;

+   there is a better way of doing this. It is undocumented, so contact me

+   and I shall try to help. Contact details are at the bottom of this file.

+

+   For reference, here are the new definitions:

+

+   typedef void (*DUH_SIGRENDERER_ANALYSER_CALLBACK)(void *data,

+                const sample_t *const *samples, int n_channels, long length);

+

+   void duh_sigrenderer_set_analyser_callback(DUH_SIGRENDERER *sigrenderer,

+                     DUH_SIGRENDERER_ANALYSER_CALLBACK callback, void *data);

+

+

+int dumb_resampling_quality;

+

+   This variable has changed meaning. It used to hold a value from 0 to 4,

+   whose meaning was as follows:

+

+        0   - aliasing

+       1,2  - linear interpolation

+        3   - quadratic interpolation

+        4   - cubic interpolation

+

+       0,1  - always use a straightforward interpolation algorithm

+      2,3,4 - when decimating (increasing the pitch), use a linear average

+              algorithm designed to reduce frequencies that would otherwise

+              reflect off the Nyquist

+

+   Now the variable only holds values from 0 to 2, and these values have

+   preprocessor constants associated with them. The somewhat inappropriate

+   quadratic interpolation has been removed. The linear average algorithm has

+   also been removed, and may or may not come back; there are probably more

+   efficient ways of achieving the same effect, which I shall be

+   investigating in the future.

+

+   This change will have hardly any noticeable effect on existing programs.

+   Levels 2, 3 and 4 used considerably more processor time because of the

+   linear average algorithm. Likewise, Level 2 in the new scheme (cubic) uses

+   considerably more processor time than Levels 1 and 0, and Levels 3 and 4

+   will behave identically to Level 2.

+

+

+******************

+*** Conclusion ***

+******************

+

+

+"I conclude that... DUMB is the bestest music player in the world because...

+Complete this sentence in fifteen words or fewer... D'OH!"

+

+The preceding conclusion formerly appeared in dumb.txt, and is deprecated

+because it's lame.

+

+

+Ben Davis

+entheh@users.sf.net

+IRC EFnet #dumb

+See readme.txt for details on using IRC.

diff --git a/plugins/dumb/dumb-kode54/docs/duhspecs.txt b/plugins/dumb/dumb-kode54/docs/duhspecs.txt
new file mode 100644
index 00000000..43b3d39c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/docs/duhspecs.txt
@@ -0,0 +1,296 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * duhspecs.txt - DUH File Specifications.            / / \  \

+ *                                                   | <  /   \_

+ * Written by entheh, one of the few programmers     |  \/ /\   /

+ * in existance who can spell correctly.              \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+Technical Details

+=================

+

+WARNING: until this warning disappears, the DUH file format could change at

+any moment. This should not be of great concern, since DUH files are not

+designed to be edited directly, but will always be generated from some other

+format. However, it is our intention that this warning be removed before the

+first release.

+

+This document is written chiefly in the context of writing a DUH file, since

+the library already contains the necessary functionality to read and play a

+DUH file.

+

+DUH files are currently saved using Allegro's file compression routines. See

+Allegro's documentation and source code for details on this system. If you

+wish to port DUMB away from Allegro and wish to preserve the file compression

+capabilities, you will have to borrow the packfile source code from Allegro.

+

+If you are happy to do away with file compression, please store the following

+four-byte signature before the rest of the file: "slh." Alternatively, write

+your DUH file writer with Allegro, and open the file with F_WRITE_NOPACK.

+This will enable versions of the library using Allegro's file compression

+routines to load the file. If you are reading a DUH file and you detect the

+signature "slh!", then the file is compressed (and is not necessarily a DUH

+file).

+

+All numbers are little-endian unless specified otherwise. Allegro's

+pack_iget*() and pack_iput*() functions can be used to read and write data in

+this format. However, the four-byte signatures can be encoded into long ints

+with AL_ID() and read and written with pack_m*().

+

+

+Overall Structure

+=================

+

+Size  Type  Value              Example C code to save to PACKFILE *f

+

+   4  ID    "DUH!"             pack_mputl(AL_ID('D','U','H','!'), f);

+   4  Int   Number of signals  pack_iputl(n_signals, f);

+

+For each signal {              for (i = 0; i < n_signals; i++) {

+   4  ID    Signal type           pack_mputl(AL_ID('S','E','Q','U'), f);

+   *  -     Signal data           write_sequence(f);

+}                              }

+

+* The size of the data for any signal must either be constant or somehow

+  encoded in the data themselves. The library contains functions to read

+  various standard signal types, including "SAMP" and "SEQU" (sample and

+  sequence respectively), and the formats for these types are laid out

+  further down. If you wish to create your own signals, you must provide your

+  own loading function for the signal. This will be described in more detail

+  in a separate file.

+

+In order to play a DUH file, we simply play the first signal. Signals can

+construct their sound from the samples of other signals, and they in turn can

+use other signals. Thus a recursive structure is built up. Recursive cycles

+are not permitted.

+

+

+Signal: SAMP (Sample)

+=====================

+

+Size  Type  Value              Example C code to save to PACKFILE *f

+

+   4  Int   Size               pack_iputl(size, f);

+   1  Bits  Flags              pack_putc(flags, f);

+   1  ID    Compression type   pack_putc(compress, f); /* NOT IMPLEMENTED YET */

+

+The flags are stored in a bit-field. Bit 0 indicates whether 16-bit samples

+(set) or 8-bit samples (clear) are stored in the file. In both cases, the

+samples are signed. NOTE: this bit might be replaced with a system allowing

+for various sample compression algorithms, or altered so there are different

+signal types for the purpose.

+

+If Bit 1 is set, the sample is a looping sample, and loops indefinitely. In

+this case the loop start point will be saved. The loop end point is not

+saved, and is assumed to be the end of the sample. (When creating DUH files

+from other formats which allow for the loop end to be earlier, you should

+truncate the sample.)

+

+If Bit 1 is not set, then Bit 2 may be set to indicate that the sample is

+looping but only loops a finite number of times before continuing to play

+normally. In this mode, both loop points (start and end) are saved in the

+file. The number of times to loop will be specified on an instance-by-

+instance basis using signal parameter #0, which should be set immediately

+(before any samples are rendered) if it is to be set at all. It defaults to 0

+(so the sample just plays through normally). In fact this parameter's value

+is added to the loop count, but this is immaterial since there is no reason

+to specify it more than once.

+

+If Bit 1 is set, you should make sure Bit 2 is clear to allow for the

+possibility of future expansion.

+

+If Bit 3 is set, a ping-pong loop is used. When the sample reaches the loop

+end point, it starts to play backwards until it reaches the loop start point,

+at which time it will resume forward playback. When using a finite loop,

+every change of direction counts as one iteration. That means an odd loop

+count will cause the sample to proceed backwards when the looping ends.

+

+If neither Bit 1 nor Bit 2 is set, then neither loop point will be saved. In

+this case, you should also make sure Bit 3 is clear for the same reason as

+above.

+

+You may find the following definitions useful:

+

+#define SAMPFLAG_16BIT    1

+#define SAMPFLAG_LOOP     2

+#define SAMPFLAG_XLOOP    4

+#define SAMPFLAG_PINGPONG 8

+

+#define SAMPPARAM_N_LOOPS 0

+

+Size  Type  Value              Example C code to save to PACKFILE *f

+

+   4  Int   Loop start         pack_iputl(loop_start, f);

+   4  Int   Loop end           pack_iputl(loop_end, f);

+

+For a 16-bit sample:           if (flags & SAMPFLAG_16BIT)

+                                  for (n = 0; n < size; n++)

+ x*2  Int   Sample data              pack_iputw(sample[n], f);

+For an 8-bit sample:           else

+                                  for (n = 0; n < size; n++)

+ x*1  Int   Sample data              pack_putc(sample[n], f);

+

+/*

+Compression type is 0 for uncompressed PCM.

+*/

+

+

+Signal: SEQU (Sequence)

+=======================

+

+Size  Type  Value              Example C code to save to PACKFILE *f

+

+   4  Int   Size               size = pack_igetl(f);

+   x  -     Sequencing data    pack_fwrite(data, size, f);

+

+The sequence signal provides a medium in which other signals can be played at

+specific times for specific lengths. You can control the pitch, volume and

+other parameters for a signal, and these can change during the signal.

+

+A sequence consists of a series of commands. Each command is preceded by a

+time, which measures how long to wait before executing this command. A time

+of zero indicates that this command is simultaneous with the previous. A time

+of -1 indicates the end of the sequence. Note that signals do not stop

+playing when the end is reached.

+

+All times are measured in units such that 65536 corresponds to one second.

+The timing in DUMB is accurate to the nearest sample, and cannot be offset in

+the way it can with much mixing software, so you can rely on timing to

+achieve certain effects. Resampling should be accurate enough to satisfy the

+most acute musician's ear, but juggling pitches at this level of accuracy

+requires knowledge of temperaments such as many musicians do not have. The

+vast majority of people are satisfied with the even temperament. More on this

+later.

+

+Size  Type  Value              Example C code to save to PACKFILE *f

+

+   4  Int   Time               pack_iputl(time, f);

+   1  ID    Command            pack_putc(SEQUENCE_START_SIGNAL, f);

+

+/********************************

+ Proposed change: 

+  Time is a short, encoded in 2 bytes.

+  The value of 'time' is actually an unsigned offset from the time of the

+  previous command. 0 means at the same time as the last command.

+  If the time in between this signal and the previous one is larger than

+  65534 ticks, then the value 65535 is written, followed by 4 more bytes (uint)

+  indicating the time offset.

+**********************************/

+

+Here are definitions for the various commands:

+

+#define SEQUENCE_START_SIGNAL  0

+#define SEQUENCE_SET_VOLUME    1

+#define SEQUENCE_SET_PITCH     2

+#define SEQUENCE_SET_PARAMETER 3

+#define SEQUENCE_STOP_SIGNAL   4

+

+Below are the details of what to write after each command code. The various

+fields are explained afterwards.

+

+Size  Type  Value              Example C code to save to PACKFILE *f

+

+SEQUENCE_START_SIGNAL:

+   1  ID    Reference          pack_putc(ref, f);

+   4  Int   Signal             pack_iputl(signal, f);   /* --> Can we drop this to 2 bytes? (65536 signals) */

+   4  Int   Starting position  pack_iputl(pos, f);

+   2  Int   Volume             pack_iputw(volume, f);

+   2  Int   Pitch              pack_iputw(pitch, f);

+

+SEQUENCE_SET_VOLUME:

+   1  ID    Reference          pack_putc(ref, f);

+   2  Int   Volume             pack_iputw(volume, f);

+

+SEQUENCE_SET_PITCH:

+   1  ID    Reference          pack_putc(ref, f);

+   2  Int   Pitch              pack_iputw(pitch, f);

+

+SEQUENCE_SET_PARAMETER:

+   1  ID    Reference          pack_putc(ref, f);

+   1  ID    Parameter ID       pack_putc(id, f);

+   4  Int   Value              pack_iputl(value, f);

+

+SEQUENCE_STOP_SIGNAL:

+   1  ID    Reference          pack_putc(ref, f);

+

+When you initiate a signal, you must choose a reference number. If you want

+to modify the signal's volume, pitch or parameters, or stop the signal later,

+you must use this reference number to do so. Need more than 256 reference

+numbers? Use two sequences, and get your brain seen to.

+

+If you initiate a new signal with the same reference number, the reference

+will belong to the new signal. The old signal becomes anonymous, and will

+either continue to play indefinitely or stop of its own accord. Even if the

+new signal stops, the old one remains anonymous. DUMB will safely ignore

+operations on reference numbers not used by any signal, or which were used by

+a signal which has now stopped.

+

+Of course all signals will stop if the sequence itself is stopped.

+

+To initiate a signal, you must index the signal. The index is 0-based, so to

+initiate the fifth signal in the file you must specify 4. Out-of-range values

+will be handled safely, as will the case where a signal tries to generate

+itself directly or indirectly from its own samples (a recursive cycle).

+

+When you initiate a signal, you can specify a starting position. This will be

+passed directly to the appropriate signal's start_samples function, so for a

+SAMP (sample) signal it represents the sample on which to start, after any

+loops have been expanded (so you can start on the backwards-playing part of

+a ping-pong loop for example by careful choice of the starting position).

+

+Volume is probably the simplest parameter. It is on a linear scale ranging

+from 0 to 65535. Note that most music sounds more dramatic if the volume

+rises and falls exponentially or on a greater curve. Linear fades are more

+suitable for fading in and out, and do not sound dramatic in the least.

+

+Pitch is specified on what is perceived as a linear scale. It is in fact

+logarithmic, but you will not need to worry about this for most purposes.

+Pitch 0 represents that the sample will be played at 65536 Hz. (This is not

+strictly true, and will be explained further later.) In the likely case that

+your sample is not recorded at 65536 Hz, you will first need to calculate the

+central pitch. Use the following formula:

+

+pitch_centre = 12 * 256 * log(sampling_frequency / 65536.0) / log(2);

+

+If your programming language does not have a log function, look for ln, or

+any function that calculates the logarithm (to any base) of the number you

+give it. If you are lucky enough to find a logarithm to base 2, you can omit

+the final division since the divisor evaluates to 1.

+

+Once you have calculated pitch_centre, you can use it to play the sample at

+the frequency at which it was recorded. Each time you add or subtract 256,

+the sample will increase or decrease respectively in pitch by one semitone in

+the even temperament. (The even temperament was noted further up as being

+suitable for most musical applications.) One octave is represented by an

+interval of 12 * 256.

+

+If you wish to use another temperament, you can calculate the appropriate

+intervals in pitch as follows:

+

+pitch_interval = 12 * 256 * log(ratio) / log(2);

+

+where, for example, ratio = 1.5 for a perfect fifth. An octave is, of course,

+still represented by 12 * 256.

+

+The SEQUENCE_SET_PARAMETER command needs little explanation. Quite simply,

+the parameter ID and value you specify are passed on to the set_parameter

+function of the signal to which this reference belongs. Exactly what this

+does depends on the signal in question.

+

+Remember, a sequence is a signal in itself. Like all signals, it is subject

+to changes in pitch. Increasing the pitch of a sequence will also speed it

+up. This capability is used to allow DUH files to be rendered at different

+sampling frequencies, and it is also available for use by the musician. This

+means that samples are only played at 65536 Hz if the pitch of the sequence

+itself has not been adjusted.

diff --git a/plugins/dumb/dumb-kode54/docs/dumb.txt b/plugins/dumb/dumb-kode54/docs/dumb.txt
new file mode 100644
index 00000000..4f6cc69b
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/docs/dumb.txt
@@ -0,0 +1,1699 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * dumb.txt - DUMB library reference.                 / / \  \

+ *                                                   | <  /   \_

+ * See readme.txt for general information on         |  \/ /\   /

+ * DUMB and how to set it up.                         \_  /  > /

+ *                                                      | \ / /

+ * If you are new to DUMB, see howto.txt.               |  ' /

+ *                                                       \__/

+ */

+

+

+***********************************

+*** Include Files and Libraries ***

+***********************************

+

+

+dumb.h

+

+   Include this if you only want the core DUMB library functions. You will

+   be able to load music files and render them into memory buffers at your

+   own pace. The core library is completely portable, and as such does not

+   access hardware; you must relay the sound data to the sound card yourself.

+   A stdio file input module is available, but you must actively register it

+   if you wish to use it (see dumb_register_stdfiles()); if you do not

+   register it, it will not be linked into your executable. You must register

+   it, or a DUMBFILE module of your own, in order to load stand-alone music

+   files.

+

+   Optimised: -ldumb   or  /link dumb.lib

+   Debugging: -ldumbd  or  /link dumbd.lib

+

+

+aldumb.h

+

+   Include this if you wish to use DUMB with Allegro. This will provide you

+   with functions to play DUHs back through Allegro's audio streams and embed

+   music files in Allegro datafiles. A file input module using Allegro's

+   packfiles is provided; you have a choice between this and the stdio

+   module (or provide one of your own). You will be able to load datafiles

+   containing music files no matter which file input module you register, or

+   even if you register no file input module. However, you must register a

+   file input module in order to load stand-alone files.

+

+   Optimised: -laldmb -ldumb -lalleg  or  /link aldmb.lib alleg.lib dumb.lib

+   Debugging: -laldmd -ldumbd -lalld  or  /link aldmd.lib alld.lib dumbd.lib

+

+   aldmb or aldmd must be linked in first, so the symbols can be resolved

+   when linking in the other two libraries.

+

+

+***************************

+*** Version Information ***

+***************************

+

+

+#define DUMB_MAJOR_VERSION

+#define DUMB_MINOR_VERSION

+#define DUMB_REVISION_VERSION

+

+   Numeric constants representing this version of DUMB. If this were version

+   1.0, DUMB_MAJOR_VERSION would be 1 and DUMB_MINOR_VERSION would be 0.

+   DUMB_REVISION_VERSION will be 0 on any significant releases, and will be

+   incremented as releases with bugfixes and minor features are made.

+

+   Typical usage:

+

+      #if DUMB_MAJOR_VERSION < 1

+      #error This add-on requires DUMB v1.0 or higher. Please upgrade.

+      #endif

+

+

+#define DUMB_VERSION

+

+   A numeric constant which appears in the format MMmmrr when displayed in

+   decimal (M for major, m for minor, r for revision). This is most useful

+   for comparing version numbers; it has little other practical use.

+

+   Typical usage:

+

+      #if DUMB_VERSION < 801

+      #error This game requires DUMB v0.8.1 or higher. Please upgrade.

+      #endif

+

+      #if DUMB_VERSION < 10002

+      #error This game requires DUMB v1.0.2 or higher. Please upgrade.

+      #endif

+

+

+#define DUMB_VERSION_STR

+

+   String constant representing this version of DUMB. If this were Version

+   1.0, DUMB_VERSION_STR would be "1.0". DUMB_REVISION_VERSION will only

+   appear on the end if it is nonzero; then DUMB_VERSION_STR might be

+   "1.0.1".

+

+

+#define DUMB_NAME

+

+   A string identifying DUMB and its version. If this were Version 1.0,

+   DUMB_NAME might be "DUMB v1.0". This constant is suitable for use in your

+   Credits screen if you wish to acknowledge the use of DUMB there.

+

+

+#define DUMB_YEAR

+#define DUMB_MONTH

+#define DUMB_DAY

+

+   Numeric constants representing the year, month and day of this release of

+   DUMB. All four digits are included in the year. Please note that

+   DUMB_MONTH and DUMB_DAY were inadvertently swapped in the v0.8 release.

+

+

+#define DUMB_YEAR_STR4

+#define DUMB_YEAR_STR2

+#define DUMB_MONTH_STR2

+#define DUMB_MONTH_STR1

+#define DUMB_DAY_STR2

+#define DUMB_DAY_STR1

+

+   String constants representing the year, month and day of this release of

+   DUMB. DUMB_MONTH_STR2 and DUMB_DAY_STR2 include a leading zero if the

+   month or day respectively are less than ten; the STR1 variations do not.

+   DUMB_YEAR_STR2 contains only the two rightmost digits of the year, while

+   DUMB_YEAR_STR4 contains all four. I recommend using DUMB_YEAR_STR4,

+   especially so soon after the turn of the century (indeed the millennium).

+   However, it is a matter of personal preference which you use.

+

+   Please note that the month and day were inadvertently swapped in the v0.8

+   release.

+

+

+#define DUMB_DATE

+

+   A numeric constant that appears in the form yyyymmdd when displayed in

+   decimal. This is most useful for comparing release dates; it has little

+   other practical use.

+

+   WARNING: The month and day were inadvertently swapped in the v0.8 release.

+            Please do not compare this constant against any date in 2002. In

+            any case, DUMB_VERSION is probably more useful for this purpose.

+

+

+#define DUMB_DATE_STR

+

+   The date as a string. The format is "d.m.yyyy", with dots used as

+   separators, the day written first, four digits for the year, and no

+   leading zeros on the day or month. This is my preferred format. If you

+   don't like it, you can construct your own format using the other

+   constants. For example, "mm/dd/yy" could be constructed as follows:

+

+      DUMB_MONTH_STR2 "/" DUMB_DAY_STR2 "/" DUMB_YEAR_STR2

+

+   Please note that the month and day were inadvertently swapped in the v0.8

+   release.

+

+

+*************************

+*** Basic Sample Type ***

+*************************

+

+

+typedef int sample_t;

+

+   DUMB works internally with 32-bit integer samples, with a 'normal range'

+   from -0x800000 to 0x7FFFFF (as of DUMB v0.9.2; previously they ranged from

+   -0x8000 to 0x7FFF). Any samples that exceed this range will eventually be

+   clipped, and could cause integer overflow in extreme cases.

+

+

+***********************************

+*** Library Clean-up Management ***

+***********************************

+

+

+int dumb_atexit(void (*proc)(void));

+

+   Registers a function to be called at the end of your program. You can

+   register multiple functions to be called, and the one you register last

+   will be called first. If you try to register the same function twice, the

+   second attempt will have no effect.

+

+   See fnptr.txt for help with function pointers.

+

+   You must call dumb_exit() before exiting your program for this to work

+   properly. The library itself registers functions with dumb_atexit(), so it

+   is important to call dumb_exit() even if you do not use dumb_atexit()

+   yourself.

+

+   This function will return zero on success. It will return zero when

+   trying to install the same function twice. If it fails through lack of

+   memory, it will return nonzero. Generally you can ignore the return code;

+   in the worst case some memory will not be freed at the end. If it is

+   crucial that your function be called (e.g. to shut down some hardware or

+   save critical data), then you should call your function manually at the

+   end of the program instead of registering it here - or use the stdlib

+   function atexit(), guaranteed under ANSI C to succeed for at least 32

+   functions.

+

+

+void dumb_exit(void);

+

+   You should call this before exiting your program if you have used any part

+   of DUMB in the program. Some parts of DUMB will allocate memory, and this

+   function will free it all up.

+

+   More specifically, this function will call any functions that have been

+   registered with dumb_atexit(). If a part of DUMB needs shutting down, the

+   shutdown procedure will have been registered in this way.

+

+   dumb_exit() will, of course, also call any functions you registered with

+   dumb_atexit() yourself.

+

+   After a call to dumb_exit(), the list of functions is erased. If you are

+   not ready to exit your program, you can start using DUMB anew as if your

+   program had just started. (Note that not everything will be reset in

+   practice - dumb_resampling_quality will retain whatever you set it to, for

+   example, though you should not assume it will.)

+

+   If you only need to call dumb_exit() once at the end of the program, you

+   can use the following to register dumb_exit() with stdlib.h atexit():

+

+      #include <stdlib.h>

+

+      atexit(&dumb_exit);

+

+   Then dumb_exit() will be called for you when your program exits. This is

+   the recommended method, since it will ensure clean-up even if your program

+   aborts. You should only call dumb_exit() manually if you need to shut DUMB

+   down prematurely, or if atexit() is unavailable for one reason or another.

+

+

+*****************************

+*** Sequential File Input ***

+*****************************

+

+

+   DUMB provides a strictly sequential file input system which uses the

+   DUMBFILE struct. "Strictly sequential" means you cannot seek backwards.

+   However, the system will keep track of how many bytes you have read,

+   enabling you to seek forwards. DUMBFILEs provide a convenient error

+   detection system, so you do not have to check the return value from every

+   function call in the way you do with the ANSI C functions.

+

+   Note that DUMBFILEs cannot be used for output, nor can they be used

+   portably for text files.

+

+   If an error occurs when reading data from a DUMBFILE, the DUMBFILE will

+   become inoperative. All subsequent activities on the DUMBFILE will return

+   error codes without attempting to read from the file. The position in the

+   file will also be forgotten. You can find out if this has happened at any

+   stage with the dumbfile_error() function. You are still required to close

+   the DUMBFILE, and the return value from dumbfile_close() will tell you if

+   an error has occurred.

+

+   This system allows you to input large chunks of your file, neither

+   checking every return value nor wasting time accessing a file that has

+   already experienced an error. However, before you allocate an amount of

+   memory or read in a quantity of data depending on previous input from the

+   file, you should always check that such input was valid. In particular you

+   should avoid passing zero or negative numbers to malloc(), and avoid

+   passing negative numbers to dumbfile_skip() and dumbfile_getnc().

+

+   DUMBFILEs can be hooked. In other words, you can specify your own

+   functions to do the work of reading from a file. While DUMB contains two

+   modules for this purpose, it does not set them up for you automatically.

+   In most cases you must register one of these modules yourself, or provide

+   your own module. See register_dumbfile_system(), dumb_register_stdfiles()

+   and dumb_register_packfiles().

+

+

+void register_dumbfile_system(DUMBFILE_SYSTEM *dfs);

+

+   Use this function to register a set of functions for use by the DUMBFILEs

+   (a DUMBFILE system). The DUMBFILE_SYSTEM struct contains the following

+   fields:

+

+      void *(*open)(const char *filename);

+      int (*skip)(void *f, long n);

+      int (*getc)(void *f);

+      long (*getnc)(char *ptr, long n, void *f);

+      void (*close)(void *f);

+

+   See fnptr.txt for help with function pointers such as these.

+

+   Your 'open' function should open the file specified and return a pointer

+   to a struct representing the open file. This pointer will be passed to

+   your other functions as 'f'. Your 'close' function should close the file

+   and free all memory pointed to by 'f'. Note that the 'close' operation

+   should never be able to fail; if you are calling a function with a return

+   value, you can generally ignore it.

+

+   Your 'getc' function should read one byte from the file and return its

+   value in the range 0 to 255. If an error occurs, you should return -1. Do

+   not worry about remembering that an error has occurred; DUMB will do that

+   for you.

+

+   'skip' is for skipping parts of the file, and should skip n bytes,

+   returning 0 on success or any other number on failure. 'getnc' should read

+   n bytes from the file, store them at 'ptr', and return the number of bytes

+   read (n on success, fewer on failure). However, these two functions are

+   optional, and you should only provide them if the operations can be done

+   more efficiently than with repeated calls to your 'getc' function. If this

+   is not the case, specify NULL for 'skip', 'getnc' or both, and DUMB will

+   use your 'getc' function to do the work.

+

+   Once you have written all your functions, you need to create a

+   DUMBFILE_SYSTEM struct to hold them, and pass its pointer to

+   register_dumbfile_system().

+

+   The DUMBFILE_SYSTEM struct must be permanent. In other words, it must be

+   either global or static, and you should not modify it later. DUMB will not

+   make its own copy.

+

+   You will most likely create your own struct to represent the open file,

+   but do not be tempted to specify that struct in the function prototypes

+   and pacify the compiler warnings by casting your function pointers. There

+   exist computer systems where a (void *) pointer and a (MY_STRUCT *)

+   pointer are represented differently in memory, and a cast of such a

+   pointer causes a tangible conversion to take place. If you cast the

+   function pointers, the computer cannot know when such a conversion is

+   necessary. Instead, use the following structure:

+

+      int myskip(void *f, long n)

+      {

+         FILE *file = f;

+         /* Do some stuff with 'file' */

+         return something;

+      }

+

+   If you need examples, have a look at the two existing DUMBFILE systems in

+   dumb/src/core/stdfile.c and dumb/src/allegro/packfile.c.

+

+

+DUMBFILE *dumbfile_open(const char *filename);

+

+   Open the specified file for input. You must pass the DUMBFILE pointer

+   whenever you wish to operate on this file. When you have finished with the

+   file, you must pass it to dumbfile_close().

+

+   Before you use this function, make sure you have registered a DUMBFILE

+   system. See register_dumbfile_system(), dumb_register_stdfiles() and

+   dumb_register_packfiles().

+

+   You must check the return value from this function. If it is NULL, the

+   file could not be opened, and you must not pass the DUMBFILE to any other

+   function. The debugging library will abort if you get this wrong; the

+   optimised library will act weird.

+

+

+DUMBFILE *dumbfile_open_ex(void *file, DUMBFILE_SYSTEM *dfs);

+

+   This function is provided for more specialised use. You should create a

+   DUMBFILE_SYSTEM specially for the purpose. Its 'open' field is irrelevant;

+   for neatness, set it to NULL, unless you are using this DUMBFILE_SYSTEM

+   with register_dumbfile_system() as well.

+

+   When you have called this function, the DUMBFILE struct it returned can be

+   used as normal. The specified DUMBFILE_SYSTEM will be used for all input,

+   with 'file' passed to your 'skip', 'getc' and 'getnc' functions as 'f'.

+   This can be used, for example, to read from an already open file.

+

+   Note that the position will always be initialised to 0 for this DUMBFILE.

+   This means for example that offsets in the file do not need adjusting when

+   embedding data in a larger file.

+

+   There are two ways to use this function. If you want 'file' to persist

+   after using a DUMBFILE returned by this function, you should make sure the

+   'close' field in the DUMBFILE is set to NULL. When the DUMBFILE is closed,

+   'file' will be left alone, and you can and should deal with it yourself

+   when the DUMBFILE has been closed.

+

+   Alternatively, you can provide a 'close' function to get rid of 'file' for

+   you when the DUMBFILE is closed. If you do this, you should not otherwise

+   use 'file' after a call to this function.

+

+   If dumbfile_open_ex() has to return NULL, owing to lack of memory, then

+   your 'close' function will be called if provided. In other words, if you

+   have provided a 'close' function, then you no longer need to worry about

+   'file' whether this function succeeds or not.

+

+   See dumb/src/helpers/stdfile.c and dumb/src/allegro/packfile.c for

+   examples of how to use this function. Neither provides a 'close' function,

+   so I hope my explanation here will suffice. If not, please feel free to

+   contact me so I can make the explanation clearer and help you do what you

+   want to do. Contact details are at the end of this file.

+

+

+long dumbfile_pos(DUMBFILE *f);

+

+   Returns the number of bytes read from the DUMBFILE (or skipped) since it

+   was opened, or -1 if an error has occurred while reading.

+

+

+int dumbfile_skip(DUMBFILE *f, long n);

+

+   Skips n bytes of the specified DUMBFILE. Returns zero on success.

+

+

+int dumbfile_getc(DUMBFILE *f);

+

+   Reads one byte from the DUMBFILE and returns it in unsigned format (from 0

+   to 255). If an error occurs, or occurred before, this function returns -1.

+

+

+int dumbfile_igetw(DUMBFILE *f);

+

+   Reads two bytes from the DUMBFILE and combines them into a word ranging

+   from 0 to 65535. The first byte read is the least significant byte, as

+   with Intel processors. This function returns -1 on error.

+

+

+int dumbfile_mgetw(DUMBFILE *f);

+

+   Reads two bytes from the DUMBFILE and combines them into a word ranging

+   from 0 to 65535. The first byte read is the most significant byte, as

+   with the Apple Macintosh. This function returns -1 on error.

+

+

+long dumbfile_igetl(DUMBFILE *f);

+

+   Reads four bytes from the DUMBFILE and combines them into a long integer

+   ranging from -2147483648 to 2147483647. The first byte read is the least

+   significant byte, as with Intel processors. This function returns -1 on

+   error, but -1 is also a valid return value. After a call to this function,

+   you can use dumbfile_error() to find out if an error occurred.

+

+

+long dumbfile_mgetl(DUMBFILE *f);

+

+   Reads four bytes from the DUMBFILE and combines them into a long integer

+   ranging from -2147483648 to 2147483647. The first byte read is the most

+   significant byte, as with the Apple Macintosh. This function returns -1 on

+   error, but -1 is also a valid return value. After a call to this function,

+   you can use dumbfile_error() to find out if an error occurred.

+

+

+unsigned long dumbfile_cgetul(DUMBFILE *f);

+

+   Reads an unsigned (nonnegative) integer from the DUMBFILE. The integer is

+   stored in a condensed format where smaller numbers use less space:

+

+           0 to 127         1 byte

+         128 to 16383       2 bytes

+       16384 to 2097151     3 bytes

+     2097152 to 268435455   4 bytes

+   268435456 to 4294967295  5 bytes

+

+   This format is the same as that used for the times between notes in MIDI

+   files.

+

+   If an error occurs, this function returns (unsigned long)(-1), but that

+   may be a valid return value. After a call to this function, you can use

+   dumbfile_error() to find out if an error occurred.

+

+

+signed long dumbfile_cgetsl(DUMBFILE *f);

+

+   Reads a signed integer from the DUMBFILE. The integer is stored in a

+   condensed format where numbers closer to zero use less space:

+

+           -64 to 63          1 byte

+         -8192 to 8191        2 bytes

+      -1048576 to 1048575     3 bytes

+    -134217728 to 134217727   4 bytes

+   -2147483648 to 2147483647  5 bytes

+

+   If an error occurs, this function returns -1, but -1 is also a valid

+   return value. After a call to this function, you can use dumbfile_error()

+   to find out if an error occurred.

+

+

+long dumbfile_getnc(char *ptr, long n, DUMBFILE *f);

+

+   Reads n bytes from the DUMBFILE and stores them at 'ptr'. Note that the

+   pointer is to a series of chars. You may also use this function to read in

+   a series of signed chars or unsigned chars (which are both officially

+   distinct types from char), but do not use this to read ints, structs or

+   any other data type from the file. Integers must be read one at a time

+   using dumbfile_igetl(), dumbfile_cgetul(), etc. To load a struct in, you

+   must read each field separately using an appropriate function for each

+   one. For complicated data types, you can simplify this process by writing

+   a function for each struct.

+

+   dumbfile_getnc() returns the number of bytes successfully read, which will

+   be less than n if an error occurs, and may be as low as zero. If

+   dumbfile_getnc() returns -1, that means an error occurred on this DUMBFILE

+   earlier, before this function was called.

+

+

+int dumbfile_error(DUMBFILE *f);

+

+   This function returns -1 if an error has occurred with the specified

+   DUMBFILE, or 0 if all is well.

+

+

+int dumbfile_close(DUMBFILE *f);

+

+   This function closes the DUMBFILE, after which the pointer will be

+   invalid. dumbfile_close() returns the value that dumbfile_error() would

+   have returned, which is -1 if an error occurred while reading or 0

+   otherwise. Regardless of the return value, the file will always be closed

+   properly.

+

+

+*******************************

+*** stdio File Input Module ***

+*******************************

+

+

+void dumb_register_stdfiles(void);

+

+   This function registers the stdio file input module for use by DUMBFILEs.

+   FILE structs and their corresponding functions, as defined by the ANSI C

+   header stdio.h, will be used internally for all DUMBFILE input (unless

+   opened with dumbfile_open_ex()).

+

+   This must be called before dumbfile_open() is used, or else an alternative

+   system must be registered (see register_dumbfile_system() and

+   dumb_register_packfiles()).

+

+

+DUMBFILE *dumbfile_open_stdfile(FILE *p);

+

+   If you have a stdio FILE struct representing an open file, you can call

+   this if you wish to read from it using a DUMBFILE. This is useful when you

+   need to pass a DUMBFILE struct to a library function, to read an embedded

+   music file for example. When you close the DUMBFILE, you can continue

+   using the FILE struct to read what follows the embedded data.

+

+

+********************************

+*** Memory File Input Module ***

+********************************

+

+

+DUMBFILE *dumbfile_open_memory(const char *data, long size);

+

+   This function is useful if you have an image of a music file in memory.

+   You might have such an image if you use dat2s to encode a datafile

+   directly into the executable. Pass a pointer to the start of the memory,

+   and the size of the image to make sure DUMB doesn't overrun the buffer.

+   The resulting DUMBFILE will feed the contents of the image to you.

+

+   Note that the pointer is of type 'char *'. Files are series of chars, and

+   interpreting them directly as anything else isn't portable.

+

+

+**********************

+*** DUH Management ***

+**********************

+

+

+void unload_duh(DUH *duh);

+

+   Removes a DUH from memory. You must call this for all DUHs you load,

+   making sure they're not playing at the time.

+

+

+long duh_get_length(DUH *duh);

+

+   Returns the length of a DUH; 65536 represents one second. This value is

+   calculated when the DUH is created, and this function simply lifts it from

+   the struct. It may not truly correspond to the time for which the DUH will

+   generate sound. For module files, it will represent the point at which the

+   module first loops (or, in the case of some XM and MOD files, freezes).

+   Any add-ons to DUMB will provide their own code for calculating this.

+

+   The algorithm for calculating the length of a module file can be fooled,

+   but only by very deliberate methods. In the early days, when modules could

+   only be played by their editors and had to be exported to .wav or similar

+   in order to be used elsewhere, musicians would sometimes make the player

+   think it was looping when it wasn't in order to prevent their music from

+   being exported properly. If the length of a module seems a lot less than

+   it should be, the module is probably protected in this way.

+

+   Getting around this protection reliably would be extremely difficult, but

+   after considering it for a while I decided it would be better not to. The

+   musician has a right to protect his or her music in this way, and I have

+   no interest in actively breaking that protection.

+

+   (On the other hand, some musicians were just showing off!)

+

+

+***********************************

+*** IT, XM, S3M and MOD Support ***

+***********************************

+

+

+int dumb_it_max_to_mix;

+

+   Specifies the maximum number of samples DUMB will mix at any one time. The

+   default number is 64. Regardless of this value, all samples will continue

+   to be processed up to an internal maximum of 256 (roughly speaking; in

+   fact it will process one sample for each channel plus up to 192 extra

+   samples that are continuing to play owing to Impulse Tracker's New Note

+   Actions), and samples that have been cut will sound again as soon as the

+   congestion clears. Samples are given priority according to their final

+   volume after all factors affecting the volume of a sample have been

+   considered.

+

+   If you play two or more modules at once, this value represents the

+   maximum number of samples for each one. You will have to reduce it further

+   if your computer cannot keep up.

+

+   Despite the name, this variable controls XM, S3M and MOD files as well as

+   IT files.

+

+

+DUMB_IT_SIGDATA *duh_get_it_sigdata(DUH *duh);

+

+   This function attempts to retrieve the DUMB_IT_SIGDATA struct from a DUH.

+   This struct will exist for any IT, XM, S3M or MOD file, and you can use it

+   to obtain or override module-specific information. If 'duh' is NULL, or if

+   the DUH you pass contains something other than a music module, then this

+   function will return NULL (which can safely be passed to any other

+   function).

+

+

+DUMB_IT_SIGRENDERER *duh_get_it_sigrenderer(DUH_SIGRENDERER *sigrenderer);

+

+   This function attempts to retrieve the DUMB_IT_SIGRENDERER struct from a

+   DUH_SIGRENDERER. This struct will exist for any currently playing IT, XM,

+   S3M or MOD file, and you can use it to obtain or override information

+   specific to module playback. If 'sigrenderer' is NULL, or if the

+   DUH_SIGRENDERER you pass is rendering something other than a music module,

+   then this function will return NULL (which can safely be passed to any

+   other function).

+

+

+DUH_SIGRENDERER *dumb_it_start_at_order

+                                  (DUH *duh, int n_channels, int startorder);

+

+   This function, given a DUH containing an IT, XM, S3M or MOD file, will

+   start playing it at the specified order. If the DUH does not contain a

+   module, this function will fail and return NULL.

+

+   Note that starting at an arbitrary order may result in missing notes or

+   other playback oddities. It should be used primarily for modules that

+   contain multiple songs that start on different orders. If you wish just to

+   start some music in the middle, consider using duh_start_sigrenderer() or

+   al_start_duh() with the pos parameter set appropriately.

+

+

+void dumb_it_set_loop_callback(DUMB_IT_SIGRENDERER *sigrenderer,

+                               int (*callback)(void *data), void *data);

+

+   Installs a callback which will be called every time the module loops. You

+   can pass any data pointer you like, and it will be passed to the callback

+   for you. DUMB considers a file to loop when it reaches the end, or when a

+   'Jump to order' effect (Bxx in both IT/S3M and XM/MOD) jumps to the same

+   order or a preceding order. This can result in the loop callback being

+   called when the module isn't really looping, but this only happens if the

+   module has a very deliberate design. See duh_get_length() for further

+   musings on this subject.

+

+   If your callback returns nonzero, the music will stop abruptly. Samples

+   will be cut, and the main program will be notified that the

+   DUH_SIGRENDERER has ended.

+

+   Alternatively, if you pass the DUMB_IT_SIGRENDERER for 'data', or

+   otherwise arrange for it to be available to the callback, then you can

+   call:

+

+      dumb_it_sr_set_speed(sigrenderer, 0);

+

+   from inside the callback, and this will cause the music to freeze but

+   samples will be able to continue playing. The xm_speed_zero callback will

+   NOT be called in this case (see below for information on this callback).

+   Note also that setting the speed in this way will work equally for IT and

+   S3M files, even though a 'speed zero' effect can only exist in XM and MOD

+   files. Beware when using this method; samples might not fade at all!

+

+   A helper callback, dumb_it_callback_terminate(), is provided; installing

+   this will cause the music to terminate when it tries to loop for the first

+   time.

+

+   Pass NULL to remove the callback function; the module will then loop as

+   normal.

+

+

+void dumb_it_set_xm_speed_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer,

+                                    int (*callback)(void *data), void *data);

+

+   Installs a callback which is in many ways similar to the loop callback

+   (see dumb_it_set_loop_callback()). This callback will be called whenever

+   an F00 effect is encountered in a MOD or XM file, setting the speed to

+   zero. If the callback returns nonzero, the music will terminate. If not,

+   any currently playing samples will continue to play. You can pass any data

+   pointer you like to this function, and it will be passed to your callback

+   for you.

+

+   The helper callback, dumb_it_callback_terminate(), will also work here;

+   installing it will cause the music to terminate as soon as an F00 effect

+   is encountered.

+

+   Pass NULL to remove the callback function.

+

+

+void dumb_it_set_midi_callback(DUMB_IT_SIGRENDERER *sigrenderer,

+                int (*callback)(void *data, int channel, unsigned char byte),

+                void *data);

+

+   Installs a callback function which will be called whenever MIDI data are

+   generated by an IT file. (No other module formats are capable of

+   generating MIDI data, so your callback will never be called.)

+

+   Zxx macros will generate MIDI data. These are most often used to set the

+   parameters for IT's low-pass resonant filters, and DUMB will handle these

+   messages by itself by default. See Impulse Tracker's documentation for

+   the MIDI messages that control filters. However, Zxx macros can be used

+   to send any kind of MIDI data.

+

+   If you wish to interpret MIDI messages yourself, you can use this

+   callback. Note that the only MIDI messages generated by DUMB at present

+   are from Zxx macros; there are no messages for note start, stop, or

+   anything else.

+

+   If you return 1 from this callback, DUMB will subsequently ignore the byte

+   of MIDI data. You can use this to prevent Zxx macros from controlling the

+   filters, useful if they were intended to do something else. Note that this

+   is NOT an effective way to disable filters, since instruments can have

+   filter envelopes and initial filter parameters. DUMB provides no means to

+   disable filters, as any IT file that uses them will sound wrong without

+   them. If you want lower processor consumption, use a different piece of

+   music.

+

+   A helper callback, dumb_it_callback_midi_block(), is provided for blocking

+   all MIDI messages and making Zxx macros do nothing.

+

+   Pass NULL to remove the callback.

+

+

+int dumb_it_callback_terminate(void *data);

+

+   This is a helper callback that can be installed with both

+   dumb_it_set_loop_callback() and dumb_it_set_xm_speed_zero_callback(). In

+   each case it will cause the music to terminate abruptly.

+

+

+int dumb_it_callback_midi_block(void *data, int channel, unsigned char byte);

+

+   This helper callback, for use with dumb_it_set_midi_callback(), will

+   absorb all MIDI messages, returning 1 to prevent DUMB from interpreting

+   them itself.

+

+

+DUH *dumb_load_it(const char *filename);

+

+   Loads the specified Impulse Tracker file, encapsulating it in a DUH

+   struct. Once the file is loaded, it can be treated exactly the same as any

+   other DUH in memory. If this fails it will return NULL, but you can safely

+   pass this NULL value to DUMB's other functions, so you do not need to

+   check the return value explicitly.

+

+

+DUH *dumb_read_it(DUMBFILE *f);

+

+   Reads an Impulse Tracker file from an already open DUMBFILE. This leaves

+   the DUMBFILE open, but the DUMBFILE may not be positioned at the end of

+   the IT data. If you are embedding an IT in another file, you are advised

+   to store the size of the IT file and make up for it at the end using

+   dumbfile_pos().

+

+   Otherwise, this function is identical to dumb_load_it().

+

+   WARNING: The behaviour of this function is undefined if you pass a

+            DUMBFILE from which data have already been read; it is likely not

+            to work. This oversight will be fixed in future releases.

+

+

+DUH *dumb_load_xm(const char *filename);

+

+   Loads the specified Fast Tracker II file, encapsulating it in a DUH

+   struct. Once the file is loaded, it can be treated exactly the same as any

+   other DUH in memory. If this fails it will return NULL, but you can safely

+   pass this NULL value to DUMB's other functions, so you do not need to

+   check the return value explicitly.

+

+

+DUH *dumb_read_xm(DUMBFILE *f);

+

+   Reads a Fast Tracker II file from an already open DUMBFILE. This leaves

+   the DUMBFILE open, but the DUMBFILE may not be positioned at the end of

+   the XM data. If you are embedding an XM in another file, you are advised

+   to store the size of the XM file and make up for it at the end using

+   dumbfile_pos().

+

+   Otherwise, this function is identical to dumb_load_xm().

+

+   WARNING: The behaviour of this function is undefined if you pass a

+            DUMBFILE from which data have already been read; it is likely not

+            to work. This oversight will be fixed in future releases.

+

+

+DUH *dumb_load_s3m(const char *filename);

+

+   Loads the specified Scream Tracker 3 file, encapsulating it in a DUH

+   struct. Once the file is loaded, it can be treated exactly the same as any

+   other DUH in memory. If this fails it will return NULL, but you can safely

+   pass this NULL value to DUMB's other functions, so you do not need to

+   check the return value explicitly.

+

+

+DUH *dumb_read_s3m(DUMBFILE *f);

+

+   Reads a Scream Tracker 3 file from an already open DUMBFILE. This leaves

+   the DUMBFILE open, but the DUMBFILE may not be positioned at the end of

+   the S3M data. If you are embedding an S3M in another file, you are advised

+   to store the size of the S3M file and make up for it at the end using

+   dumbfile_pos().

+

+   Otherwise, this function is identical to dumb_load_s3m().

+

+   WARNING: The behaviour of this function is undefined if you pass a

+            DUMBFILE from which data have already been read; it is likely not

+            to work. This oversight will be fixed in future releases.

+

+

+DUH *dumb_load_mod(const char *filename);

+

+   Loads the specified Amiga module file, encapsulating it in a DUH struct.

+   Once the file is loaded, it can be treated exactly the same as any other

+   DUH in memory. If this fails it will return NULL, but you can safely pass

+   this NULL value to DUMB's other functions, so you do not need to check the

+   return value explicitly.

+

+

+DUH *dumb_read_mod(DUMBFILE *f);

+

+   Reads an Amiga module file from an already open DUMBFILE. This leaves the

+   DUMBFILE open, but the DUMBFILE may not be positioned at the end of the

+   MOD data. If you are embedding a MOD in another file, you are advised to

+   store the size of the MOD file and make up for it at the end using

+   dumbfile_pos().

+

+   Otherwise, this function is identical to dumb_load_mod().

+

+   WARNING: The behaviour of this function is undefined if you pass a

+            DUMBFILE from which data have already been read; it is likely not

+            to work. This oversight will be fixed in future releases.

+

+

+int dumb_it_sd_get_n_orders(DUMB_IT_SIGDATA *sd);

+

+   This function returns the number of orders in the module.

+

+

+int dumb_it_sd_get_initial_global_volume(DUMB_IT_SIGDATA *sd);

+void dumb_it_sd_set_initial_global_volume(DUMB_IT_SIGDATA *sd, int gv);

+

+   These functions obtain and set the initial global volume for the module.

+   This value ranges from 0 to 128 inclusive. The module can set the global

+   volume itself during playback, so your change may not last throughout the

+   playback.

+

+

+int dumb_it_sd_get_mixing_volume(DUMB_IT_SIGDATA *sd);

+void dumb_it_sd_set_mixing_volume(DUMB_IT_SIGDATA *sd, int mv);

+

+   These functions obtain and set the mixing volume for the module. This

+   value ranges from 0 to 128 inclusive, and does not change during playback.

+   IT files have the mixing volume stored in them; for other formats it is

+   set to 48 on loading.

+

+

+int dumb_it_sd_get_initial_speed(DUMB_IT_SIGDATA *sd);

+void dumb_it_sd_set_initial_speed(DUMB_IT_SIGDATA *sd, int speed);

+int dumb_it_sd_get_initial_tempo(DUMB_IT_SIGDATA *sd);

+void dumb_it_sd_set_initial_tempo(DUMB_IT_SIGDATA *sd, int tempo);

+

+   These functions obtain and set the initial speed and tempo for the module.

+   During module playback, everything happens on a tick. If a beat is 24

+   ticks, then the tempo is measured in beats per second. The speed is then

+   the number of ticks per row. With a speed of 6, a beat is then four rows.

+

+   Modules can set these values during playback, so your change may not last

+   throughout the playback. MOD files have to set the speed and tempo on the

+   first row if they want anything other than the default 6/125, so your

+   change may not be noticed at all!

+

+

+int dumb_it_sd_get_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel);

+void dumb_it_sd_set_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel,

+                                                                 int volume);

+

+   These functions obtain and set the initial volume for the specified

+   channel. The channel parameter is 0-based (contrary to the display in most

+   trackers so be careful), and can range from 0 to DUMB_IT_N_CHANNELS - 1,

+   i.e. from 0 to 63.

+

+   Modules can set their channel volumes during playback, so your changes may

+   not last throughout the playback.

+

+

+int dumb_it_sr_get_current_order(DUMB_IT_SIGRENDERER *sr);

+int dumb_it_sr_get_current_row(DUMB_IT_SIGRENDERER *sr);

+

+   These functions return the current order and row of playback. Both are

+   0-based. If the DUMB_IT_SIGRENDERER is invalid, or has been terminated

+   by a callback (see dumb_it_set_loop_callback() and

+   dumb_it_set_xm_speed_zero_callback()), these functions will both return

+   -1.

+

+

+int dumb_it_sr_get_global_volume(DUMB_IT_SIGRENDERER *sr);

+void dumb_it_sr_set_global_volume(DUMB_IT_SIGRENDERER *sr, int gv);

+

+   These functions obtain and set the current global volume for the module.

+   This value ranges from 0 to 128 inclusive. The module can set the global

+   volume itself during playback, so your change may not last.

+

+

+int dumb_it_sr_get_tempo(DUMB_IT_SIGRENDERER *sr);

+void dumb_it_sr_set_tempo(DUMB_IT_SIGRENDERER *sr, int tempo);

+int dumb_it_sr_get_speed(DUMB_IT_SIGRENDERER *sr);

+void dumb_it_sr_set_speed(DUMB_IT_SIGRENDERER *sr, int speed);

+

+   These functions obtain and set the current speed and tempo of the module.

+   See the dumb_it_sd_*() equivalents of these functions for details on what

+   the speed and tempo mean.

+

+   Modules can set these values during playback, so your change may not last.

+

+

+int dumb_it_sr_get_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel);

+void dumb_it_sr_set_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel,

+                                                                 int volume);

+

+   These functions obtain and set the current volume for the specified

+   channel. The channel parameter is 0-based (contrary to the display in most

+   trackers so be careful), and can range from 0 to DUMB_IT_N_CHANNELS - 1,

+   i.e. from 0 to 63.

+

+   Modules can set their channel volumes during playback, so your changes may

+   not last.

+

+

+void dumb_it_sr_get_channel_state(DUMB_IT_SIGRENDERER *sr, int channel,

+                                               DUMB_IT_CHANNEL_STATE *state);

+

+   Returns the current playback state of the given channel. If you pass a

+   channel in the range 0 to DUMB_IT_N_CHANNELS-1 (0 to 63), you will get the

+   state of the most recently played note on that physical channel, if it is

+   still playing. For MOD, S3M and XM files, that's all there is to it.

+

+   IT files can have more than one note playing on a single channel, courtesy

+   of New Note Actions. This function also lets you query all the notes that

+   have been forced into the background and are still playing. For this, set

+   'channel' to a value from DUMB_IT_N_CHANNELS to DUMB_IT_TOTAL_CHANNELS-1.

+   DUMB_IT_TOTAL_CHANNELS is defined as follows:

+

+      #define DUMB_IT_TOTAL_CHANNELS \

+                                (DUMB_IT_N_CHANNELS + DUMB_IT_N_NNA_CHANNELS)

+

+   Querying these background channels for MOD, S3M and XM files will not do

+   any harm; the function will report that these channels are inactive. For

+   all files, be sure not to query any channel numbers greater than or equal

+   to DUMB_IT_TOTAL_CHANNELS.

+

+   You must provide a pointer to a preallocated DUMB_IT_CHANNEL_STATE struct.

+   The easiest way to do this is as follows:

+

+      DUMB_IT_CHANNEL_STATE state;

+      dumb_it_sr_get_channel_state(sr, channel, &state);

+

+   or:

+

+      DUMB_IT_CHANNEL_STATE state[IT_TOTAL_CHANNELS];

+      dumb_it_sr_get_channel_state(sr, channel, &state[channel]);

+

+   This struct contains the following fields:

+

+          int channel;

+          int sample;

+          int freq;

+          float volume;

+          unsigned char pan;

+          signed char subpan;

+          unsigned char filter_cutoff;

+          unsigned char filter_subcutoff;

+          unsigned char filter_resonance;

+

+   The first field to check is 'sample'; if this is 0, then the channel is

+   inactive and the other fields are undefined. Otherwise, it is the index of

+   the currently playing sample, and is 1-based.

+

+   The channel number is returned, 0-based. This will be the same as the

+   channel number you passed, unless you are querying a background channel in

+   which case it will represent the channel the note originated on.

+

+   The freq field is the current playback frequency, taking into account all

+   phenomena such as slides, vibrato and arpeggio.

+

+   The volume field ranges from 0.0f to 1.0f. In practical terms, it will

+   rarely reach 1.0f; if it does, the module is probably clipping a lot. This

+   takes mixing volume into account, along with all the other volume

+   phenomena in the IT file. The only one it doesn't take into account is the

+   one you pass to duh_render() or duh_sigrenderer_get_samples(), or the one

+   you passed to al_start_duh() (these are in fact the same thing).

+

+   The pan field ranges from 0 to 64 for a normally panned sample, but will

+   be 100 if the sample is playing using IT's surround mode where the right-

+   hand channel is inverted. If you want a more accurate pan reading, use one

+   of the following to get one:

+

+      int scaled_pan = ((int)state.pan << 8) + state.subpan;

+      float float_pan = state.pan + state.subpan / 256.0f;

+

+   The first will give a scaled value ranging (strictly) from 0 to 64*256.

+   The second will give a floating-point value whose scale corresponds to

+   that of the pan field. These results will only be valid if surround mode

+   is off, so you should check that pan <= 64 before using the above

+   expressions. At the time of writing, pitch-pan separation and panning

+   envelopes take advantage of the extra accuracy offered by subpan.

+

+   Note that subpan is signed. This means applications that only look at the

+   pan field will get an unbiased reading.

+

+   The filter cut-off and resonance both range from 0 to 127. If the cut-off

+   is 127 and the resonance is 0, then no filters are applied. These

+   parameters only ever change from the default values for IT files.

+

+   While IT allows you to set 127 different filter cut-off levels in the

+   patterns and as a default value per instrument, it also allows you to

+   create a filter envelope, which will result in an actual cut-off somewhere

+   between 0 and the first-mentioned value. By the time this has been

+   calculated, the actual cut-off may lie in between two levels on the

+   original scale. If this is the case, filter_subcutoff will be nonzero and

+   you can combine it with filter_cutoff. Typically you will want to use one

+   of the following:

+

+      int scaled_cutoff = ((int)state.filter_cutoff << 8) +

+                                state.filter_subcutoff;

+

+      float float_cutoff = state.filter_cutoff +

+                           state.filter_subcutoff / 256.0f;

+

+   The first will give you a scaled value whose maximum is 127*256. The

+   second will give you a floating-point value whose scale corresponds to the

+   scale used by filter_cutoff. These match the expressions given further up

+   for pan and subpan, but in this case, filter_subcutoff is unsigned.

+

+   Note that filter_subcutoff will always be zero if filter_cutoff is 127, so

+   you need not check it if you simply wish to determine whether filters are

+   being applied.

+

+

+*******************************

+*** DUH Rendering Functions ***

+*******************************

+

+

+   Use these functions to generate samples from a DUH. First you call

+   duh_start_sigrenderer() with the DUH, the number of channels you want and

+   the position at which you want to start. Then you use duh_render() or

+   duh_sigrenderer_get_samples() to generate the samples. You can call these

+   functions as many times as you like, and they will generate as many or as

+   few samples as you require. When you have finished, call

+   duh_end_sigrenderer().

+

+

+DUH_SIGRENDERER *duh_start_sigrenderer

+                               (DUH *duh, int sig, int n_channels, long pos);

+

+   Starts a DUH_SIGRENDERER off. This is the struct you can use to get

+   samples from a DUH. This function does not generate any samples; you must

+   pass the struct to duh_render() or duh_sigrenderer_get_samples() for that.

+   When you have finished with it, you must pass it to duh_end_sigrenderer().

+   You can use as many DUH_SIGRENDERER structs as you like at the same time.

+

+   Set sig to 0 for now. Currently, n_channels can only be 1 or 2, for

+   monaural and stereo sound respectively. The debugging library will cause

+   your program to abort if you pass anything else. Future versions will be

+   enhanced to support more channels as soon as someone needs them.

+

+   When specifying the position, 0 represents the start of the DUH, and 65536

+   represents one second. Unlike most other music systems, DUMB will always

+   make sure every note is there right from the start (assuming you aren't

+   using any broken add-ons). In other words, you can start a DUH at a point

+   halfway through a long note, and you will still hear the long note.

+

+

+void duh_sigrenderer_set_analyser_callback(DUH_SIGRENDERER *sigrenderer,

+                     DUH_SIGRENDERER_ANALYSER_CALLBACK callback, void *data);

+

+   Installs a callback function which will be called every time the given

+   sigrenderer is used to generate some samples. This can be used to create

+   an oscilloscope or spectrum analyser. DUH_SIGRENDERER_ANALYSER_CALLBACK is

+   defined as follows:

+

+      typedef void (*DUH_SIGRENDERER_ANALYSER_CALLBACK)(void *data,

+                const sample_t *const *samples, int n_channels, long length);

+

+   If the above confuses you, see fnptr.txt. As for the 'samples' parameter,

+   the first 'const' says that the samples are read-only; the second says

+   that each channel's sample pointer is also read-only. If you don't

+   understand this, don't worry about it.

+

+   Beware: your callback function may occasionally be called with

+   samples == NULL. This means the main program has decided to skip through

+   the music without generating any data (see duh_sigrenderer_get_samples()).

+   You should handle this case elegantly, typically by returning immediately,

+   but you may wish to make a note of the fact that the music is being

+   skipped, for whatever reason.

+

+   Beware again: if the main program ever calls duh_sigrenderer_get_samples()

+   on a buffer that isn't all silence, this callback function will be passed

+   the existing buffer after mixing, and thus it will include the original

+   data. This will not be an issue if you stick to duh_render(), which always

+   starts with a buffer filled with silence.

+

+   The samples array is two-dimensional. Refer to it as follows:

+

+      samples[channel_number][sample_position]

+

+   where 0 <= channel_number < n_channels,

+     and 0 <= sample_position < length.

+

+   In addition you can pass any 'data' pointer you like to

+   duh_sigrenderer_set_analyser_callback(), and this pointer will be relayed

+   to your callback function each time.

+

+   To remove the callback function, pass NULL to

+   duh_sigrenderer_set_analyser_callback().

+

+

+int duh_sigrenderer_get_n_channels(DUH_SIGRENDERER *sigrenderer);

+

+   Tells you how many channels a DUH_SIGRENDERER is set up to generate, or 0

+   if it is invalid (perhaps owing to lack of memory). This will be 1 for

+   monaural sound or 2 for stereo, in this release.

+

+

+long duh_sigrenderer_get_position(DUH_SIGRENDERER *sigrenderer);

+

+   Tells you what position a DUH_SIGRENDERER is up to, or -1 if it is invalid

+   (perhaps owing to lack of memory). As usual, 65536 is one second.

+

+

+long duh_sigrenderer_get_samples(DUH_SIGRENDERER *sigrenderer,

+                                 float volume, float delta,

+                                 long size, sample_t **samples);

+

+   Generates some samples in DUMB's internal 32-bit format (see sample_t; see

+   also duh_render()). The samples buffer is a two-dimensional array, and can

+   be allocated with create_sample_buffer(); see

+   duh_sigrenderer_set_analyser_callback() for details.

+   duh_sigrenderer_get_samples() mixes sample data with what's already in the

+   buffer, so you have to call dumb_silence() first.

+

+   The volume is a float. 1.0f is the pseudo-maximum. If you pass 1.0f, any

+   properly designed DUH will play nice and loud, but will not clip. You can

+   pass a greater volume if you like, but be prepared for the possibility of

+   distortion due to integer overflow. Of course you can pass smaller values

+   to play the DUH more quietly, and this will also resolve clipping issues

+   in badly designed DUHs.

+

+   Use delta to control the speed of the output signal. If you pass 1.0f, the

+   resultant signal will be suitable for a 65536-Hz sampling rate (which

+   isn't a commonly used rate). The most common sampling rates are 11025 Hz,

+   22050 Hz, 44100 Hz and 48000 Hz. You can work out the required delta value

+   as follows:

+

+      delta = 65536.0f / sampling_rate;

+

+   If you then increase this value, the DUH will speed up and increase in

+   pitch. If you decrease it, the DUH will slow down and decrease in pitch.

+

+   This function will attempt to render 'size' samples. In most cases it will

+   succeed. However, if the end of the DUH is reached, it may render fewer.

+   The number of samples rendered will be returned. Therefore, if the return

+   value is less than the value of 'size' passed, you know the DUH has

+   finished. It is safe to continue calling duh_sigrenderer_get_samples() if

+   you wish, and it will continually return 0.

+

+   If the DUH_SIGRENDERER is a null pointer, this function will generate

+   precisely 0 samples. If you pass NULL for 'samples', the function will

+   behave exactly the same as if you provided a sample buffer, except the

+   samples won't be stored anywhere and the function will execute very

+   quickly. This can be used to skip ahead in the audio.

+

+

+long duh_render(DUH_SIGRENDERER *sigrenderer,

+                int bits, int unsign,

+                float volume, float delta,

+                long size, void *sptr);

+

+   Generates some samples and converts them to an 8-bit or 16-bit format (see

+   also duh_sigrenderer_get_samples()). Pass the DUH_SIGRENDERER as returned

+   by duh_start_sigrenderer(). Pass the number of bits, which should be 8 or

+   16. If unsign is nonzero, the samples will be unsigned (centred on 0x80 or

+   0x8000 for 8 bits and 16 bits respectively). If unsign is zero, the

+   samples will be signed.

+

+   Allegro's audio streams always take unsigned samples. 8-bit .wav files

+   always take unsigned samples. 16-bit .wav files always take signed

+   samples.

+

+   The volume and delta parameters work the same as for

+   duh_sigrenderer_get_samples().

+

+   This function will attempt to render 'size' samples. In most cases it will

+   succeed. However, if the end of the DUH is reached, it may render fewer.

+   The number of samples rendered will be returned. Therefore, if the return

+   value is less than the value of 'size' passed, you know the DUH has

+   finished. It is safe to continue calling duh_render() if you wish, and it

+   will continually return 0. However, if you wish to do this, you will

+   probably have to fill the rest of the buffer with silence, which is 0 for

+   signed, 0x80 for 8-bit unsigned or 0x8000 for 16-bit unsigned.

+

+   The samples will be placed at sptr. Use an array of chars for 8 bits or an

+   array of shorts for 16 bits. Stereo samples will be interleaved, left

+   first. Your array should contain at least (size * n_channels) elements of

+   the appropriate bit resolution.

+

+   From an aesthetic standpoint if nothing else, it is wise to use the C

+   qualifiers 'signed' or 'unsigned' depending on whether the samples are

+   signed or unsigned. This is also convenient if you wish to process the

+   samples further yourself.

+

+   If the DUH_SIGRENDERER is a null pointer, this function will generate

+   precisely 0 samples. Unlike with duh_sigrenderer_get_samples(), you must

+   specify a sample buffer.

+

+

+void duh_end_sigrenderer(DUH_SIGRENDERER *dr);

+

+   Terminates a DUH_SIGRENDERER. Be sure to call this when you've finished

+   with one. You can safely pass a null pointer.

+

+

+********************************

+*** Allegro Packfile Support ***

+********************************

+

+

+void dumb_register_packfiles(void);

+

+   This function registers the Allegro PACKFILE input module for use by

+   DUMBFILEs. PACKFILE structs and their corresponding functions, as defined

+   by Allegro's header file allegro.h, will be used internally for all

+   DUMBFILE input (unless opened with dumbfile_open_ex()).

+

+   This must be called before dumbfile_open() is used, or else an alternative

+   system must be registered (see register_dumbfile_system() and

+   dumb_register_stdfiles()). Note that you don't have to call this function

+   in order to load datafiles that contain music.

+

+

+DUMBFILE *dumbfile_open_packfile(PACKFILE *p);

+

+   If you have an Allegro PACKFILE struct representing an open file, you can

+   call this if you wish to read from it using a DUMBFILE. This is useful

+   when you need to pass a DUMBFILE struct to a library function, to read an

+   embedded music file for example. When you close the DUMBFILE, you can

+   continue using the PACKFILE struct to read what follows the embedded data.

+

+

+DUMBFILE *dumbfile_from_packfile(PACKFILE *p);

+

+   This function is the same as dumbfile_open_packfile(), except it will

+   check if p is NULL, and arrange for pack_fclose() to be called on the

+   PACKFILE when you close the DUMBFILE. It can be seen as a function for

+   converting a PACKFILE to a DUMBFILE, but it will only work for a PACKFILE

+   you obtained with pack_fopen(), not pack_fopen_chunk(). If this function

+   fails, which may happen if memory is short, then the PACKFILE will be

+   closed immediately, so you need not worry about potential memory leaks or

+   files being left open when this happens.

+

+   The following is typical usage, and will open the compressed file foo.bin:

+

+      DUMBFILE *f = dumbfile_from_packfile(pack_fopen("foo.bin",

+                                                      F_READ_PACKED));

+

+   This differs from calling dumb_register_packfiles() and dumbfile_open() in

+   that the latter will only read uncompressed files (and is thus a method

+   suitable for reading music modules).

+

+

+***********************************************

+*** Allegro Datafile Registration Functions ***

+***********************************************

+

+

+void dumb_register_dat_it(long type);

+

+   If you wish to embed an IT file in an Allegro datafile, it is recommended

+   that you use "IT  " for the type. The grabber will have a box for the type

+   when you insert a new object. The grabber will treat the IT file as binary

+   data, which means the datafile will contain an exact copy of the IT file

+   on disk.

+

+   You must then call dumb_register_dat_it(DUMB_DAT_IT) in your program

+   before you load the datafile. Once you've done this, you'll be able to

+   access the DUH using the usual datafile[n].dat notation. You do not need

+   to call unload_duh() on this DUH; unload_datafile() will do that for you.

+

+   If you are using a different type for whatever reason, you can use

+   Allegro's DAT_ID() macro for encoding it and passing it to this function.

+   For example:

+

+      dumb_register_dat_it(DAT_ID('B','L','A','H'));

+

+   Assuming you used the recommended type, the following example iterates

+   through all the ITs in disan.dat:

+

+      DATAFILE *dat;

+      int n;

+

+      dumb_register_dat_it();

+      dat = load_datafile("disan.dat");

+

+      for (n = 0; dat[n].type != DAT_END; n++) {

+         if (dat[n].type == DUMB_DAT_IT) {

+            DUH *duh = dat[n].dat;

+            /* Insert code here to play 'duh' or whatever you want to do. */

+         }

+      }

+

+      unload_datafile(dat);

+

+

+void dumb_register_dat_xm(long type);

+

+   Inserting an XM file in an Allegro datafile is the same as inserting an IT

+   file, except that the recommended type is "XM  ", the registration

+   function is dumb_register_dat_xm(), and the macro DUMB_DAT_XM is provided

+   for the type. The intuitive process of substituting XM for IT in the above

+   method will work.

+

+

+void dumb_register_dat_s3m(long type);

+

+   Inserting an S3M file in an Allegro datafile is the same as inserting an

+   IT file, except that the recommended type is "S3M ", the registration

+   function is dumb_register_dat_s3m(), and the macro DUMB_DAT_S3M is

+   provided for the type. The intuitive process of substituting S3M for IT in

+   the above method will work.

+

+

+void dumb_register_dat_mod(long type);

+

+   Inserting a MOD file in an Allegro datafile is the same as inserting an IT

+   file, except that the recommended type is "MOD ", the registration

+   function is dumb_register_dat_mod(), and the macro DUMB_DAT_MOD is

+   provided for the type. The intuitive process of substituting MOD for IT in

+   the above method will work.

+

+

+****************************************

+*** Sample Buffer Allocation Helpers ***

+****************************************

+

+

+   Many parts of DUMB require sample buffers allocated in a special way. A

+   pointer to one looks like this:

+

+      sample_t **samples;

+

+   and it can be indexed as follows:

+

+      samples[channel_number][sample_position]

+

+   where 0 <= channel_number < n_channels

+     and 0 <= sample_position < length.

+

+   The following helpers will allocate and deallocate such buffers for you.

+   They will not initialise them, and DUMB always writes into these buffers

+   by adding to what's already there, so you will generally have to call

+   dumb_silence() too.

+

+

+sample_t **create_sample_buffer(int n_channels, long length);

+

+   This will allocate a sample buffer to hold the specified number of samples

+   for the specified number of channels. Don't forget to check the return

+   value!

+

+   You will generally have to initialise the buffer by calling

+   dumb_silence(); the channels will be stored consecutively in memory, so

+   the following technique is officially supported:

+

+      dumb_silence(samples[0], n_channels * length);

+

+   See dumb_silence() for general information on what this function does.

+

+

+void destroy_sample_buffer(sample_t **samples);

+

+   This function does the obvious: it frees up a sample buffer when you've

+   finished with it. It is safe to pass a null pointer to this function.

+

+

+************************

+*** Silencing Helper ***

+************************

+

+

+void dumb_silence(sample_t *samples, long length);

+

+   This function simply stores 'length' samples' worth of silence in the

+   array. It is typically used straight after allocating a sample buffer with

+   create_sample_buffer().

+

+

+**************************

+*** Resampling Helpers ***

+**************************

+

+

+   Please forgive the odd section name; it has to do with DUMB's internal

+   structure and the fact that the resampling algorithm is there not just for

+   use in rendering module files but for use anywhere that a waveform needs

+   resampling. Unfortunately DUMB's resampling algorithm is not ready to be

+   documented and used yet. However, one thing can be documented, and that's

+   the global variable controlling the resampling quality.

+

+   (Ironically, even this variable has changed! See deprec.txt for

+   information on what it used to do.)

+

+

+int dumb_resampling_quality;

+

+   Allows you to control the quality of all resampling that takes place. This

+   may be set to any DUMB_RQ_* constant (except DUMB_RQ_N_LEVELS). Higher

+   values will sound better, but lower values will use up less processor

+   time. You may compare any two DUMB_RQ_* constants or values using the

+   integer inequalities <, <=, > and >=; higher numbers represent higher-

+   quality algorithms.

+

+   #define DUMB_RQ_ALIASING

+

+      |     --___         'Aliasing' has very noticeable and usually unwanted

+      |__---     __       overtones. It will occasionally produce acceptable

+      |            ___--  results for noisy (impure) samples (or for cheap

+                          speakers!), but usually you will want to pay for

+      the extra processor time, which isn't much, and go for linear

+      interpolation.

+

+   #define DUMB_RQ_LINEAR

+

+      |  __          Linear interpolation is a pretty good algorithm in most

+      | /  \  /\     cases. When resampling down a few octaves, however, you

+      |/    \/  \__  may begin to notice unwanted high frequencies. You can

+                     reduce these by switching to cubic interpolation, but it

+      will cost you some processor time.

+

+   #define DUMB_RQ_CUBIC

+

+      Cubic interpolation looks like a smooth curve to the eye, and will

+      produce good results in most cases. At present this is the highest

+      quality offered by DUMB, and also the default. While this may seem

+      extravagant, GCC 3.x and an AthlonXP handle it quite well - and the

+      general trend is for processors to get better!

+

+   #define DUMB_RQ_N_LEVELS

+

+      This represents the number of resampling quality levels DUMB provides.

+      Values of dumb_resampling_quality from 0 to DUMB_RQ_N_LEVELS - 1 are

+      valid. You can use this constant if you wish to offer the resampling

+      quality as an option for the user.

+

+

+*************************************

+*** Allegro DUH Playing Functions ***

+*************************************

+

+

+   The functions in this section allow you to play back a DUH through

+   Allegro's sound system. You must call Allegro's install_sound() function

+   before you use them.

+

+

+AL_DUH_PLAYER *al_start_duh(DUH *duh, int n_channels, long pos,

+                            float volume, long bufsize, int freq);

+

+   Starts playing the specified DUH.

+

+   An AL_DUH_PLAYER represents one instance of the DUH playing. If you wish,

+   you can have two or more AL_DUH_PLAYERs going at the same time, for the

+   same DUH or for different ones. Each uses one of Allegro's audio streams

+   and hence one voice. The voice will be given priority 255 initially, so a

+   build-up of sound effects will not cause your music streams to cut off (as

+   long as you don't give all your sound effects priority 255!). You can

+   change the priority of a stream with al_duh_set_priority(). See Allegro's

+   documentation for more information on how voice priorities work.

+

+   At present, n_channels can either be 1 or 2 for monaural or stereo

+   respectively. If you use the debugging library, your program will abort if

+   other values are passed; otherwise weird things will happen.

+

+   The DUH will start playing from position 'pos'. 0 represents the start of

+   the DUH, and 65536 represents one second. Unlike other music systems, DUMB

+   will always make sure every note is there right from the start. In other

+   words, you can start a DUH at a point halfway through a long note, and you

+   will still hear the long note.

+

+   The volume is a float. 1.0f is the pseudo-maximum. If you pass 1.0f, any

+   properly designed DUH file will play nice and loud, but will not clip. You

+   can pass a greater volume if you like, but be prepared for clipping to

+   occur. Of course you can pass smaller values to play the DUH more quietly,

+   and this will also resolve clipping issues in badly designed DUH files.

+

+   You will need to pass the AL_DUH_PLAYER to other functions when you need

+   to stop or pause the DUH, change its volume, or otherwise modify the way

+   it is playing. You will also need to pass it to al_poll_duh() at regular

+   intervals; if the sound is choppy, try calling al_poll_duh() more often.

+

+   'bufsize' is the number of samples that will be rendered at once. 1024 is

+   a suitable value for most purposes. The greater this is, the less often

+   you will have to call al_poll_duh() - but when al_poll_duh() decides to

+   fill the buffer, it will take longer doing so. If your game exhibits

+   regular brief freezes, try reducing the buffer size. If the sound is

+   choppy, however, you may have to increase it.

+

+   'freq' specifies the sampling frequency at which the DUH should be

+   rendered. At present there is no (official and portable) way of knowing

+   the frequency at which Allegro is mixing - but if you do know that

+   frequency, passing it here will give the highest quality sound. If you

+   reduce it, the DUH will sound less crisp but use less processor time.

+

+   When you have finished, you must pass the AL_DUH_PLAYER to al_stop_duh()

+   to free up memory. Do not destroy the DUH beforehand.

+

+   There is no real need to check the return value from this function. The

+   other functions can be called safely with null pointers, so if there is a

+   problem, your music will simply not play.

+

+

+void al_stop_duh(AL_DUH_PLAYER *dp);

+

+   This will stop an AL_DUH_PLAYER. You must call this when you have finished

+   with it, before destroying the DUH. The pointer will no longer be valid on

+   return from this function.

+

+

+void al_pause_duh(AL_DUH_PLAYER *dp);

+

+   This will pause an AL_DUH_PLAYER. Use al_resume_duh() when you want it to

+   continue. You can safely call al_poll_duh() while the music is paused, and

+   it will do nothing.

+

+

+void al_resume_duh(AL_DUH_PLAYER *dp);

+

+   Causes a paused AL_DUH_PLAYER to resume playing (see al_pause_duh()).

+

+

+void al_duh_set_priority(AL_DUH_PLAYER *dp, int priority);

+

+   This will set the priority of the audio stream underlying an

+   AL_DUH_PLAYER. The priority is an integer ranging from 0 to 255. When

+   too many samples play at the same time, those with lower priorities will

+   be cut. 128 is the usual default with Allegro, but DUMB overrides the

+   default for all AL_DUH_PLAYER structs: they will be set up initially with

+   priority 255, so your music won't be cut (unless you play too many other

+   streams or samples with priority 255). See Allegro's documentation for

+   more information on priorities.

+

+

+void al_duh_set_volume(AL_DUH_PLAYER *dp, float volume);

+

+   This will set the volume of an AL_DUH_PLAYER. See al_start_duh() for

+   details on the volume parameter.

+

+

+int al_poll_duh(AL_DUH_PLAYER *dp);

+

+   An AL_DUH_PLAYER is not interrupt-driven. That means it will not play by

+   itself. You must keep it alive from your main program. Call this function

+   at regular intervals. If the sound crackles, try calling it more often.

+   (There is nothing you can do if Windows decides to play with the hard

+   disk; that will make your sound crackle no matter what you do.)

+

+   Normally this function will return zero. However, if it returns nonzero,

+   that means the AL_DUH_PLAYER will not generate any more sound. Indeed the

+   underlying audio stream and DUH_SIGRENDERER have been destroyed. When this

+   happens, you can call al_stop_duh() whenever you wish - but you do not

+   have to. Note that this function will wait two buffers' worth of samples

+   before taking this action, allowing Allegro to mix the trailing sound

+   before the audio stream is destroyed. This is an attempt to make sure your

+   music does not get cut off prematurely, and it should work when using

+   Allegro's mixer (the only option on DOS, the default on Linux as far as I

+   know, but not the default on Windows). That said, if you immediately call

+   Allegro's remove_sound() or exit your program, the music may get cut off.

+   If you are using another mixer and experience problems, let me know (but I

+   don't guarantee to be able to come up with an elegant solution, i.e. it

+   might not get fixed).

+

+   In case you were wondering, it is not safe on all platforms to call

+   al_poll_duh() from an interrupt context (that means an Allegro timer

+   handler). Not only is no part of DUMB locked in memory, but many parts of

+   DUMB allocate and free their memory on a call-by-call basis! Remember that

+   any disk access that occurs in interrupt context is likely to crash the

+   machine; this is explained more fully in howto.txt. This limitation only

+   applies to DOS at present, and is due to the fact that the DOS file access

+   functions are not re-entrant.

+

+   Multitasking systems are generally safe. If you are sure you don't want to

+   target DOS, you can call al_poll_duh() from inside a timer handler, but I

+   recommend including a construction like the following!

+

+      #ifdef ALLEGRO_DOS

+      #error calling al_poll_duh() from a timer handler will not work in DOS!

+      #endif

+

+   Furthermore, if you call al_poll_duh() from inside a timer handler, you

+   must use a semaphore or other threading mechanism to make sure it is not

+   executing when you call al_stop_duh(). If you don't know what a semaphore

+   is, for Heaven's sake follow my advice and call al_poll_duh() from your

+   main loop!

+

+

+long al_duh_get_position(AL_DUH_PLAYER *dp);

+

+   Tells you what position an AL_DUH_PLAYER is up to, or -1 if it is invalid

+   (perhaps owing to lack of memory). As usual, 65536 is one second. Note

+   that this is a whole number, whereas a fractional part is stored

+   internally; the sample will not be continuous if you terminate the

+   AL_DUH_PLAYER and then reinitiate it with the same position. Furthermore,

+   note that Allegro will not have mixed in all the sound up to this point;

+   if you wait for this to reach a certain position and then terminate the

+   AL_DUH_PLAYER, the sound will cut off too early. Please contact me if you

+   need to get around this.

+

+

+AL_DUH_PLAYER *al_duh_encapsulate_sigrenderer

+        (DUH_SIGRENDERER *sigrenderer, float volume, long bufsize, int freq);

+

+   If you have a DUH_SIGRENDERER, and would like to start playing music from

+   it through an Allegro audio stream, use this function. Beware that it may

+   return NULL, in which case you will have to call duh_end_sigrenderer()

+   yourself instead of relying on the encapsulating AL_DUH_PLAYER to do it

+   for you.

+

+

+DUH_SIGRENDERER *al_duh_get_sigrenderer(AL_DUH_PLAYER *dp);

+

+   This returns the DUH_SIGRENDERER contained in an AL_DUH_PLAYER, useful for

+   controlling playback, installing callbacks, etc.

+

+

+DUH_SIGRENDERER *al_duh_decompose_to_sigrenderer(AL_DUH_PLAYER *dp);

+

+   This destroys an AL_DUH_PLAYER, but preserves the DUH_SIGRENDERER it

+   contains, and returns it to you. You can then continue rendering samples

+   from the DUH_SIGRENDERER and do whatever you like with them.

+

+

+*********************

+*** Thread Safety ***

+*********************

+

+

+The following points should pretty much sum up the essence of DUMB's thread

+safety. If I haven't covered the one thing you'd like to do, please don't

+hesitate to ask about it.

+

+DOs:

+

+- You may load and use multiple DUHs in separate threads.

+

+- You may change dumb_resampling_quality and dumb_it_max_to_mix while another

+  thread is generating samples.

+

+DON'Ts:

+

+- You may not generate samples from the same DUH in multiple threads, even if

+  you are using separate DUH_RENDERERs (separate AL_DUH_PLAYERS).

+

+

+******************

+*** Conclusion ***

+******************

+

+

+"DUMB is the bestest music player in the world because ..."

+

+Complete this sentence in fifteen words or fewer and receive a free copy of

+DUMB! (Your Internet Service Provider may issue charges for your connection,

+required for download of the Product. Your electricity supplier may issue

+charges for the electricity consumed in writing the Product to a Permanent

+Storage Device. You may have been charged for a Permanent Storage Device on

+which to store the Product.)

+

+

+Ben Davis

+entheh@users.sf.net

+IRC EFnet #dumb

+See readme.txt for details on using IRC.

diff --git a/plugins/dumb/dumb-kode54/docs/dumbfull.txt b/plugins/dumb/dumb-kode54/docs/dumbfull.txt
new file mode 100644
index 00000000..6a8e192c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/docs/dumbfull.txt
@@ -0,0 +1,1717 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * dumb.txt - DUMB library reference.                 / / \  \

+ *                                                   | <  /   \_

+ * See readme.txt for general information on         |  \/ /\   /

+ * DUMB and how to set it up.                         \_  /  > /

+ *                                                      | \ / /

+ * If you are new to DUMB, see howto.txt.               |  ' /

+ *                                                       \__/

+ */

+

+

+***********************************

+*** Include Files and Libraries ***

+***********************************

+

+

+dumb.h

+

+   Include this if you only want the core DUMB library functions. You will

+   be able to load music files and render them into memory buffers at your

+   own pace. The core library is completely portable, and as such does not

+   access hardware; you must relay the sound data to the sound card yourself.

+   A stdio file input module is available, but you must actively register it

+   if you wish to use it (see dumb_register_stdfiles()); if you do not

+   register it, it will not be linked into your executable. You must register

+   it in order to load stand-alone music files.

+

+   Optimised: libdumb.a  (-ldumb)

+   Debugging: libdumbd.a (-ldumbd)

+

+

+aldumb.h

+

+   Include this if you wish to use DUMB with Allegro. This will provide you

+   with functions to play DUHs back through Allegro's audio streams and embed

+   music files in Allegro datafiles. A file input module using Allegro's

+   packfiles is provided; you have a choice between this and the stdio

+   module. You will be able to load datafiles containing music files no

+   matter which file input module you register, or even if you register no

+   file input module. However, you must register a file input module in order

+   to load stand-alone files.

+

+   Optimised: -laldmb -lalleg -ldumb

+   Debugging: -laldmd -lalld -ldumbd

+

+   libaldmb.a or libaldmd.a must be linked in first, so the symbols can be

+   resolved when linking in the other two libraries.

+

+

+***********************************

+*** Library Clean-up Management ***

+***********************************

+

+

+int dumb_atexit(void (*proc)(void));

+

+   Registers a function to be called at the end of your program. You can

+   register multiple functions to be called, and the one you register last

+   will be called first. If you try to register the same function twice, the

+   second attempt will have no effect.

+

+   See fnptr.txt for help with function pointers.

+

+   You must call dumb_exit() before exiting your program for this to work

+   properly. The library itself registers functions with dumb_atexit(), so it

+   is important to call dumb_exit() even if you do not use dumb_atexit()

+   yourself.

+

+   This function will return zero on success. It will return zero when

+   trying to install the same function twice. If it fails through lack of

+   memory, it will return nonzero. Generally you can ignore the return code;

+   in the worst case some memory will not be freed at the end. If it is

+   crucial that your function be called (e.g. to shut down some hardware or

+   save critical data), then you should call your function manually at the

+   end of the program instead of registering it here - or use the stdlib

+   function atexit(), guaranteed under ANSI C to succeed for at least 32

+   functions.

+

+

+void dumb_exit(void);

+

+   You should call this before exiting your program if you have used any part

+   of DUMB in the program. Some parts of DUMB will allocate memory, and this

+   function will free it all up.

+

+   More specifically, this function will call any functions that have been

+   registered with dumb_atexit(). If a part of DUMB needs shutting down, the

+   shutdown procedure will have been registered in this way.

+

+   dumb_exit() will, of course, also call any functions you registered with

+   dumb_atexit() yourself.

+

+   After a call to dumb_exit(), the list of functions is erased. If you are

+   not ready to exit your program, you can start using DUMB anew as if your

+   program had just started. (Note that not everything will be reset in

+   practice - dumb_resampling_quality will retain whatever you set it to, for

+   example, though you should not assume it will.)

+

+   If you only need to call dumb_exit() once at the end of the program, you

+   can use the following to register dumb_exit() with stdlib.h atexit():

+

+      #include <stdlib.h>

+

+      atexit(&dumb_exit);

+

+   Then dumb_exit() will be called for you when your program exits. This is

+   the recommended method, since it will ensure clean-up even if your program

+   aborts. You should only call dumb_exit() manually if you need to shut DUMB

+   down prematurely, or if atexit() is unavailable for one reason or another.

+

+

+*****************************

+*** Sequential File Input ***

+*****************************

+

+

+   DUMB provides a strictly sequential file input system which uses the

+   DUMBFILE struct. "Strictly sequential" means you cannot seek backwards.

+   However, the system will keep track of how many bytes you have read,

+   enabling you to seek forwards. DUMBFILEs provide a convenient error

+   detection system, so you do not have to check the return value from every

+   function call in the way you do with the ANSI C functions.

+

+   Note that DUMBFILEs cannot be used for output, nor can they be used

+   portably for text files.

+

+   If an error occurs when reading data from a DUMBFILE, the DUMBFILE will

+   become inoperative. All subsequent activities on the DUMBFILE will return

+   error codes without attempting to read from the file. The position in the

+   file will also be forgotten. You can find out if this has happened at any

+   stage with the dumbfile_error() function. You are still required to close

+   the DUMBFILE, and the return value from dumbfile_close() will tell you if

+   an error has occurred.

+

+   This system allows you to input large chunks of your file, neither

+   checking every return value nor wasting time accessing a file that has

+   already experienced an error. However, before you allocate an amount of

+   memory or read in a quantity of data depending on previous input from the

+   file, you should always check that such input was valid. In particular you

+   should passing zero or negative numbers to malloc() or dumbfile_getnc().

+

+   DUMBFILEs can be hooked. In other words, you can specify your own

+   functions to do the work of reading from a file. While DUMB contains two

+   modules for this purpose, it does not set them up for you automatically.

+   In most cases you must register one of these modules yourself, or provide

+   your own module. See register_dumbfile_system(), dumb_register_stdfiles()

+   and dumb_register_packfiles().

+

+

+void register_dumbfile_system(DUMBFILE_SYSTEM *dfs);

+

+   Use this function to register a set of functions for use by the DUMBFILEs

+   (a DUMBFILE system). The DUMBFILE_SYSTEM struct contains the following

+   fields:

+

+      void *(*open)(const char *filename);

+      int (*skip)(void *f, long n);

+      int (*getc)(void *f);

+      long (*getnc)(char *ptr, long n, void *f);

+      void (*close)(void *f);

+

+   See fnptr.txt for help with function pointers such as these.

+

+   Your 'open' function should open the file specified and return a pointer

+   to a struct representing the open file. This pointer will be passed to

+   your other functions as 'f'. Your 'close' function should close the file

+   and free all memory pointed to by 'f'. Note that the 'close' operation

+   should never be able to fail; if you are calling a function with a return

+   value, you can generally ignore it.

+

+   Your 'getc' function should read one byte from the file and return its

+   value in the range 0 to 255. If an error occurs, you should return -1. Do

+   not worry about remembering that an error has occurred; DUMB will do that

+   for you.

+

+   'skip' is for skipping parts of the file, and should skip n bytes,

+   returning 0 on success or any other number on failure. 'getnc' should read

+   n bytes from the file, store them at 'ptr', and return the number of bytes

+   read (n on success, fewer on failure). However, these two functions are

+   optional, and you should only provide them if the operations can be done

+   more efficiently than with repeated calls to your 'getc' function. If this

+   is not the case, specify NULL for 'skip', 'getnc' or both, and DUMB will

+   use your 'getc' function to do the work.

+

+   Once you have written all your functions, you need to create a

+   DUMBFILE_SYSTEM struct to hold them, and pass its pointer to

+   register_dumbfile_system().

+

+   The DUMBFILE_SYSTEM struct must be permanent. In other words, it must be

+   either global or static, and you should not modify it later. DUMB will not

+   make its own copy.

+

+   You will most likely create your own struct to represent the open file,

+   but do not be tempted to specify that struct in the function prototypes

+   and pacify the compiler warnings by casting your function pointers. There

+   exist computer systems where a (void *) pointer and a (MY_STRUCT *)

+   pointer are represented differently in memory, and a cast of such a

+   pointer causes a tangible conversion to take place. If you cast the

+   function pointers, the computer cannot know when such a conversion is

+   necessary. Instead, use the following structure:

+

+      int myskip(void *f, long n)

+      {

+         FILE *file = f;

+         /* Do some stuff with 'file' */

+         return something;

+      }

+

+   If you need examples, have a look at the two existing DUMBFILE systems in

+   dumb/src/core/stdfile.c and dumb/src/allegro/packfile.c.

+

+

+DUMBFILE *dumbfile_open(const char *filename);

+

+   Open the specified file for input. You must pass the DUMBFILE pointer

+   whenever you wish to operate on this file. When you have finished with the

+   file, you must pass it to dumbfile_close().

+

+   Before you use this function, make sure you have registered a DUMBFILE

+   system. See register_dumbfile_system(), dumb_register_stdfiles() and

+   dumb_register_packfiles().

+

+

+DUMBFILE *dumbfile_open_ex(void *file, DUMBFILE_SYSTEM *dfs);

+

+   This function is provided for more specialised use. You should create a

+   DUMBFILE_SYSTEM specially for the purpose. Its 'open' field is irrelevant;

+   for neatness, set it to NULL, unless you are using this DUMBFILE_SYSTEM

+   with register_dumbfile_system() as well.

+

+   When you have called this function, the DUMBFILE struct it returned can be

+   used as normal. The specified DUMBFILE_SYSTEM will be used for all input,

+   with 'file' passed to your 'skip', 'getc' and 'getnc' functions as 'f'.

+   This can be used, for example, to read from an already open file.

+

+   Note that the position will always be initialised to 0 for this DUMBFILE.

+   This means for example that offsets in the file do not need adjusting when

+   embedding data in a larger file.

+

+   There are two ways to use this function. If you want 'file' to persist

+   after using a DUMBFILE returned by this function, you should make sure the

+   'close' field in the DUMBFILE is set to NULL. When the DUMBFILE is closed,

+   'file' will be left alone, and you can and should deal with it yourself

+   when the DUMBFILE has been closed.

+

+   Alternatively, you can provide a 'close' function to get rid of 'file' for

+   you when the DUMBFILE is closed. If you do this, you should not otherwise

+   use 'file' after a call to this function.

+

+   If dumbfile_open_ex() has to return NULL, owing to lack of memory, then

+   your 'close' function will be called if provided. In other words, if you

+   have provided a 'close' function, then you no longer need to worry about

+   'file' whether this function succeeds or not.

+

+   See dumb/src/helpers/stdfile.c and dumb/src/allegro/packfile.c for

+   examples of how to use this function. Neither provides a 'close' function,

+   so I hope my explanation here will suffice. If not, please feel free to

+   contact me so I can make the explanation clearer and help you do what you

+   want to do. Contact details are at the end of this file.

+

+

+long dumbfile_pos(DUMBFILE *f);

+

+   Returns the number of bytes read from the DUMBFILE (or skipped) since it

+   was opened, or -1 if an error has occurred while reading.

+

+

+int dumbfile_skip(DUMBFILE *f, long n);

+

+   Skips n bytes of the specified DUMBFILE. Returns zero on success.

+

+

+int dumbfile_getc(DUMBFILE *f);

+

+   Reads one byte from the DUMBFILE and returns it in unsigned format (from 0

+   to 255). If an error occurs, or occurred before, this function returns -1.

+

+

+int dumbfile_igetw(DUMBFILE *f);

+

+   Reads two bytes from the DUMBFILE and combines them into a word ranging

+   from 0 to 65535. The first byte read is the least significant byte, as

+   with Intel processors. This function returns -1 on error.

+

+

+int dumbfile_mgetw(DUMBFILE *f);

+

+   Reads two bytes from the DUMBFILE and combines them into a word ranging

+   from 0 to 65535. The first byte read is the most significant byte, as

+   with the Apple Macintosh. This function returns -1 on error.

+

+

+long dumbfile_igetl(DUMBFILE *f);

+

+   Reads four bytes from the DUMBFILE and combines them into a long integer

+   ranging from -2147483648 to 2147483647. The first byte read is the least

+   significant byte, as with Intel processors. This function returns -1 on

+   error, but -1 is also a valid return value. After a call to this function,

+   you can use dumbfile_error() to find out if an error occurred.

+

+

+long dumbfile_mgetl(DUMBFILE *f);

+

+   Reads four bytes from the DUMBFILE and combines them into a long integer

+   ranging from -2147483648 to 2147483647. The first byte read is the most

+   significant byte, as with the Apple Macintosh. This function returns -1 on

+   error, but -1 is also a valid return value. After a call to this function,

+   you can use dumbfile_error() to find out if an error occurred.

+

+

+unsigned long dumbfile_cgetul(DUMBFILE *f);

+

+   Reads an unsigned (nonnegative) integer from the DUMBFILE. The integer is

+   stored in a condensed format where smaller numbers use less space:

+

+           0 to 127         1 byte

+         128 to 16383       2 bytes

+       16384 to 2097151     3 bytes

+     2097152 to 268435455   4 bytes

+   268435456 to 4294967295  5 bytes

+

+   This format is the same as that used for the times between notes in MIDI

+   files.

+

+   If an error occurs, this function returns (unsigned long)(-1), but that

+   may be a valid return value. After a call to this function, you can use

+   dumbfile_error() to find out if an error occurred.

+

+

+signed long dumbfile_cgetsl(DUMBFILE *f);

+

+   Reads a signed integer from the DUMBFILE. The integer is stored in a

+   condensed format where numbers closer to zero use less space:

+

+           -64 to 63          1 byte

+         -8192 to 8191        2 bytes

+      -1048576 to 1048575     3 bytes

+    -134217728 to 134217727   4 bytes

+   -2147483648 to 2147483647  5 bytes

+

+   If an error occurs, this function returns -1, but -1 is also a valid

+   return value. After a call to this function, you can use dumbfile_error()

+   to find out if an error occurred.

+

+

+long dumbfile_getnc(char *ptr, long n, DUMBFILE *f);

+

+   Reads n bytes from the DUMBFILE and stores them at 'ptr'. Note that the

+   pointer is to a series of chars. You may also use this function to read in

+   a series of signed chars or unsigned chars (which are both officially

+   distinct types from char), but do not use this to read ints, structs or

+   any other data type from the file. Integers must be read one at a time

+   using dumbfile_igetl(), dumbfile_cgetul(), etc. To load a struct in, you

+   must read each field separately using an appropriate function for each

+   one. For complicated datatypes, you can simplify this process by writing a

+   function for each struct.

+

+

+int dumbfile_error(DUMBFILE *f);

+

+   This function returns -1 if an error has occurred with the specified

+   DUMBFILE, or 0 if all is well.

+

+

+int dumbfile_close(DUMBFILE *f);

+

+   This function closes the DUMBFILE, after which the pointer will be

+   invalid. dumbfile_close() returns the value that dumbfile_error() would

+   have returned, which is -1 if an error occurred while reading or 0

+   otherwise. Regardless of the return value, the file will always be closed

+   properly.

+

+

+*******************************

+*** stdio File Input Module ***

+*******************************

+

+

+void dumb_register_stdfiles(void);

+

+   This function registers the stdio file input module for use by DUMBFILEs.

+   FILE structs and their corresponding functions, as defined by the ANSI C

+   header stdio.h, will be used internally for all DUMBFILE input (unless

+   opened with dumbfile_open_ex()).

+

+   This must be called before dumbfile_open() is used, or else an alternative

+   system must be registered (see register_dumbfile_system() and

+   dumb_register_packfiles()).

+

+

+DUMBFILE *dumbfile_open_stdfile(FILE *p);

+

+   If you have a stdio FILE struct representing an open file, you can call

+   this if you wish to read from it using a DUMBFILE. This is useful when you

+   need to pass a DUMBFILE struct to a library function, to read an embedded

+   music file for example. When you close the DUMBFILE, you can continue

+   using the FILE struct to read what follows the embedded data.

+

+

+********************************

+*** Signal Type Registration ***

+********************************

+

+

+

+

+

+

+   NOTE: SINCE THIS IS NOT TO BE THE INTRODUCTION TO DUMB, SHOULD THE

+   FOLLOWING INFORMATION BE MOVED TO ANOTHER FILE?

+

+

+

+

+

+

+   If you are lazy, then don't bother to read this section. Simply follow

+   these steps:

+

+      1. Call all the dumb_register_sigtype_*() functions. You must do this

+         after dumb_init(), but before you try to call load_duh(). If you try

+         to load any DUH files beforehand, the library will fail to load

+         them.

+

+      2. Run your program, and make sure the DUH file was successfully loaded

+         and played.

+

+      3. Comment out the first dumb_register_sigtype_*() function call.

+

+      3.1. If the DUH file is still loaded and played, remove this function

+           call.

+      3.2. If the DUH file was not loaded and played, uncomment and keep this

+           function call.

+

+      4. Repeat Step 3 for the other function calls.

+

+   Alternatively, the musician might have told you which of the functions you

+   need to call.

+

+   If you are the epitome of laziness, stop after Step 1. However, if you do

+   this, your executable may contain unnecessary code.

+

+   If, on the other hand, you are interested in how all this works, then read

+   on.

+

+   A DUH file comprises a number of 'signals'. A signal may be thought of as

+   a 'black box'; commands go in, sound comes out. A signal may in turn call

+   upon other signals to generate sound, and then do something with this

+   sound to generate its own output.

+

+   For example, here are the contents of a simple DUH file:

+      Signal #0 SEQU

+      Signal #1 SAMP

+      Signal #2 SAMP

+      Signal #3 SAMP

+

+   'SEQU' and 'SAMP' are the signal types. 'SAMP' designates a sample, so

+   Signals #1, #2 and #3 are simple recordings. For instance, Signal #1 could

+   be a bass drum, Signal #2 a snare drum and Signal #3 a high hat. When

+   invoked, these signals simply output their respective percussion sounds.

+

+   'SEQU' designates a sequence. Signal #0 will therefore generate its sound

+   by taking the output waveforms from the other signals and mixing them in

+   at appropriate times. For example:

+

+      0.00 Signal #1

+

+      0.50 Signal #2

+

+      1.00 Signal #1

+      1.25           Signal #3

+      1.50 Signal #2 Signal #3

+      1.75           Signal #3

+      2.00 Signal #1

+      2.25           Signal #3

+      2.50 Signal #2 Signal #3

+      2.75           Signal #3

+      3.00 Signal #1

+

+      3.50 Signal #2 Signal #3

+

+   The numbers down the left are times. Those with a good sense of rhythm

+   will be able to see that this represents a rather lame, highly cheesy pop

+   beat. Experienced gurus will also realise how painfully slow the beat is,

+   given that the times are in seconds. But enough of that.

+

+   A DUH is played by taking the output from Signal #0 and sending it through

+   to the sound card via an Allegro audio stream. If you do not know what an

+   audio stream is, suffice it to say that you must call Allegro's

+   install_sound() function, and an audio stream uses one voice (hence one

+   voice per DUH file). If you still don't know what I'm on about, read up on

+   Allegro's digital sound system and then come back here. Alternatively,

+   read porting.txt for details on how to use DUMB without Allegro.

+

+   In reality, DUH files are likely to be much more complicated than the

+   above example. Sequences may call upon other 'sub-sequences' to generate

+   their sound, so the above beat might be used repeatedly by a

+   'super-sequence' to generate a more complex (but still lame) piece of

+   music.

+

+   The DUH player library is split into two main parts - the core and the

+   basic signal types. The core is very simple. It does not know what 'SAMP'

+   or 'SEQU' mean. In fact it is not familiar with any signal type. It only

+   contains generic code for dealing with signals and generating output. By

+   itself, it cannot load or play any DUH file.

+

+   In addition to the core, the player library comprises a few basic signal

+   types, including 'SAMP' and 'SEQU'. In order to use a signal type, you

+   must 'register' this signal type by calling its corresponding

+   dumb_register_sigtype_*() function. These functions are listed below,

+   along with descriptions of the signals.

+

+   If you do not register a signal type, the code for that signal type will

+   not be linked into your executable file. That means DUMB will not become

+   bloated with age; new features will not add to the size of your executable

+   unless you use them. Dynamically linked libraries will still increase in

+   size.

+

+   If you try to load a DUH file that uses a signal type you haven't

+   registered, the library will not crash. It will simply fail to load the

+   DUH file. In fact, an unrecognised or corrupt signal will prevent the

+   library from reading the rest of the file - but remember, DUH files are

+   always (intended to be) generated from other formats, so you will never

+   lose any data this way.

+

+   If you are unsure which signal types a DUH uses, get in contact with the

+   author of the DUH file, or register them all and remove them one by one to

+   find out which are required (as described in the steps for lazy people at

+   the start of this section).

+

+   The great advantage of DUMB over other music systems is that it enables

+   you to create your own signals. Filters, synthesisers and compression

+   algorithms can all be set up this way. Programming and audio experience

+   are useful, but the editor provides a way to create your own signals even

+   if you don't know C. More information is available in the on-line help in

+   the editor.

+

+   If you are interested in the gory details of how a signal works, or if you

+   wish to brave creating your own without the help of the editor, then see

+   the section entitled Signal Design.

+

+

+void dumb_register_sigtype_sample(void);

+

+   Registers the sample signal type ('SAMP'). This signal deals with samples,

+   or recordings, in the DUH file. All samples are monaural; a combining

+   signal can be used to combine two of these into a stereo sample. The DUMB

+   library will cater for more than two channels to a certain extent, but it

+   is currently limited by Allegro's audio streams.

+

+

+void dumb_register_sigtype_combining(void);

+

+   Registers the combining signal type ('COMB'). This signal takes a set of

+   monaural signals and combines them into one signal with multiple channels.

+   Stereo samples can be set up this way.

+

+

+void dumb_register_sigtype_stereopan(void);

+

+   Registers the stereo pan signal type ('SPAN'). This signal takes a

+   monaural sample and sources it at the stereo position you specify,

+   provided the DUH is played in stereo (or, more precisely, provided stereo

+   output is requested of the signal).

+

+

+void dumb_register_sigtype_sequence(void);

+

+   Registers the sequence signal type ('SEQU'). This signal sequences the

+   sound from other signals. It is what turns a random collection of

+   recordings of single notes into a complete piece of music.

+

+

+**********************

+*** DUH Management ***

+**********************

+

+

+DUH *load_duh(const char *filename);

+

+   Loads a .duh file. Before you call this, make sure you have registered all

+   the necessary signal types (see 'Signal Registration'). The DUH is

+   returned to you; you will need to pass it to various functions. When you

+   have finished with it, call unload_duh() to remove it from memory.

+

+   There is no special need to check that this function succeeds. All other

+   functions can safely be called with a null pointer, which means your music

+   will simply not play if it could not be loaded.

+

+

+DUH *read_duh(DUMBFILE *f);

+

+   Reads a DUH from an already open file, and leaves the file open so you can

+   read subsequent data from the file if you wish. Otherwise this function is

+   identical to load_duh().

+

+

+void unload_duh(DUH *duh);

+

+   Removes a DUH from memory. You must call this for all DUHs you load,

+   making sure they're not playing at the time.

+

+

+long duh_get_length(DUH *duh);

+

+   Returns the length of a DUH; 65536 represents one second. This value is

+   simply lifted from the DUH struct, so it may not truly correspond to the

+   time for which the DUH will generate sound. However, if the musician is

+   any good - or if the code that calculated this value is written properly -

+   you can assume it represents the point at which the DUH first loops, or

+   else it allows time for any final flourish to be appreciated. It is used

+   by the Winamp plug-in to decide when to stop.

+

+

+*******************************

+*** Impulse Tracker Support ***

+*******************************

+

+

+int dumb_it_max_to_mix;

+

+   Specifies the maximum number of samples DUMB will mix at any one time.

+   The default number is 64. Regardless of this value, all samples will

+   continue to be processed up to an internal maximum of 128 (slightly

+   simplified), and cut samples will sound again as soon as the congestion

+   clears. Samples are prioritised by final volume, after all factors

+   affecting the volume of a sample have been considered.

+

+   If you play two or more IT files at once, this value represents the

+   maximum number of samples for each one. You will have to reduce it further

+   if your computer cannot keep up.

+

+

+DUH *dumb_load_it(const char *filename);

+

+   Loads the specified Impulse Tracker file, encapsulating it in a DUH

+   struct. No signal types need be registered for this to work. The length

+   will be set to the point at which the music first loops (see

+   duh_get_length()).

+

+   Once the file is loaded, it can be treated exactly the same as any other

+   DUH in memory.

+

+

+DUH *dumb_read_it(DUMBFILE *f);

+

+   Reads an Impulse Tracker file from an already open DUMBFILE. This leaves

+   the DUMBFILE open, but the DUMBFILE may not be positioned at the end of

+   the IT data. If you are embedding an IT in another file, you are advised

+   to store the size of the IT file and make up for it at the end using

+   dumbfile_pos().

+

+   Otherwise, this function is identical to dumb_load_it().

+

+

+*******************************

+*** DUH Rendering Functions ***

+*******************************

+

+

+   Use these functions to generate samples from a DUH. First you call

+   duh_start_renderer() with the DUH, the number of channels you want and the

+   position at which you want to start. Then you use duh_render() to generate

+   the samples. You can call duh_render() as many times as you like, and it

+   will generate as many or as few samples as you require. When you have

+   finished, call duh_end_renderer().

+

+

+DUH_RENDERER *duh_start_renderer(DUH *duh, int n_channels, long pos);

+

+   Starts a DUH_RENDERER off. This is the struct you can use to get samples

+   from a DUH. This function does not generate any samples; you must pass the

+   struct to duh_render() for that. When you have finished with it, you must

+   pass it to duh_end_renderer(). You can use as many DUH_RENDERER structs as

+   you like at the same time.

+

+   Currently, n_channels can only be 1 or 2, for monaural and stereo sound

+   respectively. The debugging library will cause your program to abort if

+   you pass anything else. Future versions will be enhanced to support more

+   channels as soon as someone needs them.

+

+   When specifying the position, 0 represents the start of the DUH, and 65536

+   represents one second. Unlike most other music systems, DUMB will always

+   make sure every note is there right from the start (provided any custom

+   signal types are properly designed). In other words, you can start a DUH

+   at a point halfway through a long note, and you will still hear the long

+   note.

+

+

+long duh_render(

+   DUH_RENDERER *dr,

+   int bits, int unsign,

+   float volume, float delta,

+   long size, void *sptr

+);

+

+   Generates some samples. Pass the DUH_RENDERER as returned by

+   duh_start_renderer(). Pass the number of bits, which should be 8 or 16. If

+   unsign is nonzero, the samples will be unsigned (centred on 0x80 or 0x8000

+   for 8 bits and 16 bits respectively). If unsign is zero, the samples will

+   be signed.

+

+   Allegro's audio streams always take unsigned samples. 8-bit .wav files

+   always take unsigned samples. 16-bit .wav files always take signed

+   samples.

+

+   The volume is a float. 1.0f is the pseudo-maximum. If you pass 1.0f, any

+   properly designed DUH will play nice and loud, but will not clip. You can

+   pass a greater volume if you like, but be prepared for clipping to occur.

+   Of course you can pass smaller values to play the DUH more quietly, and

+   this will also resolve clipping issues in badly designed DUHs.

+

+   Use delta to control the speed of the output signal. If you pass 1.0f, the

+   resultant signal will be suitable for a 65536-Hz sampling rate (which

+   isn't a commonly used rate). The most common sampling rates are 11025 Hz,

+   22050 Hz, 44100 Hz and 48000 Hz. You can work out the required delta value

+   as follows:

+

+      delta = 65536.0f / sampling_rate;

+

+   If you then increase this value, the DUH will speed up and increase in

+   pitch. If you decrease it, the DUH will slow down and decrease in pitch.

+

+   This function will attempt to render 'size' samples. In most cases it will

+   succeed. However, if the end of the DUH is reached, it may render fewer.

+   The number of samples rendered will be returned. Therefore, if the return

+   value is less than the value of 'size' passed, you know the DUH has

+   finished. It is safe to continue calling duh_render() if you wish, and it

+   will continually return 0. However, if you wish to do this, you will

+   probably have to fill the rest of the buffer with silence, which is 0 for

+   signed, 0x80 for 8-bit unsigned or 0x8000 for 16-bit unsigned.

+

+   The samples will be placed at sptr. Use an array of chars for 8 bits or an

+   array of shorts for 16 bits. Stereo samples will be interleaved, left

+   first. Your array should contain at least (size * n_channels) elements of

+   the appropriate bit resolution.

+

+   From an aesthetic standpoint if nothing else, it is wise to use the C

+   qualifiers 'signed' or 'unsigned' depending on whether the samples are

+   signed or unsigned. This is also convenient if you wish to process the

+   samples further yourself.

+

+

+long duh_renderer_get_position(DUH_RENDERER *dr);

+

+   Tells you what position a DUH_RENDERER is up to, or -1 if it is invalid

+   (perhaps owing to lack of memory). As usual, 65536 is one second. Note

+   that this is a whole number, whereas a fractional part is stored

+   internally; the sample will not be continuous if you terminate the

+   DUH_RENDERER and then reinitiate it with the same position.

+

+

+void duh_end_renderer(DUH_RENDERER *dr);

+

+   Terminates a DUH_RENDERER. Be sure to call this when you've finished with

+   one.

+

+

+***********************************

+*** Signal Design Helper Values ***

+***********************************

+

+

+DUMB_SEMITONE_BASE

+

+   When a 'delta' value is required, you can use DUMB_SEMITONE_BASE to

+   control the pitch. Use pow(DUMB_SEMITONE_BASE, n) to transpose up by n

+   semitones. To transpose down, use negative n.

+

+

+DUMB_QUARTERTONE_BASE

+

+   When a 'delta' value is required, you can use DUMB_QUARTERTONE_BASE to

+   control the pitch. Use pow(DUMB_QUARTERTONE_BASE, n) to transpose up by n

+   quartertones. To transpose down, use negative n.

+

+

+DUMB_PITCH_BASE

+

+   When a 'delta' value is required, you can use DUMB_PITCH_BASE to control

+   the pitch accurately. Use pow(DUMB_PITCH_BASE, n) to transpose up by n

+   units, where 256 units represent one semitone. This scale is used for the

+   'pitch' in a sequence (SEQU).

+

+

+************************************

+*** Signal Design Function Types ***

+************************************

+

+

+   In order to design your own signal type, you will have to write six

+   functions to be linked into your program. They are described below.

+

+   See fnptr.txt for help with function pointer types such as these.

+

+

+typedef void *(*DUH_LOAD_SIGNAL)(DUH *duh, DUMBFILE *file);

+

+   Write a function conforming to this type which loads or creates all the

+   data required by your signal. You may use this, for instance, to load a

+   sample. You will be reading directly from the DUH file, so make sure you

+   read exactly the quantity of data stored in the file for this signal. You

+   should allocate memory (multiple blocks if you like), and return a pointer

+   referencing all these data. Your data will be stored, and provided

+   whenever this signal is handled. Be careful about using global data, since

+   your load_signal function will be called more than once for different

+   signals of the same type (e.g. for signals which are both samples but are

+   different samples).

+

+   On failure you should return NULL. Please take the possibility of failed

+   memory allocation seriously, especially when loading large quantities of

+   data. You should make sure all allocated memory is freed before you return

+   with failure. See the standard signal types for examples of how to do this

+   elegantly using your unload_signal function. On failure, you need not

+   worry about reading the right quantity of data from the file.

+

+   Do not close the file under any circumstances.

+

+   Often you will write this function before you have written any code to

+   write a DUH file using this signal. If this is the case, don't worry; you

+   can write this function free-style, and then the function itself will

+   serve as a file format reference when you come to create the file.

+

+   Note that a null return value will always be interpreted as failure. If

+   this type of signal does not need to load any data, you should not provide

+   a load_signal function at all. The absence of this function will convey

+   the intended message to the library.

+

+

+typedef void *(*DUH_START_SAMPLES)(

+   DUH *duh,

+   void *signal,

+   int n_channels,

+   long pos

+);

+

+   Write a function conforming to this type. Every time your signal is

+   required to produce some output, this will be called first. The 'signal'

+   parameter is the same one you returned from your load_signal function. The

+   'n_channels' parameter specifies how many channels you will need to render

+   sound in. In general you should support one or two, although sometimes

+   only one is necessary, depending on how your signal is used. If you can

+   write generic code to support more channels, then do so. Store the number

+   of channels for use later, unless you're only permitting one value.

+

+   If your signal does not support more than two channels, you are

+   responsible for making sure it is never invoked with more than two;

+   likewise if your signal only supports one, then make sure it is never

+   invoked with more than one. In general you only need to make sure the DUH

+   file is never rendered with too many channels (see duh_start_renderer()

+   and al_start_duh()). It may be prudent to use Allegro's ASSERT() macro to

+   catch bugs of this kind.

+

+   The 'pos' parameter specifies where to start, 65536 being one second into

+   the signal. Even if you do not intend to start in the middle of the signal

+   yourself, you should support this as it will be used when a DUH is not

+   played from the beginning.

+

+   This function should make the necessary preparations in order to render a

+   string of samples. All your preparations should be stored in allocated

+   memory, to which you return a pointer; this allows several instances of

+   the same signal to play at the same time. You will not be given the 'duh'

+   and 'signal' parameters again, so you must store them if you need them in

+   the render_samples or free_samples functions.

+

+   Once again, on the rare occasions on which you do not need such data (e.g.

+   a white noise signal), you should not provide a start_samples function. A

+   null return code is interpreted as failure, and your music will be lacking

+   notes (which is better than crashing on undetected memory allocation

+   failure).

+

+

+typedef void (*DUH_SET_PARAMETER)(

+   void *sampinfo,

+   unsigned char id, long value

+);

+

+   Some signals can take parameters. For example, a stereo pan signal allows

+   you to specify the position at which to source the sample, and you might

+   want to choose the cut-off frequency for a low-pass filter. Such

+   parameters are set on an instance-by-instance basis, not globally.

+   Therefore, if you have any parameters, you should place default values for

+   them in the data you initialise in start_samples. Then you should write a

+   function conforming to this type, and have it change the parameters when

+   the correct IDs are passed (see below).

+

+   Each of your parameters should be identified by a single byte, which will

+   be passed in the 'id' parameter. When one of your parameters is correctly

+   identified by id, you should change the parameter's value in the data you

+   returned from your start_samples function. These data are available via

+   the 'sampinfo' parameter. If you do not recognise the ID passed, you may

+   wish to log the situation using Allegro's TRACE() macro (which will

+   compile away to nothing unless you define DEBUGMODE), since it signifies a

+   fault in the DUH file.

+

+   Take some care in deciding what should be a parameter and what should be

+   arranged through the use of separate signals (of the same type). For

+   example, if you are doing a low-pass filter, you will need a source signal

+   on which to apply the filter; this signal's index should be loaded by the

+   load_signal function, so you will create separate filter signals for the

+   separate source signals. However, the cut-off frequency for the filter is

+   more suitably stored in a parameter. Here are some guidelines:

+

+      Continuous values, or discrete quantities, can be stored in parameters.

+      Examples: filter cut-off, echo time, stereo pan position.

+

+      Discrete indices or references should be loaded by load_signal.

+      Examples: references to other signals.

+

+   Another way of looking at it is as follows:

+

+      If a value could be changed halfway through playing the signal, then

+      consider storing it in a parameter.

+

+      If a value needs to be known by the start_samples function and cannot

+      change later, then consider loading it in the load_signal function.

+

+   If your signal has no parameters, do not provide a set_parameters

+   function. Attempts to change parameters for this signal will not cause a

+   crash, but will cause the operation to be logged using Allegro's TRACE()

+   macro if the debugging library is used to play the DUH.

+

+

+typedef long (*DUH_RENDER_SAMPLES)(

+   void *sampinfo,

+   float volume, float delta,

+   long size, sample_t **samples

+);

+

+   Write a function conforming to this type. It should render a series of

+   samples into the array of buffers provided (see below). You are passed

+   'sampinfo' as returned by start_samples. The 'samples' parameter points to

+   an array of buffers, one for each channel. You can get a pointer to the

+   buffer for channel #n with:

+

+      sample_t *buffer = samples[n];

+

+   As you can see, samples are of type sample_t, which is typedeffed as a

+   signed int (32 bits). Your waveform should be centred on 0 and should peak

+   at no more than +/- 32768, or +/- 0x8000, given a volume of 1.0f. If your

+   waveform goes higher, it will be clipped later on (you do not need to test

+   for this yourself). Please do not read any special meaning into the volume

+   parameter; it is simply a factor to be multiplied into each sample. If you

+   wish to adjust the tone, use a parameter (see DUH_SET_PARAMETER).

+

+   In this function, you should render 'size' samples into the buffer for

+   each channel. Return the number of samples actually rendered, which will

+   be fewer than 'size' if you run out of samples (e.g. if you reach the end

+   of a non-looping sample). Never stop short unless the signal ends, and do

+   not overrun under any circumstances. Update the 'sampinfo' data so that

+   the samples generated by the next call to render_samples will continue

+   seamlessly from the samples generated this time.

+

+   The delta parameter governs the speed at which your signal will play back.

+   Higher values of delta should cause the speed and pitch to increase, as

+   with duh_render(). In general, if delta is 1.0f then your waveform should

+   be suitable for playback at a sampling rate of 65536 Hz. If you wish to

+   bend this rule, then be careful - usually it is wiser to adjust your

+   thinking in other parts.

+

+   For example, consider a sample recorded at 44100 Hz, stored in a sample

+   signal. If a delta of 1.0f is passed to this signal's render function, the

+   output will be exactly the same as the original sample - a signal at

+   44100 Hz. So it breaks the rule.

+

+   Ah, but it doesn't. Instead, it is wiser to consider the sample stored in

+   the DUH file as being sampled at 65536 Hz. Once we consider this, it is

+   clear that the output is suitable for playback at 65536 Hz, so we do not

+   break the rule. Now it is a simple matter of adjusting all the pitches in

+   the sequence to compensate for this. See duhtech.txt for details on how to

+   do this when you are writing the DUH file.

+

+   Note that the position that was passed to the start_samples function is

+   65536 for one second into the signal as played with delta 1.0f. So, with a

+   sample signal, this position is interpreted as the index of the sample on

+   which to start. If delta is 2.0, only half a second of the resultant

+   output will have been skipped.

+

+   Once again, please do not read any special meaning into the delta

+   parameter. The effect of doubling delta should be virtually the same as

+   the effect of not doubling delta but resampling the output. If you wish to

+   adjust the tone for different pitches, use a parameter.

+

+   This function is compulsory. Silent signals only increase processor and

+   memory usage, and we are not Microsoft-Intel evangelists.

+

+

+typedef void (*DUH_END_SAMPLES)(void *sampinfo);

+

+   Write a function conforming to this type. It will be called when a signal

+   stops playing. The parameter points to the data you returned from the

+   start_samples function, and here you should simply free the memory up.

+

+   This function should be provided, always if, and only if, start_samples is

+   present. The debugging library will check you get this right.

+

+

+typedef void (*DUH_UNLOAD_SIGNAL)(void *signal);

+

+   Write a function conforming to this type. It will be called when the DUH

+   is removed from memory. It should free all memory allocated by your

+   load_signal function. The parameter is the same pointer that you returned

+   from load_signal.

+

+   If you only ever use this signal type with make_duh(), and not with

+   dumb_register_sigtype(), then the following does not apply.

+

+   If load_signal is present, unload_signal should also be present; if you

+   did not provide a load_signal function, then you should not provide an

+   unload_signal function either. The debugging library will check you get

+   this right.

+

+

+**********************************

+*** Signal Design Registration ***

+**********************************

+

+

+void dumb_register_sigtype(DUH_SIGTYPE_DESC *desc);

+

+   When you have written all the functions that represent your signal, you

+   will need to register them with the library before it will be able to load

+   your DUH file. Use this function. The DUH_SIGTYPE_DESC struct contains the

+   following fields:

+

+      long type;

+      DUH_LOAD_SIGNAL    load_signal;

+      DUH_START_SAMPLES  start_samples;

+      DUH_SET_PARAMETER  set_parameter;

+      DUH_RENDER_SAMPLES render_samples;

+      DUH_END_SAMPLES    end_samples;

+      DUH_UNLOAD_SIGNAL  unload_signal;

+

+   You need to create a DUH_SIGTYPE_DESC struct and pass its pointer to

+   dumb_register_sigtype(). The struct must be in permanent memory. In other

+   words, it must be either global or static, and you should not modify it

+   later. DUMB will not make its own copy.

+

+   'type' should be a four-character string encoded with DUMB_ID(), for

+   example DUMB_ID('M','E','O','W'). By convention it should be upper case,

+   and padded with spaces if you do not use all four characters. However, you

+   do not have to stick to this.

+

+   If you are not providing a function, specify NULL for the corresponding

+   function pointer.

+

+

+**********************************

+*** Signal Rendering Functions ***

+**********************************

+

+

+   When you are designing your own signals, you will often want to retrieve

+   samples from another signal in the DUH. This signal's index ('sig') should

+   be loaded by your load_samples function. You can use the following

+   functions to obtain the samples.

+

+

+DUH_SIGNAL_SAMPINFO *duh_signal_start_samples(

+   DUH *duh, int sig, int n_channels, long pos

+);

+

+   Specifies where you want to start rendering. This function returns a

+   DUH_SIGNAL_SAMPINFO struct, which you need to pass to the other functions.

+   You can use as many DUH_SIGNAL_SAMPINFOs at once as you like.

+

+   Pass the DUH and the index of the signal whose samples you want to obtain

+   ('sig'). Specify how many channels you want, and where you want to start

+   rendering (65536 represents one second).

+

+   There is no special need to check that this function succeeds. The other

+   functions are safe to call with null pointers. However, checking the

+   return value can make your code more efficient.

+

+   Be sure to call duh_signal_end_samples() when you've finished.

+

+

+void duh_signal_set_parameter(

+   DUH_SIGNAL_SAMPINFO *signal_sampinfo,

+   unsigned char id, long value

+);

+

+   Sets a parameter for the signal whose samples are being rendered by

+   signal_sampinfo.

+

+

+

+

+   Calls the set_parameter function for the instance started by

+   duh_signal_start_samples of the signal whose details you passed to that

+   function. Exactly what this does depends on the signal in question.

+

+

+

+

+

+   THIS IS NOT VERY HELPFUL. REFER TO A FILE?

+

+

+

+

+

+

+

+

+long duh_signal_render_samples(

+   DUH_SIGNAL_SAMPINFO *signal_sampinfo,

+   float volume, float delta,

+   long size, sample_t **samples

+);

+

+   Renders 'size' samples of the signal for which signal_sampinfo was set up.

+   See duh_render() and DUH_RENDER_SAMPLES for details on the 'volume' and

+   'delta' parameters. This function will return the number of samples

+   generated, which will be fewer than 'size' if the signal ends.

+

+   Sometimes you can pass the array of sample buffers which was passed to

+   your function, and process the data in place. Other times you will have to

+   set up the array of sample buffer pointers yourself, making sure each

+   buffer can hold 'size' samples. Below is some code to do that. Note that

+   we prefix some variable names with sub-, so they don't clash with the

+   parameters to the function that would typically contain this code.

+

+      sample_t **subsamples;

+      int n;

+      long subsize;

+

+      subsamples = malloc(n_channels * sizeof(*subsamples));

+

+      if (!subsamples)

+         return 0;

+

+      subsamples[0] = malloc(size * n_channels * sizeof(*subsamples[0]));

+

+      if (!subsamples[0]) {

+         free(subsamples);

+         return 0;

+      }

+

+      for (n = 1; n < n_channels; n++)

+         subsamples[n] = subsamples[n-1] + size;

+

+      subsize = signal_render_samples(

+         subsampinfo,

+         volume, delta,

+         size, subsamples

+      );

+

+      /* Process the samples here. */

+

+      free(subsamples[0]);

+      free(subsamples);

+

+      return subsize;

+

+

+void duh_signal_end_samples(DUH_SIGNAL_SAMPINFO *signal_sampinfo);

+

+   Call this when you have finished with a DUH_SIGNAL_SAMPINFO struct. It

+   will free all memory used by the struct.

+

+

+**************************

+*** Resampling Helpers ***

+**************************

+

+

+   The DUH player library provides a versatile resampling system. The sample

+   signal type uses it, and it is available for use in any of your signals.

+

+   Be warned that the resampler may overrun the memory you specify by up to

+   DUMB_EXTRA_SAMPLES samples, so you must allocate these samples and set

+   them to appropriate values when you load your signal. Generally, if you

+   are going to loop, set them to reflect the samples at the loop start

+   point; if you are not going to loop, set them to zero.

+

+   DUMB_EXTRA_SAMPLES is defined as follows:

+

+      #define DUMB_EXTRA_SAMPLES 3

+

+

+extern int resampling_quality;

+

+   Allows you to control the quality of all resampling that takes place. This

+   may be set to any value from 0 to 4. Higher values will sound better, but

+   lower values will use up less processor time.

+

+                   |     --___

+      0 - Aliasing |__---     __

+                   |            ___--

+

+                            |  __

+      1 - Linear resampling | /  \  /\

+                            |/    \/  \__

+

+      2 - Linear resampling / linear average

+

+      3 - Quadratic / linear average

+

+      4 - Cubic / linear average

+

+   Level 0 has very noticeable unwanted overtones. It will occasionally

+   produce satisfactory results for noisy signals, but usually you will

+   want to pay for the extra processor time (which isn't much) and go

+   for Level 1.

+

+   Levels 1 and 2 are already pretty good. When resampling down a few

+   octaves, however, you will begin to notice unwanted high frequencies.

+   These can be eliminated by switching to Levels 3 or 4.

+

+   When Level 2 or higher are selected, a linear average function is used for

+   speeding the wave up. Instead of skipping samples, all samples in the

+   interval will be averaged. The interval is also smoothed at the edges.

+   This will be especially beneficial when increasing the pitch by several

+   octaves.

+

+   Levels 3 and 4 are both smooth curves to the eye. They both give

+   extremely good performance, but you may sometimes notice the difference

+   when reducing the pitch of a sample by several octaves, where Level 3

+   may exhibit unwanted high frequencies.

+

+

+

+

+

+

+

+

+   NOTE: WHAT IS THE DEFAULT? (2 at the moment, but might change. Config?)

+

+

+

+

+

+

+

+

+

+

+

+

+

+long dumb_resample(

+   sample_t *src, long *_src_pos, int *_src_subpos,

+   long src_start, long src_end,

+   sample_t *dst, long dst_size,

+   float delta, int *_dir,

+   DUMB_RESAMPLE_PICKUP pickup, void *pickup_data

+);

+

+   This is the resampling function. It takes an array of source samples and

+   fills as much of the destination array as it can for you. Its operation is

+   quite complicated, so pay attention.

+

+   All the parameters prefixed with an underline (_) are pointers to the

+   fields they describe. This means the function can modify the variables you

+   pass, but you have to prefix the variable with an ampersand (&) when

+   passing it. If you get warnings about ints being converted to pointers

+   without casts, you have most likely forgotten an ampersand somewhere.

+

+   'src' points to the source sample data. It should point to the beginning

+   of the sample, even if you are starting your resampling from somewhere in

+   the middle. Do not break this rule unless you know what you're doing.

+

+   '_src_pos' and '_src_subpos' together represent the current position in

+   the sample. When you first call the function, they represent the starting

+   position. Once the function has done its work, they will represent the

+   point at which the resampling stopped. '_src_pos' is measured in samples.

+   '_src_subpos' represents how far between samples we are, and ranges from

+   0 to 65535 - so if _src_subpos is 65535, we are very nearly on to the next

+   sample.

+

+   Once _src_pos and _src_subpos have been modified by this function, you can

+   pass them to the function again and the resampling will continue

+   seamlessly. This is important, as you will hardly ever get to render all

+   your samples in one go. Typically you will make one call to this function

+   from within your render_samples function.

+

+   This function does not need to know the size of the source buffer as such.

+   Instead, it knows src_start and src_end, which are start and end points.

+   The end point actually points to the first sample not to use, following

+   the usual start-inclusive end-exclusive convention. In general, the

+   resampling will stop when src_pos tries to pass one of these.

+

+   WARNING: dumb_resample() may read up to DUMB_EXTRA_SAMPLES samples beyond

+            src_end. Make sure the memory belongs to you.

+

+   The _dir parameter should be either 1 or -1, and tells this function

+   whether to go forwards or backwards respectively through the source sample

+   buffer. If _dir is 0, nothing will happen - resampling has stopped

+   permanently. Any other values of _dir will have unpredictable results, and

+   the debugging library will abort if you try to use them.

+

+      If _dir is 1, then _src_pos will only be tested against src_end.

+      If _dir is -1, then _src_pos will only be tested against src_start.

+

+   That means you can set src_start and src_end to your loop points, and

+   start playing from the beginning of the sample. The resampling will

+   proceed unimpeded while _src_pos is outside the loop section, provided it

+   is advancing towards the loop section. The sample signal makes extensive

+   use of this capability.

+

+   The output waveform will be rendered into the buffer pointed to by dst.

+   Up to dst_size samples will be generated. Fewer will be generated if the

+   resampling stops permanently. The number generated will be returned. You

+   can find out if resampling ended by testing the value of your direction

+   variable (pointed to by _dir); if it is 0, then resampling stopped

+   permanently.

+

+   If you pass NULL for dst, no samples will be generated. However, _src_pos,

+   _src_subpos and _dir will be updated as normal. The pick-up function will

+   be called as necessary; you should pass the usual 'src' parameter so it

+   can be passed to your pick-up function. (See below for information on

+   pick-up functions.) The function returns the number of samples that would

+   have been generated, had dst pointed somewhere. The operation of

+   do_resample() when dst is NULL is exactly the same as that when dst points

+   somewhere. However, do_resample() is much faster in this case; you should

+   use it when volume is 0, or when you are culling quieter samples to gain

+   execution speed.

+

+   If delta is 1.0f, the destination is the same speed as the source. Greater

+   values cause the sample to speed up, and lesser values cause the sample to

+   slow down. delta should always be positive.

+

+   We have covered most of the parameters. There are only two left - pickup

+   and pickup_data. The simplest usage is to set these both to NULL. Then, if

+   resampling stops, it stops permanently. Use this if your sample will not

+   loop.

+

+   Alternatively, you may wish to write a pick-up function. Your pick-up

+   function will take control whenever _src_pos tries to pass the start or

+   end points. You can use it for looping, or for a multitude of other tasks.

+   The typedef is as follows:

+

+      typedef int (*DUMB_RESAMPLE_PICKUP)(

+         sample_t *src, long *_src_pos, int *_src_subpos,

+         long *_src_start, long *_src_end,

+         int dir,

+         void *data

+      );

+

+   You are passed the source buffer, in case you want to fill it with new

+   samples. You have the _src_pos, _src_subpos, _src_start and _src_end

+   pointers, should you need to change the values to which they point. You

+   also have dir, but note that it is not a pointer. Instead, you should

+   return the new direction, or 0 to stop the resampling permanently.

+

+   The data parameter is a copy of pickup_data as passed to dumb_resample().

+   This is typically used to give you access to your 'sampinfo' parameter,

+   passed to your render_samples function.

+

+   BEWARE: you must refer to and change src_pos, src_subpos, src_start and

+           src_end through the parameters passed. Do not mistakenly use their

+           equivalents in your struct instead. The equivalents in your struct

+           will eventually be updated, but they will not be accurate during

+           the pick-up function.

+

+   On entry to this function, src_pos and src_subpos will have overrun by a

+   small amount. When changing them, you should preserve this overrun. The

+   following examples will do this for you:

+

+      If you are executing a simple loop, subtract (or add) the difference

+      between the loop points from (or to) src_pos. Do not simply set src_pos

+      to the other loop point.

+

+         *_src_pos -= *_src_end - *_src_start;

+

+      If you are executing a ping-pong loop, you need to reflect the pointer

+      off the loop boundary. To reflect off the loop end point:

+

+         *_src_pos = (*_src_end << 1) - 1 - *_src_pos;

+         *_src_subpos ^= 65535;

+         dir = -1;

+

+      To reflect off the loop start point:

+

+         *_src_pos = (*_src_start << 1) - 1 - *_src_pos;

+         *_src_subpos ^= 65535;

+         dir = 1;

+

+      In each case, don't forget to return the new direction correctly!

+

+   An ideal example of a pick-up function can be found in src/sample.c.

+

+   Of course there is more that can be done with a pick-up function. Enjoy

+   experimenting!

+

+

+************************

+*** DUH Construction ***

+************************

+

+

+DUH *make_duh(

+   long length,

+   int n_signals,

+   DUH_SIGTYPE_DESC *desc[],

+   void *signal[]

+);

+

+   Constructs a DUH from its component parts. Use this function if you are

+   writing a function to load a music file format other than .duh. Indeed,

+   this function is used internally to load IT files.

+

+   Before you call this function, you must do some preparation. Your DUH will

+   contain a fixed number of signals; pass this number as n_signals. Each

+   signal will have a DUH_SIGTYPE_DESC struct, and you pass an array of

+   pointers to these. The DUH_SIGTYPE_DESC struct contains the following

+   fields:

+

+      long type;

+      DUH_LOAD_SIGNAL    load_signal;

+      DUH_START_SAMPLES  start_samples;

+      DUH_SET_PARAMETER  set_parameter;

+      DUH_RENDER_SAMPLES render_samples;

+      DUH_END_SAMPLES    end_samples;

+      DUH_UNLOAD_SIGNAL  unload_signal;

+

+   The structs must be in permanent memory, i.e. either global or static, and

+   not modified later; however, the array of pointers can be destroyed as

+   soon as the function returns.

+

+   The values of 'type' and 'load_signal' are irrelevant; set them to 0 and

+   NULL respectively, unless you are using the DUH_SIGTYPE_DESC struct

+   elsewhere.

+

+   Because 'load_signal' is never used, you must provide an array of pointers

+   to the data that 'load_signal' would otherwise have returned. This will

+   be passed to the other functions as 'signal'. Once again, the array of

+   pointers can be destroyed as soon as the function returns. As for the

+   pointers themselves:

+

+   If an 'unload_signal' function is provided, then that will be used to

+   deallocate the pointer when you finally destroy the DUH. If the function

+   is not provided, then you are responsible for deallocating any memory

+   referenced by that pointer yourself. This applies individually to each

+   signal.

+

+   If this function fails and returns NULL, then any 'unload_signal'

+   functions you provided will have been called. You do not have any extra

+   work to do if it fails.

+

+

+********************************

+*** Allegro Packfile Support ***

+********************************

+

+

+void dumb_register_packfiles(void);

+

+   This function registers the Allegro PACKFILE input module for use by

+   DUMBFILEs. PACKFILE structs and their corresponding functions, as defined

+   by Allegro's header file allegro.h, will be used internally for all

+   DUMBFILE input (unless opened with dumbfile_open_ex()).

+

+   This must be called before dumbfile_open() is used, or else an alternative

+   system must be registered (see register_dumbfile_system() and

+   dumb_register_stdfiles()).

+

+

+DUMBFILE *dumbfile_open_packfile(PACKFILE *p);

+

+   If you have an Allegro PACKFILE struct representing an open file, you can

+   call this if you wish to read from it using a DUMBFILE. This is useful

+   when you need to pass a DUMBFILE struct to a library function, to read an

+   embedded music file for example. When you close the DUMBFILE, you can

+   continue using the PACKFILE struct to read what follows the embedded data.

+

+

+***********************************************

+*** Allegro Datafile Registration Functions ***

+***********************************************

+

+

+void register_dat_duh(void);

+

+   If you wish to put a DUH file in an Allegro datafile, you must use "DUH "

+   for the type. The grabber will have a box for the type when you insert a

+   new object. The grabber will treat the DUH file as binary data, which

+   means the datafile will contain an exact copy of the DUH file on disk.

+

+

+

+

+

+   TODO: make it possible to choose the type...

+

+

+

+

+

+   You must then call register_dat_duh() in your program before you load the

+   datafile. Once you've done this, you'll be able to access the DUH using

+   the usual datafile[n].dat notation. You do not need to call unload_duh()

+   on this DUH; unload_datafile() will do that for you.

+

+   If you need to check the type of the object for whatever reason, you can

+   use DAT_DUH, defined as follows:

+

+      #define DAT_DUH DAT_ID('D','U','H',' ')

+

+   The following example iterates through all the DUHs in disan.dat:

+

+      DATAFILE *dat;

+      int n;

+

+      register_dat_duh();

+      dat = load_datafile("disan.dat");

+

+      for (n = 0; dat[n].type != DAT_END; n++) {

+         if (dat[n].type == DAT_DUH) {

+            DUH *duh = dat[n].dat;

+            /* Insert code here to play 'duh' or whatever you want to do. */

+         }

+      }

+

+      unload_datafile(dat);

+

+

+void register_dat_it(void);

+

+   Inserting an IT file in an Allegro datafile is the same as inserting a DUH

+   file, except the type has to be "IT  ", the registration function is

+   register_dat_it(), and the following definition is available for use

+   instead of DAT_DUH:

+

+      #define DAT_IT DAT_ID('I','T',' ',' ')

+

+   Once the datafile is loaded, the 'dat' field indeed points to a DUH

+   struct. There are no differences other than those listed above.

+

+

+*************************************

+*** Allegro DUH Playing Functions ***

+*************************************

+

+

+   The functions in this section allow you to play back a DUH through

+   Allegro's sound system. You must call Allegro's install_sound() function

+   before you use them.

+

+

+AL_DUH_PLAYER *al_start_duh(

+   DUH *duh, int n_channels, long pos, float volume, long bufsize, int freq

+);

+

+   Starts playing the specified DUH.

+

+   An AL_DUH_PLAYER represents one instance of the DUH playing. If you wish,

+   you can have two or more AL_DUH_PLAYERs going at the same time, for the

+   same DUH or for different ones. Each uses one of Allegro's audio streams

+   and hence one voice.

+

+   At present, n_channels can either be 1 or 2 for monaural or stereo

+   respectively. If you use the debugging library, your program will abort if

+   other values are passed; otherwise weird things will happen.

+

+   The DUH will start playing from position 'pos'. 0 represents the start of

+   the DUH, and 65536 represents one second. Unlike other music systems, DUMB

+   will always make sure every note is there right from the start, provided

+   any custom signal types are designed properly. In other words, you can

+   start a DUH at a point halfway through a long note, and you will still

+   hear the long note.

+

+   The volume is a float. 1.0f is the pseudo-maximum. If you pass 1.0f, any

+   properly designed DUH file will play nice and loud, but will not clip. You

+   can pass a greater volume if you like, but be prepared for clipping to

+   occur. Of course you can pass smaller values to play the DUH more quietly,

+   and this will also resolve clipping issues in badly designed DUH files.

+

+   You will need to pass the AL_DUH_PLAYER to other functions when you need

+   to stop or pause the DUH, change its volume, or otherwise modify the way

+   it is playing. You will also need to pass it to al_poll_duh() at regular

+   intervals; if the sound is choppy, try calling al_poll_duh() more often.

+

+   'bufsize' is the number of samples that will be rendered at once. 1024 is

+   a suitable value for most purposes.

+

+

+

+

+

+   NOTE: IS THAT TRUE ON ALL SYSTEMS?

+

+

+

+

+

+   The greater this is, the less often you will have to call al_poll_duh() -

+   but when al_poll_duh() decides to fill the buffer, it will take longer

+   doing so. If your game exhibits regular brief freezes, try reducing the

+   buffer size. If the sound is choppy, however, you may have to increase it.

+

+   'freq' specifies the sampling frequency at which the DUH should be

+   rendered. At present there is no (official and portable) way of knowing

+   the frequency at which Allegro is mixing - but if you do know that

+   frequency, passing it here will give the highest quality sound. If you

+   reduce it, the DUH will sound less crisp but use less processor time.

+

+   When you have finished, you must pass the AL_DUH_PLAYER to al_stop_duh()

+   to free up memory. Do not destroy the DUH beforehand.

+

+   There is no real need to check the return value from this function. The

+   other functions can be called safely with null pointers, so if there is a

+   problem, your music will simply not play.

+

+

+void al_stop_duh(AL_DUH_PLAYER *dp);

+

+   This will stop an AL_DUH_PLAYER. You must call this when you have finished

+   with it, before destroying the DUH. The pointer will no longer be valid on

+   return from this function.

+

+

+void al_pause_duh(AL_DUH_PLAYER *dp);

+

+   This will pause an AL_DUH_PLAYER. Use al_resume_duh() when you want it to

+   continue.

+

+

+void al_resume_duh(AL_DUH_PLAYER *dp);

+

+   Causes a paused AL_DUH_PLAYER to resume playing (see al_pause_duh()).

+

+

+void al_duh_set_volume(AL_DUH_PLAYER *dp, float volume);

+

+   This will set the volume of an AL_DUH_PLAYER. See al_start_duh() for

+   details on the volume parameter.

+

+

+int al_poll_duh(AL_DUH_PLAYER *dp);

+

+   An AL_DUH_PLAYER is not interrupt-driven. That means it will not play by

+   itself. You must keep it alive from your main program. Call this function

+   at regular intervals. If the sound crackles, try calling it more often.

+   (There is nothing you can do if Windows decides to play with the hard

+   disk; that will make your sound crackle no matter what you do.)

+

+   Normally this function will return zero. However, if it returns nonzero,

+   that means the AL_DUH_PLAYER will not generate any more sound. Indeed the

+   underlying audio stream and DUH_RENDERER have been destroyed. When this

+   happens, you can call al_stop_duh() whenever you wish - but you do not

+   have to. Note that this function will wait two buffers' worth of samples

+   before taking this action, allowing Allegro to mix the trailing sound

+   before the audio stream is destroyed. In other words, your music will not

+   be cut off prematurely.

+

+   In case you were wondering, it is definitely not safe to call

+   al_poll_duh() from an interrupt context. Not only is no part of DUMB

+   locked in memory, but many signals and many core library functions

+   allocate and free their memory on a call-by-call basis! Remember that any

+   disk access that occurs in interrupt context is likely to crash the

+   machine. (This limitation only applies to DOS at present, and is due to

+   the fact that the DOS file access functions are not re-entrant.

+   Multitasking systems are generally safe. However, even if you do not think

+   you are targeting DOS, it is worth considering that calling this function

+   regularly from your main loop is likely to be much more efficient than

+   relying on task switching to do it for you.)

+

+

+long al_duh_get_position(AL_DUH_PLAYER *dp);

+

+   Tells you what position an AL_DUH_PLAYER is up to, or -1 if it is invalid

+   (perhaps owing to lack of memory). As usual, 65536 is one second. Note

+   that this is a whole number, whereas a fractional part is stored

+   internally; the sample will not be continuous if you terminate the

+   AL_DUH_PLAYER and then reinitiate it with the same position. Furthermore,

+   note that Allegro will not have mixed in all the sound up to this point;

+   if you wait for this to reach a certain position and then terminate the

+   AL_DUH_PLAYER, the sound will cut off too early.

+

+

+

+

+

+

+

+

+   NOTE: HOW TO GET AROUND THIS?

+

+

+

+

+

+

+

+

+DUH_RENDERER *al_duh_get_renderer(AL_DUH_PLAYER *dp);

+

+   This function returns to you the DUH_RENDERER underlying the specified

+   AL_DUH_PLAYER. It has no practical use in this release, but it

+   TODO: Write this. Also see if it should go in howto.txt.

+

+

+******************

+*** Conclusion ***

+******************

+

+

+I conclude that... DUMB is the bestest music player in the world because...

+Complete this sentence in fifteen words or fewer... D'OH!

+

+

+Ben Davis

+entheh@users.sf.net

+IRC EFnet #dumb

+See readme.txt for details on using IRC.

diff --git a/plugins/dumb/dumb-kode54/docs/faq.txt b/plugins/dumb/dumb-kode54/docs/faq.txt
new file mode 100644
index 00000000..63913f76
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/docs/faq.txt
@@ -0,0 +1,264 @@
+TO DO: add question regarding set_close_button_callback vs set_window_close_hook

+TO DO: add question regarding mixing of DJGPP and MinGW object files

+

+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * faq.txt - Frequently Asked Questions.              / / \  \

+ *                                                   | <  /   \_

+ * This file covers some of the common problems      |  \/ /\   /

+ * and misconceptions people have with DUMB. If       \_  /  > /

+ * your problem is not covered here, please             | \ / /

+ * contact me. I'll do my best to help - but            |  ' /

+ * don't be offended if I just direct you to the         \__/

+ * manual!

+ */

+

+

+*****************************************************************************

+* I get a lot of strange warnings and errors when I compile my projects     *

+* with this release of DUMB. They work with older versions! What happened?  *

+*****************************************************************************

+

+   Some parts of DUMB's API have been deprecated. See docs/deprec.txt for

+   full details, including an explanation as to why your compiler warnings

+   and errors are so unfriendly, and information on how to fix each warning

+   or error.

+

+

+*****************************************************************************

+* When I try to compile DUMB with Allegro, it complains that it cannot find *

+* 'internal/alconfig.h'! What's wrong?                                      *

+*****************************************************************************

+

+   In Allegro 4.0.1, and quite likely some other versions of Allegro, the

+   msvcmake batch file does not install Allegro properly. I believe this was

+   fixed in Allegro 4.0.2, but don't take my word for it. Some include files

+   are neglected, including alconfig.h. The fix is quite easy; you need to

+   copy all of Allegro's include files to your compiler's directory. The

+   following should do this for you (alter it accordingly depending on where

+   MSVC and Allegro are installed):

+

+      cd\progra~1\msvc\include

+      xcopy/s \allegro\include\*.*

+

+   You can safely tell it to overwrite all files.

+

+

+*****************************************************************************

+* When I build a project that uses DUMB, I get an error that it doesn't     *

+* find -laldmbd! What's wrong?                                              *

+*****************************************************************************

+

+   See the notes for DUMB v0.8 in release.txt; the existence of libaldmbd.a

+   in DUMB v0.7 was due to a mistake in the makefiles. It should be

+   libaldmd.a, in order to maintain DOS compatibility. All subsequent

+   releases get it right, but you will have to change your project files to

+   allow for the change. If this is someone else's project, please let them

+   know that it needs changing.

+

+

+*****************************************************************************

+* When I build a project that uses DUMB, I get some linker errors about     *

+* _free, _malloc, etc. already being defined in LIBC.lib! What's wrong?     *

+*****************************************************************************

+

+   MSVC offers three different implementations of the standard libraries.

+   When you link statically with a library, you have to use the same

+   implementation that the library uses. You need the multithreaded DLL

+   implementation, which you can select by passing /MD when you compile (not

+   when you link). See howto.txt for details.

+

+

+*****************************************************************************

+* I created an IT file with Impulse Tracker, but DUMB won't play it! Why?   *

+*****************************************************************************

+

+   You probably created some patterns but didn't give any information on the

+   order in which they should be played. Impulse Tracker will also fail to

+   play your music if you press F5. Press F11 and you will have an

+   opportunity to create an order list, required for playback.

+

+

+*****************************************************************************

+* I created an IT file with ModPlug Tracker and I have it fading out at the *

+* end. Why won't it loop when I play it with DUMB?                          *

+*****************************************************************************

+

+   It loops at zero volume. This is what Impulse Tracker itself does. Fix the

+   IT file by setting the global volume explicitly (Vxx in the effects

+   column), either at the start, or right at the end before looping. Also see

+   the next two questions.

+

+

+*****************************************************************************

+* My module plays too loud and distorts badly with DUMB! What can I do?     *

+*****************************************************************************

+

+   This problem is most often caused by ModPlug Tracker, which has a complete

+   lack of regard for the playback volume of the original tracker. See the

+   next question for DUMB's official position with regard to ModPlug Tracker.

+   If you wrote your module with ModPlug Tracker, please try loading it with

+   the original tracker and see if it distorts there too. If it does, reduce

+   the volume. If not, then it's a problem with DUMB; please let me know.

+

+   If for whatever reason you cannot modify the module file itself, you can

+   make it sound better by reducing the volume passed to al_start_duh().

+

+

+*****************************************************************************

+* I created a music module with ModPlug Tracker, and DUMB doesn't play it   *

+* right!                                                                    *

+*****************************************************************************

+

+   DUMB cannot and will not support ModPlug Tracker. Please see

+   docs/modplug.txt for details. The original trackers, which DUMB is

+   designed to mimic as closely as possible, are listed in readme.txt.

+   If you find DUMB plays your module differently from the original tracker,

+   then please contact me.

+

+

+*****************************************************************************

+* My program crashes as soon as I try to load anything with DUMB!           *

+*****************************************************************************

+

+   Please take my advice and use the debugging build of DUMB, not the

+   optimised build. Then you'll probably find it aborts instead of crashing.

+   In this case you probably forgot to register a DUMBFILE system; this is

+   necessary for loading stand-alone files, though not for loading Allegro

+   datafiles with embedded music. Follow the instructions in docs/howto.txt

+   carefully and you shouldn't have this problem.

+

+   If DUMB crashes with a specific music module, please let me know.

+

+

+*****************************************************************************

+* I want to use the stdio file access functions to load stand-alone music   *

+* files, but I also want to load datafiles containing music files. The docs *

+* say I shouldn't call both dumb_register_stdfiles() and                    *

+* dumb_register_packfiles(). What shall I do?                               *

+*****************************************************************************

+

+   When you register a DUMBFILE system, it only applies to files opened with

+   dumbfile_open(), i.e. separate files. When a file is embedded in a

+   datafile, dumbfile_open_ex() is used to read it, enabling it to use

+   PACKFILEs regardless of which DUMBFILE system is registered. In short, you

+   do not need to call dumb_register_packfiles() in order to load datafiles

+   with embedded music. See the section on "Sequential File Input" in

+   docs/dumb.txt if you're interested in how all this works.

+

+

+*****************************************************************************

+* I want to read a specific object in a datafile using Allegro's            *

+* "demo.dat#MY_MUSIC" syntax. Why won't it work?                            *

+*****************************************************************************

+

+   Did you call dumb_register_packfiles(), or did you call

+   dumb_register_stdfiles()? It will only work if you use the former.

+

+

+*****************************************************************************

+* My program runs, but no music plays! What am I doing wrong?               *

+*****************************************************************************

+

+   There are a number of possible causes for this. The most likely reason is

+   that you aren't calling al_poll_duh(); see docs/howto.txt for further

+   information.

+

+   Other possible causes are as follows:

+

+   - The speakers are turned down (duh)

+   - The volume of some system mixer is turned down

+   - Another program is using the sound card (not a problem for most modern

+     systems)

+   - You didn't initialise Allegro's sound system; see install_sound() in

+     Allegro's docs

+   - Allegro's drivers don't work on your system and chosen platform

+

+   In order to narrow down the cause, consider the following:

+

+   - Do you get any other sound from your program?

+   - Do other Allegro+DUMB programs generate sound?

+   - Do other Allegro programs generate sound?

+   - Do other non-Allegro programs generate sound?

+   - Does your program fail only on a specific platform (e.g. DOS but not

+     Windows)?

+

+   This problem is highly system-specific; please try hard to solve it by

+   yourself before contacting me. However, if you think this problem could

+   affect other people, please let me know what the problem is and how you

+   fixed it, if you did. Be as specific as possible.

+

+

+*****************************************************************************

+* The music stutters! What can I do?                                        *

+*****************************************************************************

+

+   If you have an older computer, it may not be able to cope with the load.

+   Try reducing quality options; look up dumb_resampling_quality and

+   dumb_it_max_to_mix in docs/dumb.txt, and consider changing the frequency

+   you pass to al_start_duh().

+

+   Stuttering may not be caused by excessive load. To find out, try

+   increasing the buffer size passed to al_start_duh(). Beware of making it

+   too big though; older systems will freeze periodically if it's too big,

+   because they render larger chunks less frequently. The timing of callbacks

+   will also be less accurate, if you are using those.

+

+   If you're using the 'dumbplay' example, you can control these parameters

+   by editing dumb.ini.

+

+

+*****************************************************************************

+* Why does DUMB use so much processor time compared with other players?     *

+*****************************************************************************

+

+   This should be less so in this release than in previous releases; the

+   resampling and filtering algorithms have been optimised.

+

+   By default, DUMB uses the most expensive resampling quality option. I've

+   found on an AthlonXP 1800+ and on a Pentium 233 that it typically uses

+   about twice as much processor time as the least expensive option.

+

+   Try setting dumb_resampling_quality to DUMB_RQ_ALIASING or DUMB_RQ_LINEAR.

+   See dumb.txt for more information. If you're using the example programs,

+   you can control this variable by editing dumb.ini.

+

+   DUMB uses 32-bit ints for mixing. Some players use 16-bit ints, and are

+   therefore marginally faster (not much!) and lower quality. So you can't

+   expect DUMB to beat these players. Furthermore, DUMB is currently written

+   entirely in C. GCC does an impressive job on the C code, but that's not to

+   say some custom-written assembly language couldn't beat it ...

+

+

+*****************************************************************************

+* Why does DUMB generate so much background noise?                          *

+*****************************************************************************

+

+   You're probably using the DOS build on a system with bad Sound Blaster

+   compatibility (most Windows XP systems fall in this category). This would

+   mean DUMB could only access an 8-bit driver. The Windows build will almost

+   certainly give better results. Your DOS binary will still give good

+   results on systems with better compatibility (like my Windows 98 system).

+

+

+*****************************************************************************

+* I e-mailed you and you replied with "RTFM"! What does that mean?          *

+*****************************************************************************

+

+   Read The Manual. If it's a specific problem, I'll probably be kind and

+   tell you where to look in the manual. However, if I get the impression you

+   haven't even looked for a solution in the manual, expect no mercy ...

+

+

+Ben Davis

+entheh@users.sf.net

+IRC EFnet #dumb

+See readme.txt for details on using IRC.

diff --git a/plugins/dumb/dumb-kode54/docs/fnptr.txt b/plugins/dumb/dumb-kode54/docs/fnptr.txt
new file mode 100644
index 00000000..9a0d87b6
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/docs/fnptr.txt
@@ -0,0 +1,113 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * fnptr.txt - Function pointer explanation.          / / \  \

+ *                                                   | <  /   \_

+ *                                                   |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+C allows you to create and use function pointers. A function pointer is a

+variable that points to a function, and you can use it to call that function.

+Why is this useful?

+

+Function pointers can be passed as parameters. As an example, here's a

+function from Allegro:

+

+   void create_light_table(COLOR_MAP *table, const PALETTE pal, int r, g, b,

+                                                  void (*callback)(int pos));

+

+Don't worry about the syntax just yet, but the last parameter, 'callback', is

+a pointer to a function that takes an int parameter. create_light_table() can

+take some time to complete its work, and you may want to display a progress

+indicator. So you write a function to draw the progress indicator, and then,

+for 'callback', you specify a pointer to your function. This will enable

+create_light_table() to call your function at intervals during its

+processing. (If you don't want to use the callback, you can pass NULL, but

+this only works because create_light_table() checks actively for NULL. You

+can't always specify NULL when you want nothing to happen.)

+

+There are many other uses. In addition to using function pointers as

+parameters, Allegro has some global function pointers you can set to point to

+your functions. Function pointers can also be used in structs, and this is

+where DUMB makes the most use of them.

+

+So how are they used?

+

+   void bar(void) { ... }    /* Here's a function */

+   void (*foo)(void) = &bar; /* Take a pointer */

+   (*foo)();                 /* Call the function */

+

+   char *baz(float a) { ... }          /* Here's another function */

+   char *(*foobarbaz)(float a) = &baz; /* Take a pointer */

+   char *rv = (*foobarbaz)(0.1);       /* Call the function */

+

+In both these cases, note how the statement for calling the pointed-to

+function (third line) resembles the definition of the function pointer

+(second line). This is true of any variable in C, and can lead to some truly

+obfuscated definitions if you are that way inclined. Such definitions can be

+clarified with typedefs, but before you use those, it is important you

+understand how the above statements work. I speak from experience: function

+pointer notation looks random and scary, until you understand why it's the

+way it is; then it makes perfect sense.

+

+(It is actually permissible to omit the & when taking a pointer and to write

+e.g. foobarbaz(0.1) instead of (*foobarbaz)(0.1). However, I recommend not

+doing this, since the syntax for using the pointer no longer resembles the

+definition. Writing e.g. (*foobarbaz)(0.1) also makes a clear distinction

+between function pointer calls and ordinary function calls, which makes code

+more readable.)

+

+Note that function pointers have the return value and parameter list

+specified. A function pointer can only point to a function with a matching

+return value and matching parameters. (You can break this rule by casting the

+pointer explicitly, but there is no situation where doing so is portable to

+all computers, and I strongly advise against it unless you're writing system

+code. If you're not sure whether you're writing system code or not, then

+you're not.)

+

+The parameter names need not match (although the types must). If you wish to

+rename a parameter in your function, you do not have to change the function

+pointer accordingly. In fact, when you define a function pointer, you don't

+even have to specify the names of parameters if you don't want to. I normally

+do so for clarity.

+

+It is possible to typedef a function pointer. In order to typedef a function

+pointer, you start by declaring the pointer as a variable:

+

+   void (*myfunc)(void);

+

+Then you write 'typedef' before it and replace the variable name, which is

+myfunc, with the type name (this rule can be applied to any variable when you

+want to use typedef):

+

+   typedef void (*MYTYPE)(void);

+

+Now 'MYTYPE' represents a pointer to a function with no parameters and no

+return value. The following two lines are completely equivalent:

+

+   MYTYPE myfunc;

+   void (*myfunc)(void);

+

+Note that we use MYTYPE without an asterisk (*), since it is already a

+pointer.

+

+That's it. If you feel anything should be explained better here, or if you

+feel something should be added, please don't hesitate to let me know!

+

+

+Ben Davis

+entheh@users.sf.net

+IRC EFnet #dumb

+See readme.txt for details on using IRC.

diff --git a/plugins/dumb/dumb-kode54/docs/howto.txt b/plugins/dumb/dumb-kode54/docs/howto.txt
new file mode 100644
index 00000000..1d9a439f
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/docs/howto.txt
@@ -0,0 +1,845 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * howto.txt - How To Use DUMB.                       / / \  \

+ *                                                   | <  /   \_

+ * See readme.txt for general information on         |  \/ /\   /

+ * DUMB and how to set it up.                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+********************

+*** Introduction ***

+********************

+

+

+Welcome to the DUMB How-To! It is assumed here that you have already set DUMB

+up on your system, with or without Allegro. If not, please see readme.txt.

+

+

+*********************************

+*** Adding music to your game ***

+*********************************

+

+

+These instructions will help you add a piece of music to your game, assuming

+your music is stored in a stand-alone IT, XM, S3M or MOD file. If you wish to

+use a different method (such as putting the music file in an Allegro

+datafile), please follow these instructions first, test your program, and

+then follow the instructions further down for adapting your code.

+

+

+1. You need to include DUMB's header file. If you have Allegro, add the

+   following line to the top of your source file (or at the top of each file

+   where you wish to use DUMB):

+

+      #include <aldumb.h>

+

+   If you do not have Allegro or do not wish to use it, use dumb.h instead.

+

+

+2. You need to link with DUMB's library file or files. If you are compiling

+   with GCC from a command line on any platform, you need to add the

+   following to the command line:

+

+      If you are using Allegro: -laldmd -ldumbd

+      If you are not using Allegro: -ldumbd

+

+   If you are using MSVC from the command line:

+

+      If you are using Allegro: /link aldmd.lib dumbd.lib

+      If you are not using Allegro: /link dumbd.lib

+

+   With MSVC, you must also add /MD to the command line when compiling (not

+   when linking).

+

+   Note that -laldmd or aldmd.lib must PRECEDE alleg.lib, -lalleg_s,

+   `allegro-config --libs`, or whatever you are already using to link with

+   Allegro. For MSVC users, the /MD flag selects the multithreaded DLL

+   implementation of the standard libraries; since DUMB is statically linked,

+   you have to use the same library DUMB uses. You would also need this flag

+   to link statically with Allegro; if you already have it, there's no need

+   to put it twice.

+

+   (If anyone would like to contribute instructions for doing the above using

+   MSVC's IDE, please contact me. Contact details are at the end of this

+   file.)

+

+   If you are using RHIDE, go to Options -> Libraries. You will need to type

+   'aldmd' and 'dumbd' in two boxes, making sure 'aldmd' comes above whatever

+   you are using to link with Allegro (or just put 'dumbd' if you are not

+   using Allegro). Make sure the box next to each of these libraries is

+   checked.

+

+   The above are the debugging libraries. It is VERY HIGHLY RECOMMENDED that

+   you use the debugging libraries at first. The reason is as follows.

+   Although DUMB is supposedly robust against corrupt music files and things

+   like lack of memory, it will NOT tolerate programmer error. If you write

+   faulty code, DUMB will probably crash rather than returning an error code

+   for you. However, the debugging libraries will abort in many cases,

+   enabling you to find out what the cause is.

+

+   Once your program is up and running reliably, you can replace 'aldmd' with

+   'aldmb' and 'dumbd' with 'dumb'. Don't forget to do this, or DUMB will be

+   a lot slower than it should be!

+

+

+3. As you use DUMB, it may claim system resources (memory in particular). You

+   will need to arrange for these resources to be freed at the end. Doing so

+   is very easy. Simply write the following line at the top of your main

+   function, but below allegro_init() if you are using Allegro:

+

+      atexit(&dumb_exit);

+

+   This arranges for the function dumb_exit() to be called when your program

+   exits; you do not need to call dumb_exit() yourself. This method is

+   preferable to calling dumb_exit() manually, as it will free resources even

+   if your program aborts unexpectedly.

+

+   If you are happy with this, please skip ahead to Step 4. If you are

+   interested in alternative methods, read on, but read on carefully.

+

+   In fact it mostly doesn't matter where you put the above atexit() line,

+   provided it gets called only once, and before you do anything with DUMB.

+   If you are using DUMB with Allegro, it is recommended that you write the

+   functions in this order:

+

+      allegro_init();

+      atexit(&dumb_exit);

+

+   And then you must NOT call allegro_exit() yourself (because it has to be

+   called after dumb_exit()). Alternatively, if you prefer not to use

+   atexit() (or you cannot), you will have to do the following before

+   exiting:

+

+      dumb_exit();

+      allegro_exit();

+

+

+4. DUMB does not automatically do any of its own file input. You have to tell

+   it how to read files. Don't worry, it's easy. Simply call the following

+   function near the beginning of your program, after your atexit() call:

+

+      dumb_register_stdfiles();

+

+   This tells DUMB to use ordinary stdio FILE structs for reading and writing

+   files. If you are using Allegro and would rather DUMB used PACKFILEs, call

+   the following function INSTEAD:

+

+      dumb_register_packfiles();

+

+   In the latter case, DUMB will be affected by any password you set with

+   packfile_password() in the same way that other PACKFILEs are.

+

+   Note that the procedure for loading datafiles with embedded music is

+   independent of these two functions; even if you will be loading datafiles,

+   you can use either of these functions. If you are loading datafiles, your

+   executable might be slightly smaller if you use dumb_register_packfiles().

+   On the other hand, dumb_register_stdfiles() will probably be faster. If

+   you are only ever going to load datafiles and never stand-alone files, you

+   can actually leave this step out; but I would recommend you put this in,

+   test your code with a stand-alone file, then follow the instructions in

+   the next section in order to adapt your code to use the datafile (you will

+   be reminded that you can remove the function call).

+

+

+5. If you are using Allegro, you'll have to initialise Allegro's sound

+   system. In most cases the following line will do the job:

+

+      install_sound(DIGI_AUTODETECT, MIDI_NONE, NULL);

+

+   You may like to initialise a MIDI driver though; see Allegro's docs for

+   details. Put this line after allegro_init().

+

+

+6. All pieces of music are stored in memory in DUH structs. To handle these,

+   you must define pointers to them. Such pointers look like this:

+

+      DUH *myduh;

+

+   You can of course replace 'myduh' with anything you like. If you are

+   unfamiliar with pointers, please see ptr.txt. It is very important that

+   you understand these if you wish to use DUMB correctly.

+

+   You do not have direct access to the contents of a DUH struct, so do not

+   try. DUMB's functions provide everything you need; if you disagree, please

+   let me know and I shall see what I can do. Contact details are at the end

+   of this file.

+

+   Given the above definition, you can load a piece of music using one of the

+   following lines, depending on what file format you want to load:

+

+      myduh = dumb_load_it("a_one.it");

+      myduh = dumb_load_xm("a_two.xm");

+      myduh = dumb_load_s3m("a_one_two.s3m");

+      myduh = dumb_load_mod("three_four.mod");

+

+   Obviously you can use relative or absolute paths as normal. You should

+   always use forward slash (/), not backslash (\), when coding in C and

+   similar languages.

+

+   Every piece of music you load must be unloaded when you've finished with

+   it. When you type the above line in, it is good practice to type the

+   following line in at the same time, but put it at the end of the program:

+

+      unload_duh(myduh);

+

+   You will now be able to use the DUH struct anywhere in between the two

+   lines you just added. There is no need to check the return value; if the

+   DUH failed to load for one reason or another (this could be due to lack of

+   memory as well as the file not being there), then DUMB will do nothing -

+   safely.

+

+

+7. From this step onwards, it will be assumed you're using Allegro. If not,

+   please read these steps anyway, and then see the section entitled

+   "Rendering music into a buffer". You will have to write your own playback

+   code using whatever sound output system is available. Alternatively you

+   may like to write data to a file (especially if you have a file that

+   consumes a lot of processor time), but beware that any streaming audio

+   format is likely to be substantially larger than the module file you

+   generate it from, and formats like MP3 will be lower quality. You might

+   not be able to hear the difference between the MP3 and the original, but

+   many people can and don't like it, so please consider them. I'm one of

+   them. If you really want to use a lossy compression format, I highly

+   recommend Ogg Vorbis:

+

+      http://www.vorbis.com/

+

+   But I digress.

+

+   In order to play the DUH you loaded, you need to define a pointer to an

+   AL_DUH_PLAYER struct:

+

+      AL_DUH_PLAYER *dp;

+

+   Two of the functions you will need are prototyped as follows:

+

+      AL_DUH_PLAYER *al_start_duh(DUH *duh, int n_channels, long pos,

+                                  float volume, long bufsize, int freq);

+

+      void al_stop_duh(AL_DUH_PLAYER *dp);

+

+   As you can see, al_start_duh() returns a pointer to an AL_DUH_PLAYER

+   struct when you call it. You then pass this pointer to all the other

+   functions. Again, if it is a NULL pointer for whatever reason (usually

+   lack of memory), DUMB will safely do nothing. When you call al_stop_duh(),

+   the pointer becomes invalid and you should not use it again; if there's

+   any risk of the pointer being used again, it is wise to set it to NULL at

+   this point. You can reassign the variable with a new call to

+   al_start_duh() of course.

+

+   Set 'n_channels' to 1 or 2 for mono or stereo respectively. Note that this

+   parameter has nothing to do with the number of samples that can play at

+   once in a music module. Set 'pos' to 0 to play from the beginning; each

+   time you add 65536, you will have advanced one second into the piece. As a

+   general rule, set the volume to 1.0f and adjust it later if the music is

+   too loud or too quiet - but see Allegro's set_volume_per_voice() function

+   first.

+

+   'bufsize' can generally be set to 4096. If your music stutters, try

+   increasing it; if your game freezes periodically, try reducing it. Find a

+   happy medium. Set 'freq' to 48000 for the best quality, though 44100 will

+   do in most cases. 22050 will be fine for a lot of music, though 11025 may

+   sound muffled. You can choose any other value, higher, lower or in

+   between. If your music stutters, and increasing 'bufsize' doesn't fix it,

+   try reducing this value.

+

+   Once you have put in a call to al_start_duh(), it is good practice to

+   insert the call to al_stop_duh() at the same time. You must call

+   al_stop_duh() before the DUH is unloaded (unload_duh(), Step 6 above).

+

+   Don't get impetuous, your program is not ready yet! Proceed to Step 8.

+

+

+8. DUMB does not play music in the background for you; if you were expecting

+   it to do so, please see the explanation at the end of this step. For your

+   music to be played, you have to call another function at regular

+   intervals. Here is its prototype:

+

+      int al_poll_duh(AL_DUH_PLAYER *dp);

+

+   Do NOT call this function from inside a timer function unless you really

+   know what you are doing. The reasons why this is bad are explained

+   further down. You should call it from your main program.

+

+   Simply writing the following line will be sufficient in general, if you

+   have a variable 'dp' that points to your AL_DUH_PLAYER struct.

+

+      al_poll_duh(dp);

+

+   As a general rule, calling this once for each logic update will do the

+   trick. If, however, you are executing time-consuming algorithms such as

+   software 3D rendering, you may wish to insert calls to this function in

+   the middle of those algorithms. You cannot call this function too often

+   (within reason); if it has nothing to do it will return immediately.

+

+   Exactly how often you need to call the function depends on the values for

+   'bufsize' and 'freq' that you passed to al_start_duh():

+

+      n = freq / bufsize;

+

+   You have to call al_poll_duh() at least n times a second. Do not hesitate

+   to call it more often for safety; if the sound stutters, you may need to

+   do just that. (Or you may need to increase the buffer size or reduce the

+   quality settings; the only way to find out is to try.)

+

+   For now, don't worry about al_poll_duh()'s return value. As soon as you

+   need it, it will be explained.

+

+   If you are happy, please skip to Step 9. If you were expecting DUMB to

+   play your music in the background, please read on.

+

+   The natural way to play music in the background on most operating systems

+   nowadays is to use threads. DOS was not built with multithreading in mind,

+   and its system operations (notably disk access) assume they will only be

+   used from a single thread.

+

+   Interrupts are the next best thing to threads. A DOS hardware interrupt

+   could be triggered at any moment, and a handler function will be called.

+   This is how Allegro's timer functions work. Unfortunately, what you can do

+   inside an interrupt handler is very limited. For one thing, all code and

+   data used by the handler must be locked in memory; if not, it could get

+   written to disk (virtual memory). If the main program was accessing the

+   disk when it got interrupted, the system would then die a horrible death.

+   This precludes the possibility of allocating extra memory inside the

+   handler, and DUMB does a lot of that in al_poll_duh().

+

+   Given DUMB's architecture, which cannot change for reasons which will

+   become apparent in future versions, this renders it impossible to come up

+   with a portable solution for making DUMB play music in the background.

+   Having said that, if you wish to write your own wrapper for al_poll_duh()

+   and use it in a thread, there is nothing stopping you. If you do do this,

+   you will have to be very careful when stopping the music; see the

+   description of al_poll_duh() in dumb.txt for more information.

+

+   So why not kill DOS? It is all too common a practice among programmers to

+   quote the phrase, "DOS is as dead as the dodo." Despite being a decidedly

+   derisible demonstation of the dreary device of alliteration, it shows a

+   distinct lack of experience. Many embedded systems still use DOS because

+   it provides hardware access capabilities and real-time possibilities

+   unparalleled by any current multitasking operating system. For an argument

+   closer to home, I used to use RHIDE for DOS before I switched to Linux,

+   and I have not found a single Freeware Windows IDE that measures up to

+   RHIDE. I'm sure many people are in the same boat, and really appreciate

+   DUMB's DOS port.

+

+   We will not be removing DOS support from DUMB. Any blind suggestions to do

+   so will be met with fiery flames. You have been warned.

+

+

+9. Test your program!

+

+   If you have trouble, check through the above steps to make sure you didn't

+   miss one out. Refer to faq.txt to see if your problem is addressed there.

+   If you still have trouble, contact me; details are at the end of this

+   file.

+

+

+**********************************

+*** Controlling music playback ***

+**********************************

+

+

+Here I describe some common operations you may wish to perform. The method

+for doing so will seem a bit strange sometimes, as will the names of the

+structs. However, there is a reason behind everything. If you would like to

+do more exotic things, or better understand some of the methods used here,

+then see dumb.txt, which covers everything from the ground up.

+

+

+To control playback quality:

+

+   #define DUMB_RQ_ALIASING

+   #define DUMB_RQ_LINEAR

+   #define DUMB_RQ_CUBIC

+   #define DUMB_RQ_N_LEVELS

+   extern int dumb_resampling_quality;

+   extern int dumb_it_max_to_mix;

+

+   Please note that dumb_resampling_quality has changed in DUMB v0.9.2. See

+   deprec.txt for more details on the change.

+

+   dumb_resampling_quality can be set to any of the DUMB_RQ_* constants

+   (except DUMB_RQ_N_LEVELS; see below). Resampling is the term given to the

+   process of adjusting a sample's pitch (in this context).

+   dumb_resampling_quality defaults to DUMB_RQ_CUBIC, which sounds nice but

+   takes a lot of processor power. Try reducing it if you have an older

+   computer or if you are trying to mix an insane number of samples (or

+   both!). See dumb.txt for details on what the different values actually do.

+

+   If you wish to give this option to your user, you can use

+   DUMB_RQ_N_LEVELS. All the values from 0 to DUMB_RQ_N_LEVELS - 1 will be

+   valid resampling levels. If a value outside this range is chosen, it is

+   not the end of the world; DUMB will behave as if you had chosen the value

+   at whichever extreme you went beyond.

+

+   dumb_it_max_to_mix, defaulting to 64, is the maximum number of samples

+   DUMB will ever mix together when playing an IT, XM, S3M or MOD file.

+   Unlike many other music systems, DUMB will still keep track of all samples

+   (up to a fixed maximum of 256 of them, roughly speaking), and then will

+   just render as many of them as this variable permits, starting with the

+   loudest ones. When samples are cut or come back in, the exact timings will

+   not generally be predictable - but nor will they be important.

+

+   dumb_it_max_to_mix applies to each currently playing module file

+   independently. So if you set it to 64, but render two modules

+   simultaneously, DUMB could end up mixing up to 128 samples.

+

+

+To pause and resume playback, set the volume, get the current playback

+position, or get the length of time a DUH will play for before either looping

+or freezing (effect F00 in XM and MOD files, which means no new notes will be

+played but any existing notes will continue):

+

+   void al_pause_duh(AL_DUH_PLAYER *dp);

+   void al_resume_duh(AL_DUH_PLAYER *dp);

+   void al_duh_set_volume(AL_DUH_PLAYER *dp, float volume);

+   long al_duh_get_position(AL_DUH_PLAYER *dp);

+

+   long duh_get_length(DUH *duh);

+

+   These functions are pretty self-explanatory. The volume passed to

+   al_duh_set_volume() and the position returned by al_duh_get_position() are

+   in the same units as those you passed to al_start_duh(). The length

+   returned by duh_get_length() is in the same units as the aforementioned

+   position; see dumb.txt for more information on this function. Be careful

+   with al_duh_get_position(); it will return a position slightly ahead of

+   what you can hear, because the system has to keep ahead slightly to avoid

+   stuttering.

+

+

+To prevent the music from looping and/or freezing:

+

+   DUH_SIGRENDERER *al_duh_get_sigrenderer(AL_DUH_PLAYER *dp);

+   DUMB_IT_SIGRENDERER *duh_get_it_sigrenderer(DUH_SIGRENDERER *sigrenderer);

+

+   void dumb_it_set_loop_callback(DUMB_IT_SIGRENDERER *sigrenderer,

+      int (*callback)(void *data), void *data);

+   void dumb_it_set_xm_speed_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer,

+      int (*callback)(void *data), void *data);

+

+   int dumb_it_callback_terminate(void *data);

+

+   If you are unfamiliar with function pointers, please see fnptr.txt.

+

+   Note that these functions apply to IT, XM, S3M and MOD files - not just to

+   IT files. This holds true throughout DUMB, for all functions with "it" in

+   the name. The xm_speed_zero event can only occur with XM and MOD files.

+

+   The first two functions will return a pointer to a struct contained by the

+   struct you pass. This system is necessary to ensure that these operations

+   are possible when not using Allegro. Typically you would write the

+   following code:

+

+   {

+      DUH_SIGRENDERER *sr = al_duh_get_sigrenderer(dp);

+      DUMB_IT_SIGRENDERER *itsr = duh_get_it_sigrenderer(sigrenderer);

+      dumb_it_set_loop_callback(itsr, &dumb_it_callback_terminate, NULL);

+      dumb_it_set_xm_speed_zero_callback

+                               (itsr, &dumb_it_callback_terminate, NULL);

+   }

+

+   Once you have done this, the return value of al_poll_duh() becomes

+   significant. It will be 0 as long as the music is playing. When the music

+   stops, al_poll_duh() will return nonzero. You can call al_stop_duh() and

+   do something else as soon as you wish, but calling al_poll_duh() some more

+   will not do any harm.

+

+   al_poll_duh() will also return 1 if the music could not be loaded, or if

+   memory was short when trying to play it, or if it was a quirky music file

+   with no music in it (technically one with an empty order list). This

+   happens regardless of whether or not you execute the above code to disable

+   looping. Normally you shouldn't need to worry about this.

+

+   To undo the above and make DUMB loop or freeze again, pass NULL instead of

+   &dumb_it_callback_terminate. If you would like to fade on looping, or loop

+   a finite number of times, or display a message when looping, or whatever,

+   you will have to write your own callback function. In this case, please

+   see dumb.txt.

+

+   Note that the above code can safely be applied for a DUH that doesn't

+   contain a music module but contains some other kind of music.

+   duh_get_it_sigrenderer() will return NULL, and the code will do nothing.

+

+

+To analyse the audio as it's generated:

+

+   typedef int sample_t;

+

+   typedef void (*DUH_SIGRENDERER_ANALYSER_CALLBACK)(void *data,

+                const sample_t *const *samples, int n_channels, long length);

+

+   void duh_sigrenderer_set_analyser_callback(DUH_SIGRENDERER *sigrenderer,

+                     DUH_SIGRENDERER_ANALYSER_CALLBACK callback, void *data);

+

+   If the above confuses you, see fnptr.txt. These functions, along with

+   al_duh_get_sigrenderer() from the last section, enable you to register a

+   callback function. Every time some samples are generated, they will be

+   passed to this function. This enables you to display an oscilloscope or

+   spectrum analyser, for example.

+

+   Beware: your callback function may occasionally be called with

+   samples == NULL. This means the main program has decided to skip through

+   the music without generating any data. You should handle this case

+   elegantly, typically by returning immediately, but you may wish to make a

+   note of the fact that the music is being skipped, for whatever reason.

+

+   Beware again: if the main program ever calls duh_sigrenderer_get_samples()

+   on a buffer that isn't all silence, this callback function will be passed

+   the existing buffer after mixing, and thus it will include the original

+   data. This will not be an issue if you stick to duh_render(), which always

+   starts with a buffer filled with silence.

+

+   The samples array is two-dimensional. Refer to it as follows:

+

+      samples[channel_number][sample_position]

+

+   where 0 <= channel_number < n_channels,

+     and 0 <= sample_position < length.

+

+   In addition you can pass any 'data' pointer you like to

+   duh_sigrenderer_set_analyser_callback(), and this pointer will be relayed

+   to your callback function each time.

+

+   To remove the callback function, pass NULL to

+   duh_sigrenderer_set_analyser_callback().

+

+

+Everything below this point assumes some knowledge of how a music module is

+constructed. If you do not have this knowledge, talk to whoever is writing

+music for you, or download a tracking program and play with it (see

+readme.txt).

+

+

+To start playing an IT, XM, S3M or MOD from an arbitrary order number (the

+default being 0, the beginning of the song), use the following:

+

+   DUH_SIGRENDERER *dumb_it_start_at_order

+                                  (DUH *duh, int n_channels, int startorder);

+   AL_DUH_PLAYER *al_duh_encapsulate_sigrenderer

+        (DUH_SIGRENDERER *sigrenderer, float volume, long bufsize, int freq);

+

+   The usage of these functions is as follows:

+

+   {

+      DUH_SIGRENDERER *sr = dumb_it_start_at_order

+                                               (duh, n_channels, startorder);

+      dp = al_duh_encapsulate_sigrenderer(sr, volume, bufsize, freq);

+   }

+

+   Replace 'dp' with whatever your AL_DUH_PLAYER pointer is. You also need

+   to insert suitable values for n_channels, startorder, volume, bufsize and

+   freq. These have the same meaning as those passed to al_start_duh().

+

+   WARNING: after passing a pointer to an "encapsulate" function, do not use

+            that pointer again. (More specifically, do not use it again if

+            the function returns NULL, because the function will have

+            destroyed the pointer if this happens, to help prevent memory

+            leaks.) There will be a "get" function with which you can obtain

+            the original pointer if it is still valid, or NULL otherwise.

+

+   The above functions will fail (safely) if you try to use them with a DUH

+   that contains a different type of music.

+

+   Notice that there is no 'pos' parameter. If you would like to skip through

+   the music, you can use this function:

+

+   long duh_sigrenderer_get_samples(

+      DUH_SIGRENDERER *sigrenderer,

+      float volume, float delta,

+      long size, sample_t **samples

+   );

+

+   Pass 0 for volume and NULL for samples, and this function will skip

+   through the music nice and quickly. So insert the following between the

+   two above statements:

+

+      duh_sigrenderer_get_samples(sr, 0, 65536.0f / freq, pos, NULL);

+

+   Substitute for 'freq' and 'pos'. An explanation of the 'delta' parameter

+   can be found further down in this file.

+

+   Finally, note that duh_get_length() is only meaningful when you start

+   playing music from order 0.

+

+

+If an IT file contains Zxx effects, DUMB will generate MIDI messages, which

+will control the low-pass resonant filters unless the IT file actively

+specifies something else. In rare cases this may not be what the Zxx effects

+were intended to do; if this is the case, you can block the MIDI messages as

+follows. Note that this does NOT mean filters are disabled; if an instrument

+specifies initial cut-off and resonance values, or has a filter envelope,

+then filters will be applied. It only makes sense to use this procedure at

+the beginning of playback.

+

+   void dumb_it_set_midi_callback(DUMB_IT_SIGRENDERER *sigrenderer,

+      int (*callback)(void *data, int channel, unsigned char byte),

+      void *data);

+

+   int dumb_it_callback_midi_block(void *data, int channel,

+                                   unsigned char byte);

+

+   Using some functions described in the previous section, we arrive at the

+   following code:

+

+   {

+      DUH_SIGRENDERER *sr = al_duh_get_sigrenderer(dp);

+      DUMB_IT_SIGRENDERER *itsr = duh_get_it_sigrenderer(sigrenderer);

+      dumb_it_set_midi_callback(itsr, &dumb_it_callback_midi_block, NULL);

+   }

+

+DUMB offers no way of disabling filters completely. Disabling filters is not

+recommended as a means to reduce processor usage, as it will completely

+damage any piece of music that uses the filters. If you want lower processor

+consumption, use a piece of music that does not use filters.

+

+

+Finally, DUMB offers a myriad of functions for querying and adjusting

+module playback. Those beginning with "dumb_it_sd" operate on the

+DUMB_IT_SIGDATA struct, which represents the piece of music before it starts

+to play. Those beginning with "dumb_it_sr" operate on the DUMB_IT_SIGRENDERER

+struct, which represents a currently playing instance of the music. Note that

+duh_get_length(), described above, becomes meaningless after some of these

+functions are used.

+

+The method for getting a DUMB_IT_SIGRENDERER struct has already been given,

+but the function prototypes are repeated here for convenience:

+

+   DUH_SIGRENDERER *al_duh_get_sigrenderer(AL_DUH_PLAYER *dp);

+   DUMB_IT_SIGRENDERER *duh_get_it_sigrenderer(DUH_SIGRENDERER *sigrenderer);

+

+Getting a DUMB_IT_SIGDATA struct is simpler:

+

+   DUMB_IT_SIGDATA *duh_get_it_sigdata(DUH *duh);

+

+For a list of dumb_it_sd_*() and dumb_it_sr_*() functions, please see

+dumb.txt. These functions are new, and may not provide exactly what you need;

+if not, please let me know.

+

+

+**************************************************

+*** Embedding music files in Allegro datafiles ***

+**************************************************

+

+

+In this section it is assumed you are already reasonably familiar with how

+Allegro datafiles are used. If not, please refer to Allegro's documentation.

+At the time of writing, the documentation you need is off the beaten track,

+so to speak, in allegro/tools/grabber.txt.

+

+To add a piece of music to a datafile, you need to create an object of type

+"IT  ", "XM  ", "S3M " or "MOD " (note the spaces used as padding, although

+you do not need to type these into the grabber). Then grab the piece of music

+in. The grabber will treat it as a binary object. Save the datafile as usual.

+

+

+To use a piece of music you added to the datafile, follow these steps:

+

+

+1. Before loading the datafile, call one or more of these functions,

+   depending on which music format or formats you'd like to support:

+

+      dumb_register_dat_it(DUMB_DAT_IT);

+      dumb_register_dat_xm(DUMB_DAT_XM);

+      dumb_register_dat_s3m(DUMB_DAT_S3M);

+      dumb_register_dat_mod(DUMB_DAT_MOD);

+

+   Remember, do not call multiple functions unless you want to support

+   multiple formats. Calling more functions will add unused code to your

+   executable.

+

+   It is important that you make call these before loading the datafile,

+   since they tell Allegro how to load the respective files straight from

+   datafiles in the future. They will not help Allegro interpret any module

+   files that have already been loaded as binary objects (but if you really

+   need to interpret a module that has been loaded in this fashion, have a

+   look at dumbfile_open_memory() in dumb.txt).

+

+   If for whatever reason your music objects are identified by a different

+   type in the datafile, you can tell DUMB what that type is by changing the

+   parameter to the registration function above. Use Allegro's DAT_ID()

+   macro, e.g. DAT_ID('B','L','A','H'). This is not really recommended

+   though, since it would prevent a hypothetical grabber plug-in from being

+   able to play your music files. Use the above types if possible.

+

+

+2. Whenever you need a pointer to a DUH struct, simply use the 'dat' field.

+   Do this in the same way you would for a pointer to a BITMAP struct or

+   anything else. If it makes you feel more comfortable, you can extract the

+   pointer in advance:

+

+      DATAFILE *dat = load_datafile("smurf.dat");

+      if (!dat) abort(); /* There are much nicer ways of handling failure! */

+      DUH *myduh = (DUH *)dat[GAME_MUSIC].dat;

+

+   Note that the explicit (DUH *) cast is only necessary for C++, not for C.

+   However, it does no harm.

+

+   Be sure that you do NOT call unload_duh() for anything stored in the

+   datafile. These DUHs will be freed when you call unload_datafile(), and

+   freeing them twice is practically guaranteed to crash your program.

+

+

+3. If you only ever load music as part of a datafile, and you never load any

+   stand-alone music files, you do not need to register a file input system

+   for DUMB to use. If you followed the instructions for the first section

+   you will have one of these two lines in your program:

+

+      dumb_register_stdfiles();

+      dumb_register_packfiles();

+

+   You can safely delete this line - but only if you never load any

+   stand-alone music files. The debugging library will bale you out if you

+   delete it when you shouldn't; the optimised library won't.

+

+

+*************************************

+*** Rendering music into a buffer ***

+*************************************

+

+

+NOTE: much of the API formerly described in this section has been deprecated,

+      and you will need to alter your code. See deprec.txt for details. If

+      you are reading this section for the first time, you can ignore this

+      note.

+

+Rendering to a buffer is similar to playing using an AL_DUH_PLAYER. However,

+you must use a DUH_SIGRENDERER struct instead. Here are the functions:

+

+   DUH_SIGRENDERER *duh_start_sigrenderer

+                               (DUH *duh, int sig, int n_channels, long pos);

+

+   int duh_sigrenderer_get_n_channels(DUH_SIGRENDERER *sigrenderer);

+   long duh_sigrenderer_get_position(DUH_SIGRENDERER *sigrenderer);

+

+   long duh_sigrenderer_get_samples(DUH_SIGRENDERER *sigrenderer,

+                   float volume, float delta, long size, sample_t **samples);

+

+   long duh_render(DUH_SIGRENDERER *sigrenderer,

+     int bits, int unsign, float volume, float delta, long size, void *sptr);

+

+   void duh_end_sigrenderer(DUH_SIGRENDERER *sigrenderer);

+

+The parameters to duh_start_sigrenderer() have the same meanings as those to

+al_start_duh(). However, note that the volume is not set at this stage. You

+pass the desired volume each time you want to render a block. The 'sig'

+parameter should be set to 0 for now.

+

+Notice that there are two rendering functions. duh_sigrenderer_get_samples()

+will generate samples in the internal 32-bit format, with a normal range from

+-0x800000 to 0x7FFFFF and with each channel in a separate array; duh_render()

+will convert to 8 or 16 bits, signed or unsigned, with stereo samples

+interleaved, left first.

+

+When you call duh_render(), pass 8 or 16 for 'bits'. If you pass 8, 'sptr' is

+expected to be an array of chars. If you pass 16, 'sptr' is expected to be an

+array of shorts. Endianness therefore depends on the platform, and you should

+not try to interpret 16-bit wave data as an array of chars (unless you're

+writing highly system-specific code anyway). Because DUMB renders internally

+with 32 bits, there is no significant speed increase in rendering an 8-bit

+stream.

+

+If you are rendering in stereo, make sure your 'sptr' array is twice as big!

+

+If you set 'unsign' to a nonzero value, then the samples generated will be

+centred on 0x80 or 0x8000, suitably stored in an array of unsigned chars or

+unsigned shorts. If 'unsign' is zero, the samples will be centred on 0,

+suitably stored in an array of signed chars or signed shorts. Note that 8-bit

+WAV files are unsigned while 16-bit WAV files are signed. This convention was

+used by the SoundBlaster 16 when receiving samples to be sent to the

+speakers. If you wish to write 16-bit sample data to a WAV file, don't use

+fwrite(); instead, take the shorts one at a time, split them up into chars as

+follows, and write the chars to the file.

+

+   short sptr[n];

+   char lsb = (char)sptr[n];

+   char msb = (char)(sptr[n] >> 8);

+

+For a 16-bit WAV file, write the LSB (less significant byte) first.

+

+The following applies equally to duh_render() and

+duh_sigrenderer_get_samples(), except where otherwise stated.

+

+If you set 'delta' to 1.0f, the sound generated will be suitable for playback

+at 65536 Hz. Increasing 'delta' causes the wave to speed up, given a constant

+sampling rate for playback. Supposing you want to vary the playback sampling

+rate but keep the pitch constant, here's the equation for 'delta':

+

+   delta = 65536.0f / sampling_rate;

+

+'size' is the number of samples you want rendered. For duh_render(), they

+will be rendered into an array which you pass as 'sptr'. Note that stereo

+samples count as one; so if you set n_channels to 2, your array must contain

+(2 * size) elements.

+

+For duh_sigrenderer_get_samples() you will have to use the following

+functions:

+

+   sample_t **create_sample_buffer(int n_channels, long length);

+   void destroy_sample_buffer(sample_t **samples);

+

+   void dumb_silence(sample_t *samples, long length);

+

+create_sample_buffer() allocates the channels sequentially in memory, so the

+following technique is valid:

+

+   sample_t **samples = create_sample_buffer(n_channels, length);

+   dumb_silence(samples[0], n_channels * length);

+

+It is necessary to fill the buffer with silence like this because

+duh_sigrenderer_get_samples() mixes what it renders with the existing

+contents of the buffer.

+

+The return values from duh_render() and duh_sigrenderer_get_samples() tell

+you how many samples were actually generated. In most cases, this will be the

+same as the 'size' parameter. However, if you reach the end of the DUH (which

+will happen if you disable looping or freezing as described further up), this

+function will return less. When that happens, you can assume the stream has

+finished. In the case of duh_render(), the remainder of the array will not

+have been initialised, so you either have to initialise it yourself or avoid

+using it.

+

+If for whatever reason duh_start_sigrenderer() returns NULL, then

+duh_render() and duh_sigrenderer_get_samples() will generate exactly 0

+samples, duh_sigrenderer_get_n_channels() will return 0,

+duh_sigrenderer_get_position() will return -1, and duh_end_sigrenderer() will

+safely do nothing.

+

+

+*********************

+*** Miscellaneous ***

+*********************

+

+

+Please see dumb.txt for an API reference and for information on thread safety

+with DUMB. The API reference has been stripped down, since some functions and

+variables are subject to change. If something does not appear in dumb.txt,

+please do not use it.

+

+

+******************

+*** Conclusion ***

+******************

+

+

+If you have any difficulties, or if you use DUMB successfully, please don't

+hesitate to contact me (see below).

+

+Enjoy!

+

+

+Ben Davis

+entheh@users.sf.net

+IRC EFnet #dumb

+See readme.txt for details on using IRC.

diff --git a/plugins/dumb/dumb-kode54/docs/modplug.txt b/plugins/dumb/dumb-kode54/docs/modplug.txt
new file mode 100644
index 00000000..65eabe8a
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/docs/modplug.txt
@@ -0,0 +1,137 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * modplug.txt - Our official position regarding      / / \  \

+ *               compatibility with ModPlug          | <  /   \_

+ *               Tracker.                            |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+********************

+*** Introduction ***

+********************

+

+ModPlug Tracker is a very popular tracker for Windows. Its popularity is due

+to the intuitive interface and its many advanced features. The author has

+done a good job with this piece of software, but sadly in doing so he has

+desecrated the IT file format.

+

+I am not against ModPlug Tracker being used to write music modules. As

+already stated, it has some very advanced and convenient features; I use it

+myself. However, I believe its users should be aware of the entire situation

+before using it for any serious work.

+

+   ModPlug Tracker - http://www.modplug.com/

+

+

+*************************

+*** Incompatibilities ***

+*************************

+

+There are a few situations in which ModPlug Tracker misinterprets the

+original module formats. I shall list the five I am most aware of, from least

+to most annoying:

+

+5. Create a multisample instrument, for example a piano. Play a low note.

+   Then go up the scale, but in the pattern data, make sure the instrument

+   column is blank; put in only the notes. Play this with ModPlug Tracker,

+   and play it with Impulse Tracker. Impulse Tracker changes sample as you go

+   up the scale; ModPlug Tracker does not.

+

+4. Arpeggio and Retrigger Note effects behave badly when combined with

+   Portamento, which can appear in the volume column. While Retrigger Note

+   isn't too bad, Arpeggio sounds completely wrong. Try it and see what

+   happens. Then repeat the experiment in Impulse Tracker.

+

+3. The filter algorithm is incorrect, in more ways than one. When Jeffrey Lim

+   programmed the low-pass resonant filters into Impulse Tracker, he used a

+   standard filter algorithm with a slight modification to achieve greater

+   resonance. ModPlug Tracker does not incorporate this modification.

+   Furthermore, ModPlug Tracker uses integer arithmetic with nowhere near

+   enough precision; the wave output is really poor in some cases. I don't

+   doubt it damages the acoustic properties of the filters in subtle ways.

+

+2. When looping, ModPlug Tracker resets all variables. The original trackers

+   do not do this.

+

+1. Worst of all, ModPlug Tracker has no regard for playback volume, and

+   generally has a much lower output level than the original trackers.

+

+Cases 3, 2 and 1 lead people to write IT files that play badly in the

+original trackers. If some of these problems could be fixed, I'd be all for

+it - but these problems have been reported to the author and he had no

+motivation to fix them. ModPlug Tracker has been around long enough that

+fixing 3, 2 and 1 would be detrimental to too many people's music.

+

+

+******************

+*** Extensions ***

+******************

+

+Worse than the incompatibilities are the extensions ModPlug Tracker makes,

+mostly to the IT format. DUMB currently supports one of these extensions,

+namely stereo samples, but supporting the others is not high on my list of

+priorities.

+

+Other extensions ModPlug Tracker has provided mostly take the form of extra

+effects. For instance, S98 and S99 can be used to enable or disable reverb. I

+believe the latest versions of ModPlug Tracker offer alternative types of

+filter, such as high-pass and band-pass. As soon as an IT file uses any of

+these features, it will play incorrectly with Impulse Tracker.

+

+By far the most evil extension provided by ModPlug Tracker is the effect

+plug-ins. These enable IT files to use VST effects. I recently downloaded an

+IT file that uses some effects from a collection named "DirectX Media Audio

+Effects". When can we expect these effects to be ported to Linux?

+

+

+******************

+*** Conclusion ***

+******************

+

+ModPlug Tracker is trying to be two things at once. It wants to be an editor

+for the existing formats, but at the same time it wants to be proprietary,

+with all its own features and extensions. Unfortunately it is succeeding;

+there are many IT files out there that only play right in ModPlug Tracker. In

+my opinion, ModPlug Tracker should have come out with its own file format, in

+which all these extensions would have found a home.

+

+If you are going to use ModPlug Tracker's extensions, I recommend you

+ultimately convert your music to a streamed format such as Ogg Vorbis. (If

+you were thinking of using MP3, then don't - consider using Ogg Vorbis

+instead.) If you release IT files that use ModPlug Tracker's extensions,

+please state prominently that the files are designed to be played with

+ModPlug Tracker. Finally, don't ask me to support ModPlug Tracker's

+extensions; ModPlug Tracker's playback code is available for use in your

+games, so use that instead.

+

+   Ogg Vorbis - http://www.vorbis.com/

+

+Despite all the above problems, don't forget that ModPlug Tracker does have a

+lot of very useful features for editing files. These include a function for

+removing unused patterns, samples and instruments, drag-and-drop sample and

+instrument ripping, drop-down menus for selecting the effects by name without

+having to memorise the codes or refer to help, and lots of other nice things.

+I do recommend it as an editor, provided you make sure you are aware of the

+situation and do not use ModPlug Tracker's extensions or incompatibilities

+inadvertently.

+

+Oh, and by the way, save your final version with Impulse Tracker. Then the

+samples will be compressed for you!

+

+

+Ben Davis

+entheh@users.sf.net

+IRC EFnet #dumb

+See readme.txt for details on using IRC.

diff --git a/plugins/dumb/dumb-kode54/docs/ptr.txt b/plugins/dumb/dumb-kode54/docs/ptr.txt
new file mode 100644
index 00000000..bf7534d4
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/docs/ptr.txt
@@ -0,0 +1,129 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * ptr.txt - Pointer explanation.                     / / \  \

+ *                                                   | <  /   \_

+ *                                                   |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+A pointer is a small variable (often the same size as an int BUT NOT ALWAYS)

+that holds the address of something in memory. You create a pointer by adding

+a * to a variable, as follows:

+

+   int x, *y;

+

+   x = 5;

+   y = &x;

+

+The & means 'address of', so &x gives us a pointer to x. We are storing it in

+y.

+

+   (*y)++;

+

+The * here means 'value at'. It's known as the 'dereferencing' operator. When

+written before a pointer, as it is here, it allows you to treat the value

+like a normal variable. In this case we are incrementing the value. If we

+look at x, we'll find that it now contains 6, not 5.

+

+   y++;

+

+Here we are incrementing the pointer itself. This is useful for traversing

+through an array, but in this particular example it is not much use.

+

+   *y++;

+

+Beware; this will increment the pointer, not the value stored there. It will

+return the value stored at the pointer (before incrementing the pointer), so

+you can use this in a bigger expression. This is why we needed brackets in

+the first example.

+

+Note that you will not need these three examples when working with DUMB; they

+are simply to help illustrate the idea of pointers.

+

+Also be aware that when defining pointers you attach the * to the variable,

+not to the type. The following example will create a pointer and an int, not

+two pointers:

+

+   int *a, b;

+

+That is why I believe it's a good idea to put a space before the * and not

+after it, although programmers are divided on this.

+

+   y = 0;

+   y = NULL;

+

+These two statements are equivalent. 0, or NULL, is a special value that is

+guaranteed to have a different value from any valid pointer. This is most

+often used to indicate that something doesn't point anywhere. DUMB's

+functions may return it on occasion. However, in simple usage of DUMB, you

+will not actually need to check for it.

+

+Some of DUMB's functions return pointers to structs. (A struct is an

+aggregration of other variables, such as ints, pointers, or other structs.

+You can generally treat a struct as a single unit.) Here's an example of such

+a function:

+

+   DUH *dumb_load_it(const char *filename);

+

+You do not know what the DUH struct actually contains; dumb.h and aldumb.h

+only give the compiler enough information to deal with pointers to them. DUMB

+will take charge of everything that happens inside a DUH struct.

+

+The above function will create a DUH struct for you. First it allocates

+the memory it needs, then it fills the struct with data, then it returns a

+pointer. This DUH struct will contain the data necessary to play an IT file.

+You can define a suitable variable and store the pointer in it as follows:

+

+   DUH *duh = dumb_load_it("music.it");

+

+Or this can be split up:

+

+   DUH *duh;

+   duh = dumb_load_it("music.it");

+

+In order to use this DUH struct later, you must pass its pointer to other

+functions. To pass the pointer to a function, simply write 'duh' for the

+appropriate parameter.

+

+When you've finished with a DUH struct (this applies equally to the other

+structs DUMB deals with), you must pass it to an appropriate function for

+freeing up the memory:

+

+   unload_duh(duh);

+

+After you've done this, the memory will no longer be allocated, and the

+pointer will have no meaning. You may wish to set it to NULL at this point

+for safety. Alternatively just be sure not to use the present value of the

+pointer any more. You can of course assign a new value to the pointer, e.g.

+by calling dumb_load_it() again.

+

+Note the following:

+

+   DUH *duh2 = duh;

+

+This only duplicates the pointer, not the DUH itself. You still only have one

+copy of the DUH. There is no way of duplicating a DUH, short of loading it

+twice. This is not a problem, because DUMB can play it 'twice at the same

+time' anyway.

+

+That should be all you need to know about pointers in order to use DUMB. If

+there's anything you feel should be explained better here, or anything else

+that should be added, please don't hesitate to let me know!

+

+

+Ben Davis

+entheh@users.sf.net

+IRC EFnet #dumb

+See readme.txt for details on using IRC.

diff --git a/plugins/dumb/dumb-kode54/docs/tutorial.txt b/plugins/dumb/dumb-kode54/docs/tutorial.txt
new file mode 100644
index 00000000..a4309655
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/docs/tutorial.txt
@@ -0,0 +1,94 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * tutorial.txt - DUMB Programmers' Tutorial.         / / \  \

+ *                                                   | <  /   \_

+ * See readme.txt for general information on         |  \/ /\   /

+ * DUMB and how to set it up.                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+********************

+*** Introduction ***

+********************

+

+

+Welcome to the DUMB Programmers' Tutorial!

+

+In order to follow this tutorial, you should already have set Allegro and

+DUMB up on your system, including DUMB's support for Allegro and the example

+programs. If you have not done so, see readme.txt for details.

+

+You will also need some IT files. If you would like to compose your own, then

+first I must offer a word of warning: not everyone is capable of composing

+music. Do not assume you will be able to learn the art. By all means have a

+go; if you can learn to play tunes on the computer keyboard, you're well on

+the way to being a composer!

+

+The best program for the job is Impulse Tracker itself, available from:

+

+http://www.noisemusic.org/it/

+

+This is a DOS program. Users of DOS-incapable operating systems may like to

+try ModPlug Tracker, but should be aware that it does not support all

+combinations of effects correctly, and some IT files will sound wrong. If you

+use a different operating system, or if you know of a better IT editor for

+Windows, please give me some links so I can put them here!

+

+ModPlug Tracker is available from: http://www.modplug.com/

+

+If you would like to download IT files composed by other people, check the

+following sites:

+

+http://www.modplug.com/

+http://www.traxinspace.com/

+

+Once again, if you know of more sites where IT files are available for

+download, please let me know.

+

+Once you've got some IT files, we're ready to begin!

+

+Note that support for S3M files has very recently been added to DUMB, but it

+is bound to be faulty. I recommend you use IT files in preference until later

+releases of DUMB.

+

+

+******************

+*** Try It Out ***

+******************

+

+

+We'll start simply by running one of the example programs.

+

+Find playit.exe, in the dumb/examples folder. Choose an IT file, and pass it

+to playit.exe. In DOS, you can do this by typing 'playit' followed by the

+name of the IT file. In Windows, you can drag the IT file and drop it on

+playit.exe.

+

+You should now hear the music play back. If not, make sure your speakers are

+on and volume is not turned down. Try one of Allegro's example programs. If

+you are using DJGPP under Windows, consider using a Windows compiler instead.

+If you cannot get it working, see readme.txt for details on seeking help with

+DUMB.

+

+When you are satisfied, press any key to stop the music and return to the

+operating system.

+

+

+*************************

+*** How Does It Work? ***

+*************************

+

+

+Now load playit.c into your favourite editor. Here is an explanation of what

+it does:

diff --git a/plugins/dumb/dumb-kode54/examples/Makefile.am b/plugins/dumb/dumb-kode54/examples/Makefile.am
new file mode 100644
index 00000000..2c1117fd
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/examples/Makefile.am
@@ -0,0 +1,11 @@
+INCLUDES = \

+	-I $(top_srcdir)/include

+

+LIBS = $(top_builddir)/src/libdumb.la -lm

+

+bin_PROGRAMS = dumb2wav dumbout

+

+dumb2wav_SOURCES = dumb2wav.c

+dumbout_SOURCES  = dumbout.c

+#dumbplay_SOURCES = dumbplay.c

+#playduh_SOURCES  = playduh.c

diff --git a/plugins/dumb/dumb-kode54/examples/dumb.ini b/plugins/dumb/dumb-kode54/examples/dumb.ini
new file mode 100644
index 00000000..ee707ad2
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/examples/dumb.ini
@@ -0,0 +1,44 @@
+# Please edit this file to control the playback quality for 'dumbplay'. Note

+# that this does not affect DUMB when you use it in your own programs; you

+# need to borrow some code from the example program in order to get that to

+# happen.

+

+# dumb_resampling_quality can be 0 for aliasing, 1 for linear interpolation

+# or 2 for cubic interpolation. See docs/dumb.txt for details on what these

+# terms mean.

+

+# dumb_it_max_to_mix is the maximum number of samples DUMB will render at a

+# time. See docs/dumb.txt for a more detailed description.

+

+# Increase buffer_size to combat stuttering.

+

+# The music module will be rendered at the sampling frequency specified by

+# sound_freq. This variable is also used by Allegro for initialising the

+# sound hardware.

+

+# buffer_size and sound_freq are passed directly to al_start_duh(). See this

+# function's description in docs/dumb.txt for information about how to use

+# these variables.

+

+# You can ignore the quality variable. Allegro uses it when relaying the

+# audio stream to the sound card. Only a masochist would set it lower than 2;

+# if your computer is powerful enough to run DUMB, it is powerful enough to

+# use this setting with Allegro.

+

+# For best results, choose a value for sound_freq that your sound card can do

+# exactly. See Allegro's docs, "Standard config variables", for details. If

+# you do not choose an exact value, Allegro will round it to the nearest

+# value it can do; then when DUMB plays the stream at a sampling frequency of

+# sound_freq, Allegro will have to resample it. Allegro's 'quality = 2'

+# setting is only comparable with DUMB's 'dumb_resampling_quality = 1'

+# setting. Therefore, in order to appreciate DUMB's cubic resampler fully,

+# you will need to make sure Allegro doesn't do any resampling, by choosing

+# an exact value for sound_freq.

+

+[sound]

+dumb_resampling_quality = 2

+dumb_it_max_to_mix = 256

+buffer_size = 4096

+sound_freq = 44100

+

+quality = 2

diff --git a/plugins/dumb/dumb-kode54/examples/dumb2wav.c b/plugins/dumb/dumb-kode54/examples/dumb2wav.c
new file mode 100644
index 00000000..9a4c5090
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/examples/dumb2wav.c
@@ -0,0 +1,481 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * dumb2wav.c - Utility to convert DUH to WAV.        / / \  \

+ *                                                   | <  /   \_

+ * By Chad Austin, based on dumbout.c by entheh.     |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <time.h>

+#include <stdlib.h>

+#include <stdio.h>

+#include <ctype.h>

+#include <math.h>

+#include <string.h>

+#include <dumb.h>

+

+#include <internal/it.h>

+

+union {

+	float s32[4096];

+	short s16[8192];

+	char s8[16384];

+} buffer;

+

+sample_t ** internal_buffer;

+

+int loop_count = 1;

+

+

+static int write32_le(FILE* outf, unsigned int value) {

+	int total = 0;

+	total += fputc(value & 0xFF,         outf);

+	total += fputc((value >> 8)  & 0xFF, outf);

+	total += fputc((value >> 16) & 0xFF, outf);

+	total += fputc((value >> 24) & 0xFF, outf);

+	return total;

+}

+

+static int write16_le(FILE* outf, unsigned int value) {

+	int total = 0;

+	total += fputc(value & 0xFF,        outf);

+	total += fputc((value >> 8) & 0xFF, outf);

+	return total;

+}

+

+

+static int loop_callback(void* data) {

+	return (--loop_count <= 0 ? -1 : 0);

+}

+

+

+int main(int argc, const char *argv[])

+{

+	DUH *duh;

+	DUH_SIGRENDERER *sr;

+

+	const char *fn = NULL;

+	const char *fn_out = NULL;

+	FILE *outf;

+

+	int depth = 16;

+	int unsign = 0;

+	int freq = 44100;

+	int n_channels = 2;

+	int solo = -1;

+	float volume = 1.0f;

+	float delay = 0.0f;

+	float delta;

+	int bufsize;

+	clock_t start, end;

+	int data_written = 0;  /* total bytes written to data chunk */

+

+	int i = 1;

+

+	LONG_LONG length;

+	LONG_LONG done;

+	int dots;

+

+	while (i < argc) {

+		const char *arg = argv[i++];

+		if (*arg != '-') {

+			if (fn) {

+				fprintf(stderr,

+					"Cannot specify multiple filenames!\n"

+					"Second filename found: \"%s\"\n", arg);

+				return 1;

+			}

+			fn = arg;

+			continue;

+		}

+		arg++;

+		while (*arg) {

+			char *endptr;

+			switch (*arg++) {

+				case 'o':

+				case 'O':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; output filename expected!\n");

+						return 1;

+					}

+					fn_out = argv[i++];

+					break;

+				case 'd':

+				case 'D':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; delay expected!\n");

+						return 1;

+					}

+					delay = (float)strtod(argv[i++], &endptr);

+					if (*endptr != 0 || delay < 0.0f || delay > 64.0f) {

+						fprintf(stderr, "Invalid delay!\n");

+						return 1;

+					}

+					break;

+				case 'v':

+				case 'V':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; volume expected!\n");

+						return 1;

+					}

+					volume = (float)strtod(argv[i++], &endptr);

+					if (*endptr != 0 || volume < -8.0f || volume > 8.0f) {

+						fprintf(stderr, "Invalid volume!\n");

+						return 1;

+					}

+					break;

+				case 's':

+				case 'S':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; sampling rate expected!\n");

+						return 1;

+					}

+					freq = strtol(argv[i++], &endptr, 10);

+					if (*endptr != 0 || freq < 1 || freq > 960000) {

+						fprintf(stderr, "Invalid sampling rate!\n");

+						return 1;

+					}

+					break;

+				case 'f':

+					depth = 32;

+					break;

+				case '8':

+					depth = 8;

+					break;

+				case 'l':

+				case 'L':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments: loop count expected!\n");

+						return 1;

+					}

+					loop_count = strtol(argv[i++], &endptr, 10);

+					break;

+				case 'm':

+				case 'M':

+					n_channels = 1;

+					break;

+				case 'u':

+				case 'U':

+					unsign = 1;

+					break;

+				case 'r':

+				case 'R':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; resampling quality expected!\n");

+						return 1;

+					}

+					dumb_resampling_quality = strtol(argv[i++], &endptr, 10);

+					if (*endptr != 0 || dumb_resampling_quality < 0 || dumb_resampling_quality > 2) {

+						fprintf(stderr, "Invalid resampling quality!\n");

+						return 1;

+					}

+					break;

+				case 'c':

+				case 'C':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; channel number expected!\n");

+						return 1;

+					}

+					solo = strtol(argv[i++], &endptr, 10);

+					if (*endptr != 0 || solo < 0 || solo >= DUMB_IT_N_CHANNELS) {

+						fprintf(stderr, "Invalid channel number!\n");

+						return 1;

+					}

+					break;

+				default:

+					fprintf(stderr, "Invalid switch - '%c'!\n", isprint(arg[-1]) ? arg[-1] : '?');

+					return 1;

+			}

+		}

+	}

+

+	if (!fn) {

+		fprintf(stderr,

+			"Usage: dumb2wav [options] module [more-options]\n"

+			"\n"

+			"The module can be any IT, XM, S3M or MOD file. It will be rendered to a .wav\n"

+			"file of the same name, unless you specify otherwise with the -o option.\n"

+			"\n"

+			"The valid options are:\n"

+			"-o <file>   specify the output filename (defaults to the input filename with\n"

+			"              the extension replaced with .wav); use - to write to standard\n"

+			"              output or . to write nowhere (useful for measuring DUMB's\n"

+			"              performance, and DOS and Windows don't have /dev/null!)\n"

+			"-d <delay>  set the initial delay, in seconds (default 0.0)\n"

+			"-v <volume> adjust the volume (default 1.0)\n"

+			"-s <freq>   set the sampling rate in Hz (default 44100)\n"

+			"-8          generate 8-bit instead of 16-bit\n"

+			"-f          generate floating point samples instead of 16-bit\n"

+			"-m          generate mono output instead of stereo left/right pairs\n"

+			"-u          generated unsigned output instead of signed\n"

+			"-r <value>  specify the resampling quality to use\n"

+			"-l <value>  specify the number of times to loop (default 1)\n"

+			"-c <value>  specify a channel number to solo\n");

+		return 1;

+	}

+

+	atexit(&dumb_exit);

+	dumb_register_stdfiles();

+

+	dumb_it_max_to_mix = 256;

+

+	duh = load_duh(fn);

+	if (!duh) {

+		duh = dumb_load_it(fn);

+		if (!duh) {

+			duh = dumb_load_xm(fn);

+			if (!duh) {

+				duh = dumb_load_s3m(fn);

+				if (!duh) {

+					duh = dumb_load_mod(fn);

+					if (!duh) {

+						fprintf(stderr, "Unable to open %s!\n", fn);

+						return 1;

+					}

+				}

+			}

+		}

+	}

+

+	sr = duh_start_sigrenderer(duh, 0, n_channels, 0);

+	if (!sr) {

+		unload_duh(duh);

+		fprintf(stderr, "Unable to play file!\n");

+		return 1;

+	}

+

+	if (solo >= 0) {

+		DUMB_IT_SIGRENDERER * itsr = duh_get_it_sigrenderer(sr);

+		if (itsr) {

+			for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+				if (i != solo) {

+					IT_CHANNEL * channel = &itsr->channel[i];

+					IT_PLAYING * playing = channel->playing;

+					channel->flags |= IT_CHANNEL_MUTED;

+					/* start_sigrenderer leaves me all of the channels the first tick triggered */

+					if (playing) {

+						playing->ramp_volume[0] = 0;

+						playing->ramp_volume[1] = 0;

+						playing->ramp_delta[0] = 0;

+						playing->ramp_delta[1] = 0;

+					}

+				}

+			}

+		}

+	}

+

+	if (fn_out) {

+		if (fn_out[0] == '-' && fn_out[1] == 0)

+			outf = stdout;

+		else if (fn_out[0] == '.' && fn_out[1] == 0)

+			outf = NULL;

+		else {

+			outf = fopen(fn_out, "wb");

+			if (!outf) {

+				fprintf(stderr, "Unable to open %s for writing!\n", fn_out);

+				duh_end_sigrenderer(sr);

+				unload_duh(duh);

+				return 1;

+			}

+		}

+	} else {

+		char *extptr = NULL, *p;

+		char *fn_out = malloc(strlen(fn)+5);

+		if (!fn_out) {

+			fprintf(stderr, "Out of memory!\n");

+			duh_end_sigrenderer(sr);

+			unload_duh(duh);

+			return 1;

+		}

+		strcpy(fn_out, fn);

+		for (p = fn_out; *p; p++)

+			if (*p == '.') extptr = p;

+		if (!extptr) extptr = p;

+		strcpy(extptr, ".wav");

+		outf = fopen(fn_out, "wb");

+		if (!outf) {

+			fprintf(stderr, "Unable to open %s for writing!\n", fn_out);

+			free(fn_out);

+			duh_end_sigrenderer(sr);

+			unload_duh(duh);

+			return 1;

+		}

+		free(fn_out);

+	}

+

+	{

+		DUMB_IT_SIGRENDERER *itsr = duh_get_it_sigrenderer(sr);

+		dumb_it_set_ramp_style(itsr, 2);

+		dumb_it_set_loop_callback(itsr, loop_callback, NULL);

+		dumb_it_set_xm_speed_zero_callback(itsr, &dumb_it_callback_terminate, NULL);

+		dumb_it_set_global_volume_zero_callback(itsr, &dumb_it_callback_terminate, NULL);

+	}

+

+

+	if (outf) {

+		/* write RIFF header: fill file length later */

+		fwrite("RIFF", 1, 4, outf);

+		fwrite("    ", 1, 4, outf);

+		fwrite("WAVE", 1, 4, outf);

+

+		/* write format chunk */

+		fwrite("fmt ", 1, 4, outf);

+

+		if (depth == 32)

+		{

+			write32_le(outf, 18);

+			write16_le(outf, 3);

+		}

+		else

+		{

+			write32_le(outf, 16);         /* header length */

+			write16_le(outf, 1);          /* WAVE_FORMAT_PCM */

+		}

+		write16_le(outf, n_channels); /* channel count */

+		write32_le(outf, freq);       /* frequency */

+		write32_le(outf, freq * n_channels * depth / 8); /*bytes/sec*/

+		write16_le(outf, n_channels * depth / 8); /* block alignment */

+		write16_le(outf, depth);      /* bits per sample */

+

+		if (depth == 32)

+		{

+			write16_le(outf, 0);

+		}

+

+		/* start data chunk */

+		fwrite("data", 1, 4, outf);

+		fwrite("    ", 1, 4, outf);  /* fill in later */

+	}

+

+	length = (LONG_LONG)_dumb_it_build_checkpoints(duh_get_it_sigdata(duh), 0) * freq >> 16;

+	done = 0;

+	dots = 0;

+	delta = 65536.0f / freq;

+	bufsize = sizeof(buffer);

+	if (depth == 32) bufsize /= sizeof(*buffer.s32);

+	else if (depth == 16) bufsize /= sizeof(*buffer.s16);

+	bufsize /= n_channels;

+

+	if (depth == 32) {

+		internal_buffer = create_sample_buffer(n_channels, bufsize);

+		if (!internal_buffer) {

+			fprintf(stderr, "Out of memory!\n");

+			duh_end_sigrenderer(sr);

+			unload_duh(duh);

+		}

+	}

+

+	{

+		long l = (long)floor(delay * freq + 0.5f);

+		l *= n_channels * (depth >> 3);

+		if (l) {

+			if (unsign && depth != 32) {

+				if (depth == 16) {

+					for (i = 0; i < 8192; i++) {

+						buffer.s8[i*2] = 0x00;

+						buffer.s8[i*2+1] = 0x80;

+					}

+				} else

+					memset(buffer.s8, 0x80, 16384);

+			} else

+				memset(buffer.s8, 0, 16384);

+			while (l >= 16384) {

+				if (outf) fwrite(buffer.s8, 1, 16384, outf);

+				l -= 16384;

+				data_written += 16384;

+			}

+			if (l) {

+				if (outf) fwrite(buffer.s8, 1, l, outf);

+				data_written += 1;

+			}

+		}

+	}

+

+	start = clock();

+

+	fprintf(stderr, "................................................................\n");

+	for (;;) {

+		int write_size;

+		int l;

+		

+		if (depth != 32) {

+			l = duh_render(sr, depth, unsign, volume, delta, bufsize, &buffer);

+			if (depth == 16) {

+				for (i = 0; i < l * n_channels; i++) {

+					short val = buffer.s16[i];

+					buffer.s8[i*2] = val;

+					buffer.s8[i*2+1] = val >> 8;

+				}

+			}

+		} else {

+			int j;

+			dumb_silence(internal_buffer[0], bufsize * n_channels);

+			l = duh_sigrenderer_get_samples(sr, volume, delta, bufsize, internal_buffer);

+			for (i = 0; i < n_channels; i++) {

+				for (j = 0; j < l; j++) {

+					buffer.s32[j * n_channels + i] = (float)((double)internal_buffer[i][j] * (1.0 / (double)(0x800000)));

+				}

+			}

+		}

+		write_size = l * n_channels * (depth >> 3);

+		if (outf) fwrite(buffer.s8, 1, write_size, outf);

+		data_written += write_size;

+		if (l < bufsize) break;

+		done += l;

+		l = done * 64 / length;

+		while (dots < 64 && l > dots) {

+			fprintf(stderr, "|");

+			dots++;

+		}

+			if (dots >= 64) {

+			putchar('\n');

+			dots = 0;

+			done = 0;

+		}

+	}

+

+	while (64 > dots) {

+		fprintf(stderr, "|");

+		dots++;

+	}

+	fprintf(stderr, "\n");

+

+	end = clock();

+

+	if (depth == 32) destroy_sample_buffer(internal_buffer);

+

+	/* fill in blanks we left in WAVE file */

+	if (outf) {

+		/* file size, not including RIFF header */

+		const int fmt_size = 8 + ((depth == 32) ? 18 : 16);

+		const int data_size = 8 + data_written;

+		const int file_size = fmt_size + data_size;

+

+		/* can we seek stdout? */

+		fseek(outf, 4, SEEK_SET);

+		write32_le(outf, file_size);

+

+		fseek(outf, 12 + fmt_size + 4, SEEK_SET);

+		write32_le(outf, data_written);

+	}

+

+

+	duh_end_sigrenderer(sr);

+	unload_duh(duh);

+	if (outf && outf != stdout) fclose(outf);

+

+	fprintf(stderr, "Elapsed time: %f seconds\n", (end - start) / (float)CLOCKS_PER_SEC);

+

+	return 0;

+}

diff --git a/plugins/dumb/dumb-kode54/examples/dumbout.c b/plugins/dumb/dumb-kode54/examples/dumbout.c
new file mode 100644
index 00000000..3082b3b4
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/examples/dumbout.c
@@ -0,0 +1,404 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * dumbout.c - Utility to stream music to a file.     / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <time.h>

+#include <stdlib.h>

+#include <stdio.h>

+#include <ctype.h>

+#include <math.h>

+#include <string.h>

+#include <dumb.h>

+

+#include <internal/it.h>

+

+union {

+	float s32[4096];

+	short s16[8192];

+	char s8[16384];

+} buffer;

+

+sample_t ** internal_buffer;

+

+int main(int argc, const char *const *argv) /* I'm const-crazy! */

+{

+	DUH *duh;

+	DUH_SIGRENDERER *sr;

+

+	const char *fn = NULL;

+	const char *fn_out = NULL;

+	FILE *outf;

+

+	int depth = 16;

+	int bigendian = 0;

+	int unsign = 0;

+	int freq = 44100;

+	int n_channels = 2;

+	int solo = -1;

+	float volume = 1.0f;

+	float delay = 0.0f;

+	float delta;

+	int bufsize;

+	clock_t start, end;

+

+	int i = 1;

+

+	LONG_LONG length;

+	LONG_LONG done;

+	int dots;

+

+	while (i < argc) {

+		const char *arg = argv[i++];

+		if (*arg != '-') {

+			if (fn) {

+				fprintf(stderr,

+					"Cannot specify multiple filenames!\n"

+					"Second filename found: \"%s\"\n", arg);

+				return 1;

+			}

+			fn = arg;

+			continue;

+		}

+		arg++;

+		while (*arg) {

+			char *endptr;

+			switch (*arg++) {

+				case 'o':

+				case 'O':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; output filename expected!\n");

+						return 1;

+					}

+					fn_out = argv[i++];

+					break;

+				case 'd':

+				case 'D':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; delay expected!\n");

+						return 1;

+					}

+					delay = (float)strtod(argv[i++], &endptr);

+					if (*endptr != 0 || delay < 0.0f || delay > 64.0f) {

+						fprintf(stderr, "Invalid delay!\n");

+						return 1;

+					}

+					break;

+				case 'v':

+				case 'V':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; volume expected!\n");

+						return 1;

+					}

+					volume = (float)strtod(argv[i++], &endptr);

+					if (*endptr != 0 || volume < -8.0f || volume > 8.0f) {

+						fprintf(stderr, "Invalid volume!\n");

+						return 1;

+					}

+					break;

+				case 's':

+				case 'S':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; sampling rate expected!\n");

+						return 1;

+					}

+					freq = strtol(argv[i++], &endptr, 10);

+					if (*endptr != 0 || freq < 1 || freq > 960000) {

+						fprintf(stderr, "Invalid sampling rate!\n");

+						return 1;

+					}

+					break;

+				case 'f':

+					depth = 32;

+					break;

+				case '8':

+					depth = 8;

+					break;

+				case 'b':

+				case 'B':

+					bigendian = 1;

+					break;

+				case 'm':

+				case 'M':

+					n_channels = 1;

+					break;

+				case 'u':

+				case 'U':

+					unsign = 1;

+					break;

+				case 'r':

+				case 'R':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; resampling quality expected!\n");

+						return 1;

+					}

+					dumb_resampling_quality = strtol(argv[i++], &endptr, 10);

+					if (*endptr != 0 || dumb_resampling_quality < 0 || dumb_resampling_quality > 2) {

+						fprintf(stderr, "Invalid resampling quality!\n");

+						return 1;

+					}

+					break;

+				case 'c':

+				case 'C':

+					if (i >= argc) {

+						fprintf(stderr, "Out of arguments; channel number expected!\n");

+						return 1;

+					}

+					solo = strtol(argv[i++], &endptr, 10);

+					if (*endptr != 0 || solo < 0 || solo >= DUMB_IT_N_CHANNELS) {

+						fprintf(stderr, "Invalid channel number!\n");

+						return 1;

+					}

+					break;

+				default:

+					fprintf(stderr, "Invalid switch - '%c'!\n", isprint(arg[-1]) ? arg[-1] : '?');

+					return 1;

+			}

+		}

+	}

+

+	if (!fn) {

+		fprintf(stderr,

+			"Usage: dumbout [options] module [more-options]\n"

+			"\n"

+			"The module can be any IT, XM, S3M or MOD file. It will be rendered to a .pcm\n"

+			"file of the same name, unless you specify otherwise with the -o option.\n"

+			"\n"

+			"The valid options are:\n"

+			"-o <file>   specify the output filename (defaults to the input filename with\n"

+			"              the extension replaced with .pcm); use - to write to standard\n"

+			"              output or . to write nowhere (useful for measuring DUMB's\n"

+			"              performance, and DOS and Windows don't have /dev/null!)\n"

+			"-d <delay>  set the initial delay, in seconds (default 0.0)\n"

+			"-v <volume> adjust the volume (default 1.0)\n"

+			"-s <freq>   set the sampling rate in Hz (default 44100)\n"

+			"-8          generate 8-bit instead of 16-bit\n"

+			"-f          generate 32-bit floating point data instead of 16-bit\n"

+			"-b          generate big-endian data instead of little-endian (meaningless when\n"

+			"              using -8)\n"

+			"-m          generate mono output instead of stereo left/right pairs\n"

+			"-u          generated unsigned output instead of signed\n"

+			"-r <value>  specify the resampling quality to use\n"

+			"-c <value>  specify a channel number to solo\n");

+		return 1;

+	}

+

+	atexit(&dumb_exit);

+	dumb_register_stdfiles();

+

+	dumb_it_max_to_mix = 256;

+

+	duh = load_duh(fn);

+	if (!duh) {

+		duh = dumb_load_it(fn);

+		if (!duh) {

+			duh = dumb_load_xm(fn);

+			if (!duh) {

+				duh = dumb_load_s3m(fn);

+				if (!duh) {

+					duh = dumb_load_mod(fn);

+					if (!duh) {

+						fprintf(stderr, "Unable to open %s!\n", fn);

+						return 1;

+					}

+				}

+			}

+		}

+	}

+

+	sr = duh_start_sigrenderer(duh, 0, n_channels, 0);

+	if (!sr) {

+		unload_duh(duh);

+		fprintf(stderr, "Unable to play file!\n");

+		return 1;

+	}

+

+	if (solo >= 0) {

+		DUMB_IT_SIGRENDERER * itsr = duh_get_it_sigrenderer(sr);

+		if (itsr) {

+			for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+				if (i != solo) {

+					IT_CHANNEL * channel = &itsr->channel[i];

+					IT_PLAYING * playing = channel->playing;

+					channel->flags |= IT_CHANNEL_MUTED;

+					/* start_sigrenderer leaves me all of the channels the first tick triggered */

+					if (playing) {

+						playing->ramp_volume[0] = 0;

+						playing->ramp_volume[1] = 0;

+						playing->ramp_delta[0] = 0;

+						playing->ramp_delta[1] = 0;

+					}

+				}

+			}

+		}

+	}

+

+	if (fn_out) {

+		if (fn_out[0] == '-' && fn_out[1] == 0)

+			outf = stdout;

+		else if (fn_out[0] == '.' && fn_out[1] == 0)

+			outf = NULL;

+		else {

+			outf = fopen(fn_out, "wb");

+			if (!outf) {

+				fprintf(stderr, "Unable to open %s for writing!\n", fn_out);

+				duh_end_sigrenderer(sr);

+				unload_duh(duh);

+				return 1;

+			}

+		}

+	} else {

+		char *extptr = NULL, *p;

+		char *fn_out = malloc(strlen(fn)+5);

+		if (!fn_out) {

+			fprintf(stderr, "Out of memory!\n");

+			duh_end_sigrenderer(sr);

+			unload_duh(duh);

+			return 1;

+		}

+		strcpy(fn_out, fn);

+		for (p = fn_out; *p; p++)

+			if (*p == '.') extptr = p;

+		if (!extptr) extptr = p;

+		strcpy(extptr, ".pcm");

+		outf = fopen(fn_out, "wb");

+		if (!outf) {

+			fprintf(stderr, "Unable to open %s for writing!\n", fn_out);

+			free(fn_out);

+			duh_end_sigrenderer(sr);

+			unload_duh(duh);

+			return 1;

+		}

+		free(fn_out);

+	}

+

+	{

+		DUMB_IT_SIGRENDERER *itsr = duh_get_it_sigrenderer(sr);

+		dumb_it_set_ramp_style(itsr, 2);

+		dumb_it_set_loop_callback(itsr, &dumb_it_callback_terminate, NULL);

+		dumb_it_set_xm_speed_zero_callback(itsr, &dumb_it_callback_terminate, NULL);

+		dumb_it_set_global_volume_zero_callback(itsr, &dumb_it_callback_terminate, NULL);

+	}

+

+	length = (LONG_LONG)_dumb_it_build_checkpoints(duh_get_it_sigdata(duh), 0) * freq >> 16;

+	done = 0;

+	dots = 0;

+	delta = 65536.0f / freq;

+	bufsize = sizeof(buffer);

+	if (depth == 32) bufsize /= sizeof(*buffer.s32);

+	else if (depth == 16) bufsize /= sizeof(*buffer.s16);

+	bufsize /= n_channels;

+

+	if (depth == 32) {

+		internal_buffer = create_sample_buffer(n_channels, bufsize);

+		if (!internal_buffer) {

+			fprintf(stderr, "Out of memory!\n");

+			duh_end_sigrenderer(sr);

+			unload_duh(duh);

+		}

+	}

+

+	{

+		long l = (long)floor(delay * freq + 0.5f);

+		l *= n_channels * (depth >> 3);

+		if (l) {

+			if (unsign && depth != 32) {

+				if (depth == 16) {

+					if (bigendian) {

+						for (i = 0; i < 8192; i++) {

+							buffer.s8[i*2] = 0x80;

+							buffer.s8[i*2+1] = 0x00;

+						}

+					} else {

+						for (i = 0; i < 8192; i++) {

+							buffer.s8[i*2] = 0x00;

+							buffer.s8[i*2+1] = 0x80;

+						}

+					}

+				} else

+					memset(buffer.s8, 0x80, 16384);

+			} else

+				memset(buffer.s8, 0, 16384);

+			while (l >= 16384) {

+				if (outf) fwrite(buffer.s8, 1, 16384, outf);

+				l -= 16384;

+			}

+			if (l && outf) fwrite(buffer.s8, 1, l, outf);

+		}

+	}

+

+	start = clock();

+

+	fprintf(stderr, "................................................................\n");

+	for (;;) {

+		int l;

+		

+		if (depth != 32) {

+			l = duh_render(sr, depth, unsign, volume, delta, bufsize, &buffer);

+			if (depth == 16) {

+				if (bigendian) {

+					for (i = 0; i < l * n_channels; i++) {

+						short val = buffer.s16[i];

+						buffer.s8[i*2] = val >> 8;

+						buffer.s8[i*2+1] = val;

+					}

+				} else {

+					for (i = 0; i < l * n_channels; i++) {

+						short val = buffer.s16[i];

+						buffer.s8[i*2] = val;

+						buffer.s8[i*2+1] = val >> 8;

+					}

+				}

+			}

+		} else {

+			int j;

+			dumb_silence(internal_buffer[0], bufsize * n_channels);

+			l = duh_sigrenderer_get_samples(sr, volume, delta, bufsize, internal_buffer);

+			for (i = 0; i < n_channels; i++) {

+				for (j = i; j < l; j++) {

+					buffer.s32[j * n_channels] = (float)((double)internal_buffer[i][j] * (1.0 / (double)(0x800000)));

+				}

+			}

+		}

+		if (outf) fwrite(buffer.s8, 1, l * n_channels * (depth >> 3), outf);

+		if (l < bufsize) break;

+		done += l;

+		l = done * 64 / length;

+		while (dots < 64 && l > dots) {

+			fprintf(stderr, "|");

+			dots++;

+		}

+	}

+

+	while (64 > dots) {

+		fprintf(stderr, "|");

+		dots++;

+	}

+	fprintf(stderr, "\n");

+

+	end = clock();

+

+	if (depth == 32) destroy_sample_buffer(internal_buffer);

+

+	duh_end_sigrenderer(sr);

+	unload_duh(duh);

+	if (outf && outf != stdout) fclose(outf);

+

+	fprintf(stderr, "Elapsed time: %f seconds\n", (end - start) / (float)CLOCKS_PER_SEC);

+

+	return 0;

+}

diff --git a/plugins/dumb/dumb-kode54/examples/dumbplay.c b/plugins/dumb/dumb-kode54/examples/dumbplay.c
new file mode 100644
index 00000000..521113f6
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/examples/dumbplay.c
@@ -0,0 +1,238 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * dumbplay.c - Not-so-simple program to play         / / \  \

+ *              music. It used to be simpler!        | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ * IMPORTANT NOTE: This file is not very friendly.      |  ' /

+ * I strongly recommend AGAINST using it as a            \__/

+ * reference for writing your own code. If you would

+ * like to write a program that uses DUMB, or add DUMB to an existing

+ * project, please use docs/howto.txt. It will help you a lot more than this

+ * file can. (If you have difficulty reading documentation, you are lacking

+ * an important coding skill, and now is as good a time as any to learn.)

+ */

+

+#include <stdlib.h>

+#include <allegro.h>

+

+#ifndef ALLEGRO_DOS

+#include <string.h>

+#endif

+

+/* Note that your own programs should use <aldumb.h> not "aldumb.h". <> tells

+ * the compiler to look in the compiler's default header directory, which is

+ * where DUMB should be installed before you use it (make install does this).

+ * Use "" when it is your own header file. This example uses "" because DUMB

+ * might not have been installed yet when the makefile builds it.

+ */

+#include "aldumb.h"

+

+

+

+#ifndef ALLEGRO_DOS

+static volatile int closed = 0;

+static void closehook(void) { closed = 1; }

+#else

+#define closed 0

+#endif

+

+#ifdef ALLEGRO_WINDOWS

+#define GFX_DUMB_MODE GFX_GDI

+#include <winalleg.h>

+#define YIELD() Sleep(1)

+#else

+#define GFX_DUMB_MODE GFX_AUTODETECT_WINDOWED

+#ifdef ALLEGRO_UNIX

+#include <sys/time.h>

+static void YIELD(void)

+{

+	struct timeval tv;

+	tv.tv_sec = 0;

+	tv.tv_usec = 1;

+	select(0, NULL, NULL, NULL, &tv);

+}

+#else

+#define YIELD() yield_timeslice()

+#endif

+#endif

+

+

+

+#ifdef ALLEGRO_DOS

+static int loop_callback(void *data)

+{

+	(void)data;

+	printf("Music has looped.\n");

+	return 0;

+}

+

+static int xm_speed_zero_callback(void *data)

+{

+	(void)data;

+	printf("Music has stopped.\n");

+	return 0;

+}

+#else

+static int gfx_half_width;

+

+static int loop_callback(void *data)

+{

+	(void)data;

+	if (gfx_half_width) {

+		acquire_screen();

+		textout_centre(screen, font, "Music has looped.", gfx_half_width, 36, 10);

+		release_screen();

+	}

+	return 0;

+}

+

+static int xm_speed_zero_callback(void *data)

+{

+	(void)data;

+	if (gfx_half_width) {

+		text_mode(0); /* In case this is overwriting "Music has looped." */

+		acquire_screen();

+		textout_centre(screen, font, "Music has stopped.", gfx_half_width, 36, 10);

+		release_screen();

+	}

+	return 0;

+}

+#endif

+

+

+

+static void usage(const char *exename)

+{

+	allegro_message(

+#ifdef ALLEGRO_WINDOWS

+		"Usage:\n"

+		"  At the command line: %s file\n"

+		"  In Windows Explorer: drag a file on to this program's icon.\n"

+#else

+		"Usage: %s file\n"

+#endif

+		"This will play the music file specified.\n"

+		"File formats supported: IT XM S3M MOD.\n"

+		"You can control playback quality by editing dumb.ini.\n", exename);

+

+	exit(1);

+}

+

+

+

+int main(int argc, const char *const *argv) /* I'm const-crazy! */

+{

+	DUH *duh;

+	AL_DUH_PLAYER *dp;

+

+	if (allegro_init())

+		return 1;

+

+	if (argc != 2)

+		usage(argv[0]);

+

+	set_config_file("dumb.ini");

+

+	if (install_keyboard()) {

+		allegro_message("Failed to initialise keyboard driver!\n");

+		return 1;

+	}

+

+	set_volume_per_voice(0);

+

+	if (install_sound(DIGI_AUTODETECT, MIDI_NONE, NULL)) {

+		allegro_message("Failed to initialise sound driver!\n%s\n", allegro_error);

+		return 1;

+	}

+

+	atexit(&dumb_exit);

+

+	dumb_register_packfiles();

+

+	duh = dumb_load_it(argv[1]);

+	if (!duh) {

+		duh = dumb_load_xm(argv[1]);

+		if (!duh) {

+			duh = dumb_load_s3m(argv[1]);

+			if (!duh) {

+				duh = dumb_load_mod(argv[1]);

+				if (!duh) {

+					allegro_message("Failed to load %s!\n", argv[1]);

+					return 1;

+				}

+			}

+		}

+	}

+

+	dumb_resampling_quality = get_config_int("sound", "dumb_resampling_quality", 4);

+	dumb_it_max_to_mix = get_config_int("sound", "dumb_it_max_to_mix", 128);

+

+#ifndef ALLEGRO_DOS

+	{

+		const char *fn = get_filename(argv[1]);

+		gfx_half_width = strlen(fn);

+		if (gfx_half_width < 22) gfx_half_width = 22;

+		gfx_half_width = (gfx_half_width + 2) * 4;

+

+		/* set_window_title() is not const-correct (yet). */

+		set_window_title((char *)"DUMB Music Player");

+

+		if (set_gfx_mode(GFX_DUMB_MODE, gfx_half_width*2, 80, 0, 0) == 0) {

+			acquire_screen();

+			textout_centre(screen, font, fn, gfx_half_width, 20, 14);

+			textout_centre(screen, font, "Press any key to exit.", gfx_half_width, 52, 11);

+			release_screen();

+		} else

+			gfx_half_width = 0;

+	}

+

+#if ALLEGRO_VERSION*10000 + ALLEGRO_SUB_VERSION*100 + ALLEGRO_WIP_VERSION >= 40105

+	set_close_button_callback(&closehook);

+#else

+	set_window_close_hook(&closehook);

+#endif

+

+#endif

+

+	set_display_switch_mode(SWITCH_BACKGROUND);

+

+	dp = al_start_duh(duh, 2, 0, 1.0f,

+		get_config_int("sound", "buffer_size", 4096),

+		get_config_int("sound", "sound_freq", 44100));

+

+	{

+		DUH_SIGRENDERER *sr = al_duh_get_sigrenderer(dp);

+		DUMB_IT_SIGRENDERER *itsr = duh_get_it_sigrenderer(sr);

+		dumb_it_set_loop_callback(itsr, &loop_callback, NULL);

+		dumb_it_set_xm_speed_zero_callback(itsr, &xm_speed_zero_callback, NULL);

+	}

+

+	for (;;) {

+		if (keypressed()) {

+			readkey();

+			break;

+		}

+

+		if (al_poll_duh(dp) || closed)

+			break;

+

+		YIELD();

+	}

+

+	al_stop_duh(dp);

+

+	unload_duh(duh);

+

+	return 0;

+}

+END_OF_MAIN();

diff --git a/plugins/dumb/dumb-kode54/examples/playduh.c b/plugins/dumb/dumb-kode54/examples/playduh.c
new file mode 100644
index 00000000..31d7b619
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/examples/playduh.c
@@ -0,0 +1,169 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * playduh.c - Simple program to play DUH files.      / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <allegro.h>

+

+#ifndef ALLEGRO_DOS

+#include <string.h>

+#endif

+

+/* Note that your own programs should use <aldumb.h> not "aldumb.h". <> tells

+ * the compiler to look in the compiler's default header directory, which is

+ * where DUMB should be installed before you use it (make install does this).

+ * Use "" when it is your own header file. This example uses "" because DUMB

+ * might not have been installed yet when the makefile builds it.

+ */

+#include "aldumb.h"

+

+

+

+#ifndef ALLEGRO_DOS

+static int closed = 0;

+static void closehook(void) { closed = 1; }

+#else

+#define closed 0

+#endif

+

+#ifdef ALLEGRO_WINDOWS

+#define GFX_DUMB_MODE GFX_GDI

+#include <winalleg.h>

+#define YIELD() Sleep(1)

+#else

+#define GFX_DUMB_MODE GFX_AUTODETECT_WINDOWED

+#ifdef ALLEGRO_UNIX

+#include <sys/time.h>

+static void YIELD(void)

+{

+	struct timeval tv;

+	tv.tv_sec = 0;

+	tv.tv_usec = 1;

+	select(0, NULL, NULL, NULL, &tv);

+}

+#else

+#define YIELD() yield_timeslice()

+#endif

+#endif

+

+

+

+static void usage(void)

+{

+	allegro_message(

+		"Usage: playduh file.duh\n"

+		"This will play the .duh file specified.\n"

+		"You can control playback quality by editing dumb.ini.\n"

+	);

+

+	exit(1);

+}

+

+

+

+int main(int argc, char *argv[])

+{

+	DUH *duh;

+	AL_DUH_PLAYER *dp;

+

+	if (allegro_init())

+		return 1;

+

+	if (argc != 2)

+		usage();

+

+	set_config_file("dumb.ini");

+

+	if (install_keyboard()) {

+		allegro_message("Failed to initialise keyboard driver!\n");

+		return 1;

+	}

+

+	set_volume_per_voice(0);

+

+	if (install_sound(DIGI_AUTODETECT, MIDI_NONE, NULL)) {

+		allegro_message("Failed to initialise sound driver!\n%s\n", allegro_error);

+		return 1;

+	}

+

+	atexit(&dumb_exit);

+

+	dumb_register_stdfiles();

+

+/*

+	dumb_register_sigtype_sample();

+	dumb_register_sigtype_combining();

+	dumb_register_sigtype_stereopan();

+	dumb_register_sigtype_sequence();

+*/

+

+	duh = load_duh(argv[1]);

+	if (!duh) {

+		allegro_message("Failed to load %s!\n", argv[1]);

+		return 1;

+	}

+

+	dumb_resampling_quality = get_config_int("sound", "dumb_resampling_quality", 4);

+	// Are we sure dumb_it_max_to_mix will be unused? Can decide when editor matures...

+

+#ifndef ALLEGRO_DOS

+	{

+		const char *fn = get_filename(argv[1]);

+		int w = strlen(fn);

+		if (w < 22) w = 22;

+		w = (w + 2) * 4;

+

+		set_window_title("DUMB - IT player");

+

+		if (set_gfx_mode(GFX_DUMB_MODE, w*2, 80, 0, 0) == 0) {

+			acquire_screen();

+			textout_centre(screen, font, fn, w, 28, 14);

+			textout_centre(screen, font, "Press any key to exit.", w, 44, 11);

+			release_screen();

+		}

+	}

+

+	//set_window_close_hook(&closehook);

+#endif

+

+	set_display_switch_mode(SWITCH_BACKGROUND);

+

+	dp = al_start_duh(duh, 2, 0, 1.0,

+		get_config_int("sound", "buffer_size", 4096),

+		get_config_int("sound", "sound_freq", 44100));

+

+	for (;;) {

+		if (keypressed()) {

+			readkey();

+			break;

+		}

+

+		if (al_poll_duh(dp) || closed)

+			break;

+

+		YIELD();

+	}

+

+	al_stop_duh(dp);

+

+	unload_duh(duh);

+

+	return 0;

+}

+END_OF_MAIN();

+

diff --git a/plugins/dumb/dumb-kode54/include/Makefile.am b/plugins/dumb/dumb-kode54/include/Makefile.am
new file mode 100644
index 00000000..6f552820
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/include/Makefile.am
@@ -0,0 +1,4 @@
+SUBDIRS = internal

+

+# XXX include the allegro headers too

+include_HEADERS = dumb.h

diff --git a/plugins/dumb/dumb-kode54/include/aldumb.h b/plugins/dumb/dumb-kode54/include/aldumb.h
new file mode 100644
index 00000000..015ff946
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/include/aldumb.h
@@ -0,0 +1,94 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * aldumb.h - The user header file for DUMB with      / / \  \

+ *            Allegro.                               | <  /   \_

+ *                                                   |  \/ /\   /

+ * Include this file if you wish to use DUMB          \_  /  > /

+ * with Allegro. It will include dumb.h for you,        | \ / /

+ * and provide extra functionality such as audio        |  ' /

+ * stream and datafile integration.                      \__/

+ */

+

+#ifndef ALDUMB_H

+#define ALDUMB_H

+

+

+#include <allegro.h>

+

+#include "dumb.h"

+

+

+#ifdef __cplusplus

+	extern "C" {

+#endif

+

+

+/* Packfile Support */

+

+void dumb_register_packfiles(void);

+

+DUMBFILE *dumbfile_open_packfile(PACKFILE *p);

+DUMBFILE *dumbfile_from_packfile(PACKFILE *p);

+

+

+/* Datafile Registration Functions */

+

+#define DUMB_DAT_DUH DAT_ID('D','U','H',' ')

+#define DUMB_DAT_IT  DAT_ID('I','T',' ',' ')

+#define DUMB_DAT_XM  DAT_ID('X','M',' ',' ')

+#define DUMB_DAT_S3M DAT_ID('S','3','M',' ')

+#define DUMB_DAT_MOD DAT_ID('M','O','D',' ')

+

+void dumb_register_dat_duh(long type);

+void dumb_register_dat_it(long type);

+void dumb_register_dat_xm(long type);

+void dumb_register_dat_s3m(long type);

+void dumb_register_dat_mod(long type);

+

+

+/* DUH Playing Functions */

+

+typedef struct AL_DUH_PLAYER AL_DUH_PLAYER;

+

+AL_DUH_PLAYER *al_start_duh(DUH *duh, int n_channels, long pos, float volume, long bufsize, int freq);

+void al_stop_duh(AL_DUH_PLAYER *dp);

+void al_pause_duh(AL_DUH_PLAYER *dp);

+void al_resume_duh(AL_DUH_PLAYER *dp);

+void al_duh_set_priority(AL_DUH_PLAYER *dp, int priority);

+void al_duh_set_volume(AL_DUH_PLAYER *dp, float volume);

+float al_duh_get_volume(AL_DUH_PLAYER *dp);

+int al_poll_duh(AL_DUH_PLAYER *dp);

+long al_duh_get_position(AL_DUH_PLAYER *dp);

+

+AL_DUH_PLAYER *al_duh_encapsulate_sigrenderer(DUH_SIGRENDERER *sigrenderer, float volume, long bufsize, int freq);

+DUH_SIGRENDERER *al_duh_get_sigrenderer(AL_DUH_PLAYER *dp);

+

+/* IMPORTANT: This function will return NULL if the music has ended. */

+DUH_SIGRENDERER *al_duh_decompose_to_sigrenderer(AL_DUH_PLAYER *dp);

+

+#ifdef DUMB_DECLARE_DEPRECATED

+

+AL_DUH_PLAYER *al_duh_encapsulate_renderer(DUH_SIGRENDERER *dr, float volume, long bufsize, int freq) DUMB_DEPRECATED;

+DUH_SIGRENDERER *al_duh_get_renderer(AL_DUH_PLAYER *dp) DUMB_DEPRECATED;

+DUH_SIGRENDERER *al_duh_decompose_to_renderer(AL_DUH_PLAYER *dp) DUMB_DEPRECATED;

+/* Replace 'renderer' with 'sigrenderer' in each case where you called one of

+ * these functions.

+ */

+

+#endif

+

+

+#ifdef __cplusplus

+	}

+#endif

+

+

+#endif /* ALDUMB_H */

diff --git a/plugins/dumb/dumb-kode54/include/dumb.h b/plugins/dumb/dumb-kode54/include/dumb.h
new file mode 100644
index 00000000..63718e1e
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/include/dumb.h
@@ -0,0 +1,744 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * dumb.h - The user header file for DUMB.            / / \  \

+ *                                                   | <  /   \_

+ * Include this file in any of your files in         |  \/ /\   /

+ * which you wish to use the DUMB functions           \_  /  > /

+ * and variables.                                       | \ / /

+ *                                                      |  ' /

+ * Allegro users, you will probably want aldumb.h.       \__/

+ */

+

+#ifndef DUMB_H

+#define DUMB_H

+

+

+#include <stdlib.h>

+#include <stdio.h>

+

+#ifdef _DEBUG

+#define _CRTDBG_MAP_ALLOC

+#include <crtdbg.h>

+#endif

+

+#ifdef __cplusplus

+	extern "C" {

+#endif

+

+

+#define DUMB_MAJOR_VERSION    0

+#define DUMB_MINOR_VERSION    9

+#define DUMB_REVISION_VERSION 3

+

+#define DUMB_VERSION (DUMB_MAJOR_VERSION*10000 + DUMB_MINOR_VERSION*100 + DUMB_REVISION_VERSION)

+

+#define DUMB_VERSION_STR "0.9.3"

+

+#define DUMB_NAME "DUMB v"DUMB_VERSION_STR

+

+#define DUMB_YEAR  2005

+#define DUMB_MONTH 8

+#define DUMB_DAY   7

+

+#define DUMB_YEAR_STR2  "05"

+#define DUMB_YEAR_STR4  "2005"

+#define DUMB_MONTH_STR1 "8"

+#define DUMB_DAY_STR1   "7"

+

+#if DUMB_MONTH < 10

+#define DUMB_MONTH_STR2 "0"DUMB_MONTH_STR1

+#else

+#define DUMB_MONTH_STR2 DUMB_MONTH_STR1

+#endif

+

+#if DUMB_DAY < 10

+#define DUMB_DAY_STR2 "0"DUMB_DAY_STR1

+#else

+#define DUMB_DAY_STR2 DUMB_DAY_STR1

+#endif

+

+

+/* WARNING: The month and day were inadvertently swapped in the v0.8 release.

+ *          Please do not compare this constant against any date in 2002. In

+ *          any case, DUMB_VERSION is probably more useful for this purpose.

+ */

+#define DUMB_DATE (DUMB_YEAR*10000 + DUMB_MONTH*100 + DUMB_DAY)

+

+#define DUMB_DATE_STR DUMB_DAY_STR1"."DUMB_MONTH_STR1"."DUMB_YEAR_STR4

+

+

+#undef MIN

+#undef MAX

+#undef MID

+

+#define MIN(x,y)   (((x) < (y)) ? (x) : (y))

+#define MAX(x,y)   (((x) > (y)) ? (x) : (y))

+#define MID(x,y,z) MAX((x), MIN((y), (z)))

+

+#undef ABS

+#define ABS(x) (((x) >= 0) ? (x) : (-(x)))

+

+

+#ifdef DEBUGMODE

+

+#ifndef ASSERT

+#include <assert.h>

+#define ASSERT(n) assert(n)

+#endif

+#ifndef TRACE

+// it would be nice if this did actually trace ...

+#define TRACE 1 ? (void)0 : (void)printf

+#endif

+

+#else

+

+#ifndef ASSERT

+#define ASSERT(n)

+#endif

+#ifndef TRACE

+#define TRACE 1 ? (void)0 : (void)printf

+#endif

+

+#endif

+

+

+#define DUMB_ID(a,b,c,d) (((unsigned int)(a) << 24) | \

+                          ((unsigned int)(b) << 16) | \

+                          ((unsigned int)(c) <<  8) | \

+                          ((unsigned int)(d)      ))

+

+

+

+#ifndef LONG_LONG

+#if defined __GNUC__ || defined __INTEL_COMPILER || defined __MWERKS__

+#define LONG_LONG long long

+#elif defined _MSC_VER || defined __WATCOMC__

+#define LONG_LONG __int64

+#elif defined __sgi

+#define LONG_LONG long long

+#else

+#error 64-bit integer type unknown

+#endif

+#endif

+

+#if __GNUC__ * 100 + __GNUC_MINOR__ >= 301 /* GCC 3.1+ */

+#ifndef DUMB_DECLARE_DEPRECATED

+#define DUMB_DECLARE_DEPRECATED

+#endif

+#define DUMB_DEPRECATED __attribute__((__deprecated__))

+#else

+#define DUMB_DEPRECATED

+#endif

+

+

+/* Basic Sample Type. Normal range is -0x800000 to 0x7FFFFF. */

+

+typedef int sample_t;

+

+

+/* Library Clean-up Management */

+

+int dumb_atexit(void (*proc)(void));

+

+void dumb_exit(void);

+

+

+/* File Input Functions */

+

+typedef struct DUMBFILE_SYSTEM

+{

+	void *(*open)(const char *filename);

+	int (*skip)(void *f, long n);

+	int (*getc)(void *f);

+	long (*getnc)(char *ptr, long n, void *f);

+	void (*close)(void *f);

+}

+DUMBFILE_SYSTEM;

+

+typedef struct DUMBFILE DUMBFILE;

+

+void register_dumbfile_system(DUMBFILE_SYSTEM *dfs);

+

+DUMBFILE *dumbfile_open(const char *filename);

+DUMBFILE *dumbfile_open_ex(void *file, DUMBFILE_SYSTEM *dfs);

+

+long dumbfile_pos(DUMBFILE *f);

+int dumbfile_skip(DUMBFILE *f, long n);

+

+int dumbfile_getc(DUMBFILE *f);

+

+int dumbfile_igetw(DUMBFILE *f);

+int dumbfile_mgetw(DUMBFILE *f);

+

+long dumbfile_igetl(DUMBFILE *f);

+long dumbfile_mgetl(DUMBFILE *f);

+

+unsigned long dumbfile_cgetul(DUMBFILE *f);

+signed long dumbfile_cgetsl(DUMBFILE *f);

+

+long dumbfile_getnc(char *ptr, long n, DUMBFILE *f);

+

+int dumbfile_error(DUMBFILE *f);

+int dumbfile_close(DUMBFILE *f);

+

+

+/* stdio File Input Module */

+

+void dumb_register_stdfiles(void);

+

+DUMBFILE *dumbfile_open_stdfile(FILE *p);

+

+

+/* Memory File Input Module */

+

+DUMBFILE *dumbfile_open_memory(const char *data, long size);

+

+

+/* DUH Management */

+

+typedef struct DUH DUH;

+

+#define DUH_SIGNATURE DUMB_ID('D','U','H','!')

+

+void unload_duh(DUH *duh);

+

+DUH *load_duh(const char *filename);

+DUH *read_duh(DUMBFILE *f);

+

+long duh_get_length(DUH *duh);

+

+const char *duh_get_tag(DUH *duh, const char *key);

+

+

+/* Signal Rendering Functions */

+

+typedef struct DUH_SIGRENDERER DUH_SIGRENDERER;

+

+DUH_SIGRENDERER *duh_start_sigrenderer(DUH *duh, int sig, int n_channels, long pos);

+

+#ifdef DUMB_DECLARE_DEPRECATED

+typedef void (*DUH_SIGRENDERER_CALLBACK)(void *data, sample_t **samples, int n_channels, long length);

+/* This is deprecated, but is not marked as such because GCC tends to

+ * complain spuriously when the typedef is used later. See comments below.

+ */

+

+void duh_sigrenderer_set_callback(

+	DUH_SIGRENDERER *sigrenderer,

+	DUH_SIGRENDERER_CALLBACK callback, void *data

+) DUMB_DEPRECATED;

+/* The 'callback' argument's type has changed for const-correctness. See the

+ * DUH_SIGRENDERER_CALLBACK definition just above. Also note that the samples

+ * in the buffer are now 256 times as large; the normal range is -0x800000 to

+ * 0x7FFFFF. The function has been renamed partly because its functionality

+ * has changed slightly and partly so that its name is more meaningful. The

+ * new one is duh_sigrenderer_set_analyser_callback(), and the typedef for

+ * the function pointer has also changed, from DUH_SIGRENDERER_CALLBACK to

+ * DUH_SIGRENDERER_ANALYSER_CALLBACK. (If you wanted to use this callback to

+ * apply a DSP effect, don't worry; there is a better way of doing this. It

+ * is undocumented, so contact me and I shall try to help. Contact details

+ * are in readme.txt.)

+ */

+

+typedef void (*DUH_SIGRENDERER_ANALYSER_CALLBACK)(void *data, const sample_t *const *samples, int n_channels, long length);

+/* This is deprecated, but is not marked as such because GCC tends to

+ * complain spuriously when the typedef is used later. See comments below.

+ */

+

+void duh_sigrenderer_set_analyser_callback(

+	DUH_SIGRENDERER *sigrenderer,

+	DUH_SIGRENDERER_ANALYSER_CALLBACK callback, void *data

+) DUMB_DEPRECATED;

+/* This is deprecated because the meaning of the 'samples' parameter in the

+ * callback needed to change. For stereo applications, the array used to be

+ * indexed with samples[channel][pos]. It is now indexed with

+ * samples[0][pos*2+channel]. Mono sample data are still indexed with

+ * samples[0][pos]. The array is still 2D because samples will probably only

+ * ever be interleaved in twos. In order to fix your code, adapt it to the

+ * new sample layout and then call

+ * duh_sigrenderer_set_sample_analyser_callback below instead of this

+ * function.

+ */

+#endif

+

+typedef void (*DUH_SIGRENDERER_SAMPLE_ANALYSER_CALLBACK)(void *data, const sample_t *const *samples, int n_channels, long length);

+

+void duh_sigrenderer_set_sample_analyser_callback(

+	DUH_SIGRENDERER *sigrenderer,

+	DUH_SIGRENDERER_SAMPLE_ANALYSER_CALLBACK callback, void *data

+);

+

+int duh_sigrenderer_get_n_channels(DUH_SIGRENDERER *sigrenderer);

+long duh_sigrenderer_get_position(DUH_SIGRENDERER *sigrenderer);

+

+void duh_sigrenderer_set_sigparam(DUH_SIGRENDERER *sigrenderer, unsigned char id, long value);

+

+#ifdef DUMB_DECLARE_DEPRECATED

+long duh_sigrenderer_get_samples(

+	DUH_SIGRENDERER *sigrenderer,

+	float volume, float delta,

+	long size, sample_t **samples

+) DUMB_DEPRECATED;

+/* The sample format has changed, so if you were using this function,

+ * you should switch to duh_sigrenderer_generate_samples() and change

+ * how you interpret the samples array. See the comments for

+ * duh_sigrenderer_set_analyser_callback().

+ */

+#endif

+

+long duh_sigrenderer_generate_samples(

+	DUH_SIGRENDERER *sigrenderer,

+	float volume, float delta,

+	long size, sample_t **samples

+);

+

+void duh_sigrenderer_get_current_sample(DUH_SIGRENDERER *sigrenderer, float volume, sample_t *samples);

+

+void duh_end_sigrenderer(DUH_SIGRENDERER *sigrenderer);

+

+

+/* DUH Rendering Functions */

+

+long duh_render(

+	DUH_SIGRENDERER *sigrenderer,

+	int bits, int unsign,

+	float volume, float delta,

+	long size, void *sptr

+);

+

+#ifdef DUMB_DECLARE_DEPRECATED

+

+long duh_render_signal(

+	DUH_SIGRENDERER *sigrenderer,

+	float volume, float delta,

+	long size, sample_t **samples

+) DUMB_DEPRECATED;

+/* Please use duh_sigrenderer_generate_samples(), and see the

+ * comments for the deprecated duh_sigrenderer_get_samples() too.

+ */

+

+typedef DUH_SIGRENDERER DUH_RENDERER DUMB_DEPRECATED;

+/* Please use DUH_SIGRENDERER instead of DUH_RENDERER. */

+

+DUH_SIGRENDERER *duh_start_renderer(DUH *duh, int n_channels, long pos) DUMB_DEPRECATED;

+/* Please use duh_start_sigrenderer() instead. Pass 0 for 'sig'. */

+

+int duh_renderer_get_n_channels(DUH_SIGRENDERER *dr) DUMB_DEPRECATED;

+long duh_renderer_get_position(DUH_SIGRENDERER *dr) DUMB_DEPRECATED;

+/* Please use the duh_sigrenderer_*() equivalents of these two functions. */

+

+void duh_end_renderer(DUH_SIGRENDERER *dr) DUMB_DEPRECATED;

+/* Please use duh_end_sigrenderer() instead. */

+

+DUH_SIGRENDERER *duh_renderer_encapsulate_sigrenderer(DUH_SIGRENDERER *sigrenderer) DUMB_DEPRECATED;

+DUH_SIGRENDERER *duh_renderer_get_sigrenderer(DUH_SIGRENDERER *dr) DUMB_DEPRECATED;

+DUH_SIGRENDERER *duh_renderer_decompose_to_sigrenderer(DUH_SIGRENDERER *dr) DUMB_DEPRECATED;

+/* These functions have become no-ops that just return the parameter.

+ * So, for instance, replace

+ *   duh_renderer_encapsulate_sigrenderer(my_sigrenderer)

+ * with

+ *   my_sigrenderer

+ */

+

+#endif

+

+

+/* Impulse Tracker Support */

+

+extern int dumb_it_max_to_mix;

+

+typedef struct DUMB_IT_SIGDATA DUMB_IT_SIGDATA;

+typedef struct DUMB_IT_SIGRENDERER DUMB_IT_SIGRENDERER;

+

+DUMB_IT_SIGDATA *duh_get_it_sigdata(DUH *duh);

+DUH_SIGRENDERER *duh_encapsulate_it_sigrenderer(DUMB_IT_SIGRENDERER *it_sigrenderer, int n_channels, long pos);

+DUMB_IT_SIGRENDERER *duh_get_it_sigrenderer(DUH_SIGRENDERER *sigrenderer);

+

+int dumb_it_trim_silent_patterns(DUH * duh);

+

+typedef int (*dumb_scan_callback)(void *, int, long);

+int dumb_it_scan_for_playable_orders(DUMB_IT_SIGDATA *sigdata, dumb_scan_callback callback, void * callback_data);

+

+DUH_SIGRENDERER *dumb_it_start_at_order(DUH *duh, int n_channels, int startorder);

+

+void dumb_it_set_resampling_quality(DUMB_IT_SIGRENDERER * sigrenderer, int quality);

+

+void dumb_it_set_ramp_style(DUMB_IT_SIGRENDERER * sigrenderer, int ramp_style);

+

+void dumb_it_set_loop_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data), void *data);

+void dumb_it_set_xm_speed_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data), void *data);

+void dumb_it_set_midi_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data, int channel, unsigned char midi_byte), void *data);

+void dumb_it_set_global_volume_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data), void *data);

+

+int dumb_it_callback_terminate(void *data);

+int dumb_it_callback_midi_block(void *data, int channel, unsigned char midi_byte);

+

+DUH *dumb_load_it(const char *filename);

+DUH *dumb_load_xm(const char *filename);

+DUH *dumb_load_s3m(const char *filename);

+DUH *dumb_load_stm(const char *filename);

+DUH *dumb_load_mod(const char *filename, int restr);

+DUH *dumb_load_ptm(const char *filename);

+DUH *dumb_load_669(const char *filename);

+DUH *dumb_load_psm(const char *filename, int subsong);

+DUH *dumb_load_old_psm(const char * filename);

+DUH *dumb_load_mtm(const char *filename);

+DUH *dumb_load_riff(const char *filename);

+DUH *dumb_load_asy(const char *filename);

+

+DUH *dumb_read_it(DUMBFILE *f);

+DUH *dumb_read_xm(DUMBFILE *f);

+DUH *dumb_read_s3m(DUMBFILE *f);

+DUH *dumb_read_stm(DUMBFILE *f);

+DUH *dumb_read_mod(DUMBFILE *f, int restr);

+DUH *dumb_read_ptm(DUMBFILE *f);

+DUH *dumb_read_669(DUMBFILE *f);

+DUH *dumb_read_psm(DUMBFILE *f, int subsong);

+DUH *dumb_read_old_psm(DUMBFILE *f);

+DUH *dumb_read_mtm(DUMBFILE *f);

+DUH *dumb_read_riff(DUMBFILE *f);

+DUH *dumb_read_asy(DUMBFILE *f);

+

+DUH *dumb_load_it_quick(const char *filename);

+DUH *dumb_load_xm_quick(const char *filename);

+DUH *dumb_load_s3m_quick(const char *filename);

+DUH *dumb_load_stm_quick(const char *filename);

+DUH *dumb_load_mod_quick(const char *filename, int restr);

+DUH *dumb_load_ptm_quick(const char *filename);

+DUH *dumb_load_669_quick(const char *filename);

+DUH *dumb_load_psm_quick(const char *filename, int subsong);

+DUH *dumb_load_old_psm_quick(const char * filename);

+DUH *dumb_load_mtm_quick(const char *filename);

+DUH *dumb_load_riff_quick(const char *filename);

+DUH *dumb_load_asy_quick(const char *filename);

+

+DUH *dumb_read_it_quick(DUMBFILE *f);

+DUH *dumb_read_xm_quick(DUMBFILE *f);

+DUH *dumb_read_s3m_quick(DUMBFILE *f);

+DUH *dumb_read_stm_quick(DUMBFILE *f);

+DUH *dumb_read_mod_quick(DUMBFILE *f, int restr);

+DUH *dumb_read_ptm_quick(DUMBFILE *f);

+DUH *dumb_read_669_quick(DUMBFILE *f);

+DUH *dumb_read_psm_quick(DUMBFILE *f, int subsong);

+DUH *dumb_read_old_psm_quick(DUMBFILE *f);

+DUH *dumb_read_mtm_quick(DUMBFILE *f);

+DUH *dumb_read_riff_quick(DUMBFILE *f);

+DUH *dumb_read_asy_quick(DUMBFILE *f);

+

+long dumb_it_build_checkpoints(DUMB_IT_SIGDATA *sigdata, int startorder);

+void dumb_it_do_initial_runthrough(DUH *duh);

+

+int dumb_get_psm_subsong_count(DUMBFILE *f);

+

+const unsigned char *dumb_it_sd_get_song_message(DUMB_IT_SIGDATA *sd);

+

+int dumb_it_sd_get_n_orders(DUMB_IT_SIGDATA *sd);

+int dumb_it_sd_get_n_samples(DUMB_IT_SIGDATA *sd);

+int dumb_it_sd_get_n_instruments(DUMB_IT_SIGDATA *sd);

+

+const unsigned char *dumb_it_sd_get_sample_name(DUMB_IT_SIGDATA *sd, int i);

+const unsigned char *dumb_it_sd_get_sample_filename(DUMB_IT_SIGDATA *sd, int i);

+const unsigned char *dumb_it_sd_get_instrument_name(DUMB_IT_SIGDATA *sd, int i);

+const unsigned char *dumb_it_sd_get_instrument_filename(DUMB_IT_SIGDATA *sd, int i);

+

+int dumb_it_sd_get_initial_global_volume(DUMB_IT_SIGDATA *sd);

+void dumb_it_sd_set_initial_global_volume(DUMB_IT_SIGDATA *sd, int gv);

+

+int dumb_it_sd_get_mixing_volume(DUMB_IT_SIGDATA *sd);

+void dumb_it_sd_set_mixing_volume(DUMB_IT_SIGDATA *sd, int mv);

+

+int dumb_it_sd_get_initial_speed(DUMB_IT_SIGDATA *sd);

+void dumb_it_sd_set_initial_speed(DUMB_IT_SIGDATA *sd, int speed);

+

+int dumb_it_sd_get_initial_tempo(DUMB_IT_SIGDATA *sd);

+void dumb_it_sd_set_initial_tempo(DUMB_IT_SIGDATA *sd, int tempo);

+

+int dumb_it_sd_get_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel);

+void dumb_it_sd_set_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel, int volume);

+

+int dumb_it_sr_get_current_order(DUMB_IT_SIGRENDERER *sr);

+int dumb_it_sr_get_current_row(DUMB_IT_SIGRENDERER *sr);

+

+int dumb_it_sr_get_global_volume(DUMB_IT_SIGRENDERER *sr);

+void dumb_it_sr_set_global_volume(DUMB_IT_SIGRENDERER *sr, int gv);

+

+int dumb_it_sr_get_tempo(DUMB_IT_SIGRENDERER *sr);

+void dumb_it_sr_set_tempo(DUMB_IT_SIGRENDERER *sr, int tempo);

+

+int dumb_it_sr_get_speed(DUMB_IT_SIGRENDERER *sr);

+void dumb_it_sr_set_speed(DUMB_IT_SIGRENDERER *sr, int speed);

+

+#define DUMB_IT_N_CHANNELS 64

+#define DUMB_IT_N_NNA_CHANNELS 192

+#define DUMB_IT_TOTAL_CHANNELS (DUMB_IT_N_CHANNELS + DUMB_IT_N_NNA_CHANNELS)

+

+/* Channels passed to any of these functions are 0-based */

+int dumb_it_sr_get_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel);

+void dumb_it_sr_set_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel, int volume);

+

+int dumb_it_sr_get_channel_muted(DUMB_IT_SIGRENDERER *sr, int channel);

+void dumb_it_sr_set_channel_muted(DUMB_IT_SIGRENDERER *sr, int channel, int muted);

+

+typedef struct DUMB_IT_CHANNEL_STATE DUMB_IT_CHANNEL_STATE;

+

+struct DUMB_IT_CHANNEL_STATE

+{

+	int channel; /* 0-based; meaningful for NNA channels */

+	int sample; /* 1-based; 0 if nothing playing, then other fields undef */

+	int freq; /* in Hz */

+	float volume; /* 1.0 maximum; affected by ALL factors, inc. mixing vol */

+	unsigned char pan; /* 0-64, 100 for surround */

+	signed char subpan; /* use (pan + subpan/256.0f) or ((pan<<8)+subpan) */

+	unsigned char filter_cutoff;    /* 0-127    cutoff=127 AND resonance=0 */

+	unsigned char filter_subcutoff; /* 0-255      -> no filters (subcutoff */

+	unsigned char filter_resonance; /* 0-127        always 0 in this case) */

+	/* subcutoff only changes from zero if filter envelopes are in use. The

+	 * calculation (filter_cutoff + filter_subcutoff/256.0f) gives a more

+	 * accurate filter cutoff measurement as a float. It would often be more

+	 * useful to use a scaled int such as ((cutoff<<8) + subcutoff).

+	 */

+};

+

+/* Values of 64 or more will access NNA channels here. */

+void dumb_it_sr_get_channel_state(DUMB_IT_SIGRENDERER *sr, int channel, DUMB_IT_CHANNEL_STATE *state);

+

+

+/* Signal Design Helper Values */

+

+/* Use pow(DUMB_SEMITONE_BASE, n) to get the 'delta' value to transpose up by

+ * n semitones. To transpose down, use negative n.

+ */

+#define DUMB_SEMITONE_BASE 1.059463094359295309843105314939748495817

+

+/* Use pow(DUMB_QUARTERTONE_BASE, n) to get the 'delta' value to transpose up

+ * by n quartertones. To transpose down, use negative n.

+ */

+#define DUMB_QUARTERTONE_BASE 1.029302236643492074463779317738953977823

+

+/* Use pow(DUMB_PITCH_BASE, n) to get the 'delta' value to transpose up by n

+ * units. In this case, 256 units represent one semitone; 3072 units

+ * represent one octave. These units are used by the sequence signal (SEQU).

+ */

+#define DUMB_PITCH_BASE 1.000225659305069791926712241547647863626

+

+

+/* Signal Design Function Types */

+

+typedef void sigdata_t;

+typedef void sigrenderer_t;

+

+typedef sigdata_t *(*DUH_LOAD_SIGDATA)(DUH *duh, DUMBFILE *file);

+

+typedef sigrenderer_t *(*DUH_START_SIGRENDERER)(

+	DUH *duh,

+	sigdata_t *sigdata,

+	int n_channels,

+	long pos

+);

+

+typedef void (*DUH_SIGRENDERER_SET_SIGPARAM)(

+	sigrenderer_t *sigrenderer,

+	unsigned char id, long value

+);

+

+typedef long (*DUH_SIGRENDERER_GENERATE_SAMPLES)(

+	sigrenderer_t *sigrenderer,

+	float volume, float delta,

+	long size, sample_t **samples

+);

+

+typedef void (*DUH_SIGRENDERER_GET_CURRENT_SAMPLE)(

+	sigrenderer_t *sigrenderer,

+	float volume,

+	sample_t *samples

+);

+

+typedef void (*DUH_END_SIGRENDERER)(sigrenderer_t *sigrenderer);

+

+typedef void (*DUH_UNLOAD_SIGDATA)(sigdata_t *sigdata);

+

+

+/* Signal Design Function Registration */

+

+typedef struct DUH_SIGTYPE_DESC

+{

+	long type;

+	DUH_LOAD_SIGDATA                   load_sigdata;

+	DUH_START_SIGRENDERER              start_sigrenderer;

+	DUH_SIGRENDERER_SET_SIGPARAM       sigrenderer_set_sigparam;

+	DUH_SIGRENDERER_GENERATE_SAMPLES   sigrenderer_generate_samples;

+	DUH_SIGRENDERER_GET_CURRENT_SAMPLE sigrenderer_get_current_sample;

+	DUH_END_SIGRENDERER                end_sigrenderer;

+	DUH_UNLOAD_SIGDATA                 unload_sigdata;

+}

+DUH_SIGTYPE_DESC;

+

+void dumb_register_sigtype(DUH_SIGTYPE_DESC *desc);

+

+

+// Decide where to put these functions; new heading?

+

+sigdata_t *duh_get_raw_sigdata(DUH *duh, int sig, long type);

+

+DUH_SIGRENDERER *duh_encapsulate_raw_sigrenderer(sigrenderer_t *vsigrenderer, DUH_SIGTYPE_DESC *desc, int n_channels, long pos);

+sigrenderer_t *duh_get_raw_sigrenderer(DUH_SIGRENDERER *sigrenderer, long type);

+

+

+/* Standard Signal Types */

+

+//void dumb_register_sigtype_sample(void);

+

+

+/* Sample Buffer Allocation Helpers */

+

+#ifdef DUMB_DECLARE_DEPRECATED

+sample_t **create_sample_buffer(int n_channels, long length) DUMB_DEPRECATED;

+/* DUMB has been changed to interleave stereo samples. Use

+ * allocate_sample_buffer() instead, and see the comments for

+ * duh_sigrenderer_set_analyser_callback().

+ */

+#endif

+sample_t **allocate_sample_buffer(int n_channels, long length);

+void destroy_sample_buffer(sample_t **samples);

+

+

+/* Silencing Helper */

+

+void dumb_silence(sample_t *samples, long length);

+

+

+/* Click Removal Helpers */

+

+typedef struct DUMB_CLICK_REMOVER DUMB_CLICK_REMOVER;

+

+DUMB_CLICK_REMOVER *dumb_create_click_remover(void);

+void dumb_record_click(DUMB_CLICK_REMOVER *cr, long pos, sample_t step);

+void dumb_remove_clicks(DUMB_CLICK_REMOVER *cr, sample_t *samples, long length, int step, float halflife);

+sample_t dumb_click_remover_get_offset(DUMB_CLICK_REMOVER *cr);

+void dumb_destroy_click_remover(DUMB_CLICK_REMOVER *cr);

+

+DUMB_CLICK_REMOVER **dumb_create_click_remover_array(int n);

+void dumb_record_click_array(int n, DUMB_CLICK_REMOVER **cr, long pos, sample_t *step);

+void dumb_record_click_negative_array(int n, DUMB_CLICK_REMOVER **cr, long pos, sample_t *step);

+void dumb_remove_clicks_array(int n, DUMB_CLICK_REMOVER **cr, sample_t **samples, long length, float halflife);

+void dumb_click_remover_get_offset_array(int n, DUMB_CLICK_REMOVER **cr, sample_t *offset);

+void dumb_destroy_click_remover_array(int n, DUMB_CLICK_REMOVER **cr);

+

+

+/* Resampling Helpers */

+

+#define DUMB_RQ_ALIASING 0

+#define DUMB_RQ_LINEAR   1

+#define DUMB_RQ_CUBIC    2

+#define DUMB_RQ_N_LEVELS 3

+extern int dumb_resampling_quality;

+

+typedef struct DUMB_RESAMPLER DUMB_RESAMPLER;

+

+typedef struct DUMB_VOLUME_RAMP_INFO DUMB_VOLUME_RAMP_INFO;

+

+typedef void (*DUMB_RESAMPLE_PICKUP)(DUMB_RESAMPLER *resampler, void *data);

+

+struct DUMB_RESAMPLER

+{

+	void *src;

+	long pos;

+	int subpos;

+	long start, end;

+	int dir;

+	DUMB_RESAMPLE_PICKUP pickup;

+	void *pickup_data;

+	int quality;

+	/* Everything below this point is internal: do not use. */

+	union {

+		sample_t x24[3*2];

+		short x16[3*2];

+		signed char x8[3*2];

+	} x;

+	int overshot;

+};

+

+struct DUMB_VOLUME_RAMP_INFO

+{

+	float volume;

+	float delta;

+	float target;

+	float mix;

+};

+

+void dumb_reset_resampler(DUMB_RESAMPLER *resampler, sample_t *src, int src_channels, long pos, long start, long end, int quality);

+DUMB_RESAMPLER *dumb_start_resampler(sample_t *src, int src_channels, long pos, long start, long end, int quality);

+long dumb_resample_1_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume, float delta);

+long dumb_resample_1_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+long dumb_resample_2_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+long dumb_resample_2_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+void dumb_resample_get_current_sample_1_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume, sample_t *dst);

+void dumb_resample_get_current_sample_1_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_resample_get_current_sample_2_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_resample_get_current_sample_2_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_end_resampler(DUMB_RESAMPLER *resampler);

+

+void dumb_reset_resampler_16(DUMB_RESAMPLER *resampler, short *src, int src_channels, long pos, long start, long end, int quality);

+DUMB_RESAMPLER *dumb_start_resampler_16(short *src, int src_channels, long pos, long start, long end, int quality);

+long dumb_resample_16_1_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume, float delta);

+long dumb_resample_16_1_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+long dumb_resample_16_2_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+long dumb_resample_16_2_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+void dumb_resample_get_current_sample_16_1_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume, sample_t *dst);

+void dumb_resample_get_current_sample_16_1_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_resample_get_current_sample_16_2_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_resample_get_current_sample_16_2_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_end_resampler_16(DUMB_RESAMPLER *resampler);

+

+void dumb_reset_resampler_8(DUMB_RESAMPLER *resampler, signed char *src, int src_channels, long pos, long start, long end, int quality);

+DUMB_RESAMPLER *dumb_start_resampler_8(signed char *src, int src_channels, long pos, long start, long end, int quality);

+long dumb_resample_8_1_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume, float delta);

+long dumb_resample_8_1_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+long dumb_resample_8_2_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+long dumb_resample_8_2_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+void dumb_resample_get_current_sample_8_1_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume, sample_t *dst);

+void dumb_resample_get_current_sample_8_1_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_resample_get_current_sample_8_2_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_resample_get_current_sample_8_2_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_end_resampler_8(DUMB_RESAMPLER *resampler);

+

+void dumb_reset_resampler_n(int n, DUMB_RESAMPLER *resampler, void *src, int src_channels, long pos, long start, long end, int quality);

+DUMB_RESAMPLER *dumb_start_resampler_n(int n, void *src, int src_channels, long pos, long start, long end, int quality);

+long dumb_resample_n_1_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume, float delta);

+long dumb_resample_n_1_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+long dumb_resample_n_2_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+long dumb_resample_n_2_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta);

+void dumb_resample_get_current_sample_n_1_1(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume, sample_t *dst);

+void dumb_resample_get_current_sample_n_1_2(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_resample_get_current_sample_n_2_1(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_resample_get_current_sample_n_2_2(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst);

+void dumb_end_resampler_n(int n, DUMB_RESAMPLER *resampler);

+

+

+/* DUH Construction */

+

+DUH *make_duh(

+	long length,

+	int n_tags,

+	const char *const tag[][2],

+	int n_signals,

+	DUH_SIGTYPE_DESC *desc[],

+	sigdata_t *sigdata[]

+);

+

+void duh_set_length(DUH *duh, long length);

+

+

+#ifdef __cplusplus

+	}

+#endif

+

+

+#endif /* DUMB_H */

diff --git a/plugins/dumb/dumb-kode54/include/dumb.h.ex b/plugins/dumb/dumb-kode54/include/dumb.h.ex
new file mode 100644
index 00000000..ebaefcd7
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/include/dumb.h.ex
@@ -0,0 +1,37 @@
+/* dumb.h: the user header file for DUMB. Include this in any of your files

+ * where you wish to use the DUMB functions and variables.

+ */

+

+#ifndef DUMB_H

+#define DUMB_H

+

+

+#define DAT_DUH DAT_ID('D','U','H',' ')

+

+

+typedef struct DUH DUH;

+

+

+int install_dumb(int *errno_ptr, int (*atexit_ptr)(void (*func)(void)));

+void remove_dumb(void);

+

+DUH *load_duh(const char *filename);

+void unload_duh(DUH *duh);

+

+void register_dat_duh(void);

+

+typedef void *(*DUH_LOAD_SIGNAL)(DUH *duh, PACKFILE *file);

+typedef float *(*DUH_RENDER_SAMPLES)(DUH *duh, void *data);

+typedef void (*DUH_FREE_SAMPLES)(float *samples);

+typedef void (*DUH_UNLOAD_SIGNAL)(void *data);

+

+void register_signal_type(

+	long type,

+	DUH_LOAD_SIGNAL    load_signal,

+	DUH_RENDER_SAMPLES render_samples,

+	DUH_FREE_SAMPLES   free_samples,

+	DUH_UNLOAD_SIGNAL  unload_signal

+);

+

+

+#endif /* DUMB_H */

diff --git a/plugins/dumb/dumb-kode54/include/internal/Makefile.am b/plugins/dumb/dumb-kode54/include/internal/Makefile.am
new file mode 100644
index 00000000..038788b4
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/include/internal/Makefile.am
@@ -0,0 +1,3 @@
+EXTRA_DIST = \

+	dumb.h \

+	it.h

diff --git a/plugins/dumb/dumb-kode54/include/internal/aldumb.h b/plugins/dumb/dumb-kode54/include/internal/aldumb.h
new file mode 100644
index 00000000..9c02c01f
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/include/internal/aldumb.h
@@ -0,0 +1,27 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * internal/aldumb.h - The internal header file       / / \  \

+ *                     for DUMB with Allegro.        | <  /   \_

+ *                                                   |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#ifndef INTERNAL_ALDUMB_H

+#define INTERNAL_ALDUMB_H

+

+

+void _dat_unload_duh(void *duh);

+

+

+#endif /* INTERNAL_DUMB_H */

diff --git a/plugins/dumb/dumb-kode54/include/internal/barray.h b/plugins/dumb/dumb-kode54/include/internal/barray.h
new file mode 100644
index 00000000..53c9a6cf
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/include/internal/barray.h
@@ -0,0 +1,20 @@
+#ifndef _B_ARRAY_H_

+#define _B_ARRAY_H_

+

+#include <stdlib.h>

+

+void * bit_array_create(size_t size);

+void bit_array_destroy(void * array);

+void * bit_array_dup(void * array);

+

+void bit_array_reset(void * array);

+

+void bit_array_set(void * array, size_t bit);

+int bit_array_test(void * array, size_t bit);

+int bit_array_test_range(void * array, size_t bit, size_t count);

+void bit_array_clear(void * array, size_t bit);

+

+void bit_array_merge(void * array, void * source, size_t offset);

+void bit_array_mask(void * array, void * source, size_t offset);

+

+#endif

diff --git a/plugins/dumb/dumb-kode54/include/internal/dumb.h b/plugins/dumb/dumb-kode54/include/internal/dumb.h
new file mode 100644
index 00000000..bed59566
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/include/internal/dumb.h
@@ -0,0 +1,61 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * internal/dumb.h - DUMB's internal declarations.    / / \  \

+ *                                                   | <  /   \_

+ * This header file provides access to the           |  \/ /\   /

+ * internal structure of DUMB, and is liable          \_  /  > /

+ * to change, mutate or cease to exist at any           | \ / /

+ * moment. Include it at your own peril.                |  ' /

+ *                                                       \__/

+ * ...

+ *

+ * Seriously. You don't need access to anything in this file. All right, you

+ * probably do actually. But if you use it, you will be relying on a specific

+ * version of DUMB, so please check DUMB_VERSION defined in dumb.h. Please

+ * contact the authors so that we can provide a public API for what you need.

+ */

+

+#ifndef INTERNAL_DUMB_H

+#define INTERNAL_DUMB_H

+

+

+typedef struct DUH_SIGTYPE_DESC_LINK

+{

+	struct DUH_SIGTYPE_DESC_LINK *next;

+	DUH_SIGTYPE_DESC *desc;

+}

+DUH_SIGTYPE_DESC_LINK;

+

+

+typedef struct DUH_SIGNAL

+{

+	sigdata_t *sigdata;

+	DUH_SIGTYPE_DESC *desc;

+}

+DUH_SIGNAL;

+

+

+struct DUH

+{

+	long length;

+

+	int n_tags;

+	char *(*tag)[2];

+

+	int n_signals;

+	DUH_SIGNAL **signal;

+};

+

+

+DUH_SIGTYPE_DESC *_dumb_get_sigtype_desc(long type);

+

+

+#endif /* INTERNAL_DUMB_H */

diff --git a/plugins/dumb/dumb-kode54/include/internal/it.h b/plugins/dumb/dumb-kode54/include/internal/it.h
new file mode 100644
index 00000000..fd7cb8b5
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/include/internal/it.h
@@ -0,0 +1,882 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * internal/it.h - Internal stuff for IT playback     / / \  \

+ *                 and MOD/XM/S3M conversion.        | <  /   \_

+ *                                                   |  \/ /\   /

+ * This header file provides access to the            \_  /  > /

+ * internal structure of DUMB, and is liable            | \ / /

+ * to change, mutate or cease to exist at any           |  ' /

+ * moment. Include it at your own peril.                 \__/

+ *

+ * ...

+ *

+ * Seriously. You don't need access to anything in this file. All right, you

+ * probably do actually. But if you use it, you will be relying on a specific

+ * version of DUMB, so please check DUMB_VERSION defined in dumb.h. Please

+ * contact the authors so that we can provide a public API for what you need.

+ */

+

+#ifndef INTERNAL_IT_H

+#define INTERNAL_IT_H

+

+

+#define BIT_ARRAY_BULLSHIT

+

+#include <stddef.h>

+

+#include "barray.h"

+

+

+/** TO DO: THINK ABOUT THE FOLLOWING:

+

+sigdata->flags & IT_COMPATIBLE_GXX

+

+                Bit 5: On = Link Effect G's memory with Effect E/F. Also

+                            Gxx with an instrument present will cause the

+                            envelopes to be retriggered. If you change a

+                            sample on a row with Gxx, it'll adjust the

+                            frequency of the current note according to:

+

+                              NewFrequency = OldFrequency * NewC5 / OldC5;

+*/

+

+

+

+/* These #defines are TEMPORARY. They are used to write alternative code to

+ * handle ambiguities in the format specification. The correct code in each

+ * case will be determined most likely by experimentation.

+ */

+#define STEREO_SAMPLES_COUNT_AS_TWO

+#define INVALID_ORDERS_END_SONG

+#define INVALID_NOTES_CAUSE_NOTE_CUT

+#define SUSTAIN_LOOP_OVERRIDES_NORMAL_LOOP

+#define VOLUME_OUT_OF_RANGE_SETS_MAXIMUM

+

+

+

+#define SIGTYPE_IT DUMB_ID('I', 'T', ' ', ' ')

+

+#define IT_SIGNATURE            DUMB_ID('I', 'M', 'P', 'M')

+#define IT_INSTRUMENT_SIGNATURE DUMB_ID('I', 'M', 'P', 'I')

+#define IT_SAMPLE_SIGNATURE     DUMB_ID('I', 'M', 'P', 'S')

+

+// olivier sux

+#define IT_MPTX_SIGNATURE       DUMB_ID('X', 'T', 'P', 'M')

+#define IT_INSM_SIGNATURE       DUMB_ID('M', 'S', 'N', 'I')

+

+

+/* 1 minute per 4 rows, each row 6 ticks; this is divided by the tempo to get

+ * the interval between ticks.

+ */

+#define TICK_TIME_DIVIDEND ((65536 * 60) / (4 * 6))

+

+

+

+/* I'm not going to try to explain this, because I didn't derive it very

+ * formally ;)

+ */

+/* #define AMIGA_DIVISOR ((float)(4.0 * 14317056.0)) */

+/* I believe the following one to be more accurate. */

+//#define AMIGA_DIVISOR ((float)(8.0 * 7159090.5))

+#define AMIGA_CLOCK 3546895

+#define AMIGA_DIVISOR ((float)(16.0 * AMIGA_CLOCK))

+

+

+

+typedef struct IT_MIDI IT_MIDI;

+typedef struct IT_FILTER_STATE IT_FILTER_STATE;

+typedef struct IT_ENVELOPE IT_ENVELOPE;

+typedef struct IT_INSTRUMENT IT_INSTRUMENT;

+typedef struct IT_SAMPLE IT_SAMPLE;

+typedef struct IT_ENTRY IT_ENTRY;

+typedef struct IT_PATTERN IT_PATTERN;

+typedef struct IT_PLAYING_ENVELOPE IT_PLAYING_ENVELOPE;

+typedef struct IT_PLAYING IT_PLAYING;

+typedef struct IT_CHANNEL IT_CHANNEL;

+typedef struct IT_CHECKPOINT IT_CHECKPOINT;

+typedef struct IT_CALLBACKS IT_CALLBACKS;

+

+

+

+struct IT_MIDI

+{

+	unsigned char SFmacro[16][16]; // read these from 0x120

+	unsigned char SFmacrolen[16];

+	unsigned short SFmacroz[16]; /* Bitfield; bit 0 set = z in first position */

+	unsigned char Zmacro[128][16]; // read these from 0x320

+	unsigned char Zmacrolen[128];

+};

+

+

+

+struct IT_FILTER_STATE

+{

+	sample_t currsample, prevsample;

+};

+

+

+

+#define IT_ENVELOPE_ON                1

+#define IT_ENVELOPE_LOOP_ON           2

+#define IT_ENVELOPE_SUSTAIN_LOOP      4

+#define IT_ENVELOPE_CARRY             8

+#define IT_ENVELOPE_PITCH_IS_FILTER 128

+

+struct IT_ENVELOPE

+{

+	unsigned char flags;

+	unsigned char n_nodes;

+	unsigned char loop_start;

+	unsigned char loop_end;

+	unsigned char sus_loop_start;

+	unsigned char sus_loop_end;

+	signed char node_y[25];

+	unsigned short node_t[25];

+};

+

+

+

+#define NNA_NOTE_CUT      0

+#define NNA_NOTE_CONTINUE 1

+#define NNA_NOTE_OFF      2

+#define NNA_NOTE_FADE     3

+

+#define DCT_OFF        0

+#define DCT_NOTE       1

+#define DCT_SAMPLE     2

+#define DCT_INSTRUMENT 3

+

+#define DCA_NOTE_CUT  0

+#define DCA_NOTE_OFF  1

+#define DCA_NOTE_FADE 2

+

+struct IT_INSTRUMENT

+{

+	unsigned char name[27];

+	unsigned char filename[14];

+

+	int fadeout;

+

+	IT_ENVELOPE volume_envelope;

+	IT_ENVELOPE pan_envelope;

+	IT_ENVELOPE pitch_envelope;

+

+	unsigned char new_note_action;

+	unsigned char dup_check_type;

+	unsigned char dup_check_action;

+	signed char pp_separation;

+	unsigned char pp_centre;

+	unsigned char global_volume;

+	unsigned char default_pan;

+	unsigned char random_volume;

+	unsigned char random_pan;

+

+	unsigned char filter_cutoff;

+	unsigned char filter_resonance;

+

+	unsigned char map_note[120];

+	unsigned short map_sample[120];

+

+	//int output;

+};

+

+

+

+#define IT_SAMPLE_EXISTS              1

+#define IT_SAMPLE_16BIT               2

+#define IT_SAMPLE_STEREO              4

+#define IT_SAMPLE_LOOP               16

+#define IT_SAMPLE_SUS_LOOP           32

+#define IT_SAMPLE_PINGPONG_LOOP      64

+#define IT_SAMPLE_PINGPONG_SUS_LOOP 128

+

+#define IT_VIBRATO_SINE      0

+#define IT_VIBRATO_SAWTOOTH  1

+#define IT_VIBRATO_SQUARE    2

+#define IT_VIBRATO_RANDOM    3

+#define IT_VIBRATO_XM_SQUARE 4

+#define IT_VIBRATO_RAMP_DOWN 5

+#define IT_VIBRATO_RAMP_UP   6

+

+struct IT_SAMPLE

+{

+	unsigned char name[35];

+	unsigned char filename[14];

+	unsigned char flags;

+	unsigned char global_volume;

+	unsigned char default_volume;

+	unsigned char default_pan;

+	/* default_pan:

+	 *   0-255 for XM

+	 *   ignored for MOD

+	 *   otherwise, 0-64, and add 128 to enable

+	 */

+

+	long length;

+	long loop_start;

+	long loop_end;

+	long C5_speed;

+	long sus_loop_start;

+	long sus_loop_end;

+

+	unsigned char vibrato_speed;

+	unsigned char vibrato_depth;

+	unsigned char vibrato_rate;

+	unsigned char vibrato_waveform;

+

+	signed short   finetune;

+

+	void *data;

+

+	int max_resampling_quality;

+};

+

+

+

+#define IT_ENTRY_NOTE       1

+#define IT_ENTRY_INSTRUMENT 2

+#define IT_ENTRY_VOLPAN     4

+#define IT_ENTRY_EFFECT     8

+

+#define IT_SET_END_ROW(entry) ((entry)->channel = 255)

+#define IT_IS_END_ROW(entry) ((entry)->channel >= DUMB_IT_N_CHANNELS)

+

+#define IT_NOTE_OFF 255

+#define IT_NOTE_CUT 254

+

+#define IT_ENVELOPE_SHIFT 8

+

+#define IT_SURROUND 100

+#define IT_IS_SURROUND(pan) ((pan) > 64)

+#define IT_IS_SURROUND_SHIFTED(pan) ((pan) > 64 << IT_ENVELOPE_SHIFT)

+

+#define IT_SET_SPEED              1

+#define IT_JUMP_TO_ORDER          2

+#define IT_BREAK_TO_ROW           3

+#define IT_VOLUME_SLIDE           4

+#define IT_PORTAMENTO_DOWN        5

+#define IT_PORTAMENTO_UP          6

+#define IT_TONE_PORTAMENTO        7

+#define IT_VIBRATO                8

+#define IT_TREMOR                 9

+#define IT_ARPEGGIO              10

+#define IT_VOLSLIDE_VIBRATO      11

+#define IT_VOLSLIDE_TONEPORTA    12

+#define IT_SET_CHANNEL_VOLUME    13

+#define IT_CHANNEL_VOLUME_SLIDE  14

+#define IT_SET_SAMPLE_OFFSET     15

+#define IT_PANNING_SLIDE         16

+#define IT_RETRIGGER_NOTE        17

+#define IT_TREMOLO               18

+#define IT_S                     19

+#define IT_SET_SONG_TEMPO        20

+#define IT_FINE_VIBRATO          21

+#define IT_SET_GLOBAL_VOLUME     22

+#define IT_GLOBAL_VOLUME_SLIDE   23

+#define IT_SET_PANNING           24

+#define IT_PANBRELLO             25

+#define IT_MIDI_MACRO            26 //see MIDI.TXT

+

+/* Some effects needed for XM compatibility */

+#define IT_XM_PORTAMENTO_DOWN       27

+#define IT_XM_PORTAMENTO_UP         28

+#define IT_XM_FINE_VOLSLIDE_DOWN    29

+#define IT_XM_FINE_VOLSLIDE_UP      30

+#define IT_XM_RETRIGGER_NOTE        31

+#define IT_XM_KEY_OFF               32

+#define IT_XM_SET_ENVELOPE_POSITION 33

+

+/* More effects needed for PTM compatibility */

+#define IT_PTM_NOTE_SLIDE_DOWN        34

+#define IT_PTM_NOTE_SLIDE_UP          35

+#define IT_PTM_NOTE_SLIDE_DOWN_RETRIG 36

+#define IT_PTM_NOTE_SLIDE_UP_RETRIG   37

+

+#define IT_N_EFFECTS                  38

+

+/* These represent the top nibble of the command value. */

+#define IT_S_SET_FILTER              0 /* Greyed out in IT... */

+#define IT_S_SET_GLISSANDO_CONTROL   1 /* Greyed out in IT... */

+#define IT_S_FINETUNE                2 /* Greyed out in IT... */

+#define IT_S_SET_VIBRATO_WAVEFORM    3

+#define IT_S_SET_TREMOLO_WAVEFORM    4

+#define IT_S_SET_PANBRELLO_WAVEFORM  5

+#define IT_S_FINE_PATTERN_DELAY      6

+#define IT_S7                        7

+#define IT_S_SET_PAN                 8

+#define IT_S_SET_SURROUND_SOUND      9

+#define IT_S_SET_HIGH_OFFSET        10

+#define IT_S_PATTERN_LOOP           11

+#define IT_S_DELAYED_NOTE_CUT       12

+#define IT_S_NOTE_DELAY             13

+#define IT_S_PATTERN_DELAY          14

+#define IT_S_SET_MIDI_MACRO         15

+

+/*

+S0x Set filter

+S1x Set glissando control

+S2x Set finetune

+

+

+S3x Set vibrato waveform to type x

+S4x Set tremelo waveform to type x

+S5x Set panbrello waveform to type x

+  Waveforms for commands S3x, S4x and S5x:

+    0: Sine wave

+    1: Ramp down

+    2: Square wave

+    3: Random wave

+S6x Pattern delay for x ticks

+S70 Past note cut

+S71 Past note off

+S72 Past note fade

+S73 Set NNA to note cut

+S74 Set NNA to continue

+S75 Set NNA to note off

+S76 Set NNA to note fade

+S77 Turn off volume envelope

+S78 Turn on volume envelope

+S79 Turn off panning envelope

+S7A Turn on panning envelope

+S7B Turn off pitch envelope

+S7C Turn on pitch envelope

+S8x Set panning position

+S91 Set surround sound

+SAy Set high value of sample offset yxx00h

+SB0 Set loopback point

+SBx Loop x times to loopback point

+SCx Note cut after x ticks

+SDx Note delay for x ticks

+SEx Pattern delay for x rows

+SFx Set parameterised MIDI Macro

+*/

+

+struct IT_ENTRY

+{

+	unsigned char channel; /* End of row if channel >= DUMB_IT_N_CHANNELS */

+	unsigned char mask;

+	unsigned char note;

+	unsigned char instrument;

+	unsigned char volpan;

+	unsigned char effect;

+	unsigned char effectvalue;

+};

+

+

+

+struct IT_PATTERN

+{

+	int n_rows;

+	int n_entries;

+	IT_ENTRY *entry;

+};

+

+

+

+#define IT_STEREO            1

+#define IT_USE_INSTRUMENTS   4

+#define IT_LINEAR_SLIDES     8 /* If not set, use Amiga slides */

+#define IT_OLD_EFFECTS      16

+#define IT_COMPATIBLE_GXX   32

+

+/* Make sure IT_WAS_AN_XM and IT_WAS_A_MOD aren't set accidentally */

+#define IT_REAL_FLAGS       63

+

+#define IT_WAS_AN_XM        64 /* Set for both XMs and MODs */

+#define IT_WAS_A_MOD       128

+

+#define IT_WAS_AN_S3M      256

+

+#define IT_WAS_A_PTM       512

+

+#define IT_WAS_A_669      1024

+

+#define IT_ORDER_END  255

+#define IT_ORDER_SKIP 254

+

+struct DUMB_IT_SIGDATA

+{

+	unsigned char name[65];

+

+	unsigned char *song_message;

+

+	int n_orders;

+	int n_instruments;

+	int n_samples;

+	int n_patterns;

+	int n_pchannels;

+

+	int flags;

+

+	int global_volume;

+	int mixing_volume;

+	int speed;

+	int tempo;

+	int pan_separation;

+

+	unsigned char channel_pan[DUMB_IT_N_CHANNELS];

+	unsigned char channel_volume[DUMB_IT_N_CHANNELS];

+

+	unsigned char *order;

+	unsigned char restart_position; /* for XM compatiblity */

+

+	IT_INSTRUMENT *instrument;

+	IT_SAMPLE *sample;

+	IT_PATTERN *pattern;

+

+	IT_MIDI *midi;

+

+	IT_CHECKPOINT *checkpoint;

+};

+

+

+

+struct IT_PLAYING_ENVELOPE

+{

+	int next_node;

+	int tick;

+	int value;

+};

+

+

+

+#define IT_PLAYING_BACKGROUND 1

+#define IT_PLAYING_SUSTAINOFF 2

+#define IT_PLAYING_FADING     4

+#define IT_PLAYING_DEAD       8

+

+struct IT_PLAYING

+{

+	int flags;

+

+	int resampling_quality;

+

+	IT_CHANNEL *channel;

+	IT_SAMPLE *sample;

+	IT_INSTRUMENT *instrument;

+	IT_INSTRUMENT *env_instrument;

+

+	unsigned short sampnum;

+	unsigned char instnum;

+

+	unsigned char declick_stage;

+	float declick_volume;

+

+	float float_volume[2];

+	float ramp_volume[2];

+	float ramp_delta[2];

+

+	unsigned char channel_volume;

+

+	unsigned char volume;

+	unsigned short pan;

+

+	signed char volume_offset, panning_offset;

+

+	unsigned char note;

+

+	unsigned char enabled_envelopes;

+

+	unsigned char filter_cutoff;

+	unsigned char filter_resonance;

+

+	unsigned short true_filter_cutoff;   /* These incorporate the filter envelope, and will not */

+	unsigned char true_filter_resonance; /* be changed if they would be set to 127<<8 and 0.    */

+

+	unsigned char vibrato_speed;

+	unsigned char vibrato_depth;

+	unsigned char vibrato_n; /* May be specified twice: volpan & effect. */

+	unsigned char vibrato_time;

+	unsigned char vibrato_waveform;

+

+	unsigned char tremolo_speed;

+	unsigned char tremolo_depth;

+	unsigned char tremolo_time;

+	unsigned char tremolo_waveform;

+

+	unsigned char panbrello_speed;

+	unsigned char panbrello_depth;

+	unsigned char panbrello_time;

+	unsigned char panbrello_waveform;

+	signed char panbrello_random;

+

+	unsigned char sample_vibrato_time;

+	unsigned char sample_vibrato_waveform;

+	int sample_vibrato_depth; /* Starts at rate?0:depth, increases by rate */

+

+	int slide;

+	float delta;

+	int finetune;

+

+	IT_PLAYING_ENVELOPE volume_envelope;

+	IT_PLAYING_ENVELOPE pan_envelope;

+	IT_PLAYING_ENVELOPE pitch_envelope;

+

+	int fadeoutcount;

+

+	IT_FILTER_STATE filter_state[2]; /* Left and right */

+

+	DUMB_RESAMPLER resampler;

+

+	/* time_lost is used to emulate Impulse Tracker's sample looping

+	 * characteristics. When time_lost is added to pos, the result represents

+	 * the position in the theoretical version of the sample where all loops

+	 * have been expanded. If this is stored, the resampling helpers will

+	 * safely convert it for use with new loop boundaries. The situation is

+	 * slightly more complicated if dir == -1 when the change takes place; we

+	 * must reflect pos off the loop end point and set dir to 1 before

+	 * proceeding.

+	 */

+	long time_lost;

+

+	//int output;

+};

+

+

+

+#define IT_CHANNEL_MUTED 1

+

+#define IT_ENV_VOLUME  1

+#define IT_ENV_PANNING 2

+#define IT_ENV_PITCH   4

+

+struct IT_CHANNEL

+{

+	int flags;

+

+	unsigned char volume;

+	signed char volslide;

+	signed char xm_volslide;

+	signed char panslide;

+

+	/* xm_volslide is used for volume slides done in the volume column in an

+	 * XM file, since it seems the volume column slide is applied first,

+	 * followed by clamping, followed by the effects column slide. IT does

+	 * not exhibit this behaviour, so xm_volslide is maintained at zero.

+	 */

+

+	unsigned char pan;

+	unsigned short truepan;

+

+	unsigned char channelvolume;

+	signed char channelvolslide;

+

+	unsigned char instrument;

+	unsigned char note;

+

+	unsigned char SFmacro;

+

+	unsigned char filter_cutoff;

+	unsigned char filter_resonance;

+

+	unsigned char key_off_count;

+	unsigned char note_cut_count;

+	unsigned char note_delay_count;

+	IT_ENTRY *note_delay_entry;

+

+	unsigned char new_note_action;

+

+	int arpeggio;

+	unsigned char retrig;

+	unsigned char xm_retrig;

+	int retrig_tick;

+

+	unsigned char tremor;

+	unsigned char tremor_time; /* Bit 6 set if note on; bit 7 set if tremor active. */

+

+	unsigned char vibrato_waveform;

+	unsigned char tremolo_waveform;

+	unsigned char panbrello_waveform;

+

+	int portamento;

+	int toneporta;

+	int toneslide;

+	unsigned char toneslide_tick, last_toneslide_tick, ptm_toneslide, ptm_last_toneslide;

+	unsigned char destnote;

+	unsigned char toneslide_retrig;

+

+	unsigned char glissando;

+

+	/** WARNING - for neatness, should one or both of these be in the IT_PLAYING struct? */

+	unsigned short sample;

+	unsigned char truenote;

+

+	unsigned char midi_state;

+

+	signed char lastvolslide;

+	unsigned char lastDKL;

+	unsigned char lastEF; /* Doubles as last portamento up for XM files */

+	unsigned char lastG;

+	unsigned char lastHspeed;

+	unsigned char lastHdepth;

+	unsigned char lastRspeed;

+	unsigned char lastRdepth;

+	unsigned char lastYspeed;

+	unsigned char lastYdepth;

+	unsigned char lastI;

+	unsigned char lastJ; /* Doubles as last portamento down for XM files */

+	unsigned char lastN;

+	unsigned char lastO;

+	unsigned char high_offset;

+	unsigned char lastP;

+	unsigned char lastQ;

+	unsigned char lastS;

+	unsigned char pat_loop_row;

+	unsigned char pat_loop_count;

+	unsigned char pat_loop_end_row; /* Used to catch infinite pattern loops */

+	unsigned char lastW;

+

+	unsigned char xm_lastE1;

+	unsigned char xm_lastE2;

+	unsigned char xm_lastEA;

+	unsigned char xm_lastEB;

+	unsigned char xm_lastX1;

+	unsigned char xm_lastX2;

+

+	IT_PLAYING *playing;

+

+#ifdef BIT_ARRAY_BULLSHIT

+	void * played_patjump;

+	int played_patjump_order;

+#endif

+

+	//int output;

+};

+

+

+

+struct DUMB_IT_SIGRENDERER

+{

+	DUMB_IT_SIGDATA *sigdata;

+

+	int n_channels;

+

+	int resampling_quality;

+

+	unsigned char globalvolume;

+	signed char globalvolslide;

+

+	int tempo;

+	signed char temposlide;

+

+	IT_CHANNEL channel[DUMB_IT_N_CHANNELS];

+

+	IT_PLAYING *playing[DUMB_IT_N_NNA_CHANNELS];

+

+	int tick;

+	int speed;

+	int rowcount;

+

+	int order; /* Set to -1 if the song is terminated by a callback. */

+	int row;

+	int processorder;

+	int processrow;

+	int breakrow;

+

+	int restart_position;

+

+	int n_rows;

+

+	IT_ENTRY *entry_start;

+	IT_ENTRY *entry;

+	IT_ENTRY *entry_end;

+

+	long time_left; /* Time before the next tick is processed */

+	int sub_time_left;

+

+	DUMB_CLICK_REMOVER **click_remover;

+

+	IT_CALLBACKS *callbacks;

+

+#ifdef BIT_ARRAY_BULLSHIT

+	/* bit array, which rows are played, only checked by pattern break or loop commands */

+	void * played;

+#endif

+

+	long gvz_time;

+	int gvz_sub_time;

+

+	int ramp_style;

+

+	//int max_output;

+};

+

+

+

+struct IT_CHECKPOINT

+{

+	IT_CHECKPOINT *next;

+	long time;

+	DUMB_IT_SIGRENDERER *sigrenderer;

+};

+

+

+

+struct IT_CALLBACKS

+{

+	int (*loop)(void *data);

+	void *loop_data;

+	/* Return 1 to prevent looping; the music will terminate abruptly. If you

+	 * want to make the music stop but allow samples to fade (beware, as they

+	 * might not fade at all!), use dumb_it_sr_set_speed() and set the speed

+	 * to 0. Note that xm_speed_zero() will not be called if you set the

+	 * speed manually, and also that this will work for IT and S3M files even

+	 * though the music can't stop in this way by itself.

+	 */

+

+	int (*xm_speed_zero)(void *data);

+	void *xm_speed_zero_data;

+	/* Return 1 to terminate the mod, without letting samples fade. */

+

+	int (*midi)(void *data, int channel, unsigned char byte);

+	void *midi_data;

+	/* Return 1 to prevent DUMB from subsequently interpreting the MIDI bytes

+	 * itself. In other words, return 1 if the Zxx macros in an IT file are

+	 * controlling filters and shouldn't be.

+	 */

+

+	int (*global_volume_zero)(void *data);

+	void *global_volume_zero_data;

+	/* Return 1 to terminate the module when global volume is set to zero. */

+};

+

+

+

+void _dumb_it_end_sigrenderer(sigrenderer_t *sigrenderer);

+void _dumb_it_unload_sigdata(sigdata_t *vsigdata);

+

+extern DUH_SIGTYPE_DESC _dumb_sigtype_it;

+

+

+

+#define XM_APPREGIO                0

+#define XM_PORTAMENTO_UP           1

+#define XM_PORTAMENTO_DOWN         2

+#define XM_TONE_PORTAMENTO         3

+#define XM_VIBRATO                 4

+#define XM_VOLSLIDE_TONEPORTA      5

+#define XM_VOLSLIDE_VIBRATO        6

+#define XM_TREMOLO                 7

+#define XM_SET_PANNING             8

+#define XM_SAMPLE_OFFSET           9

+#define XM_VOLUME_SLIDE            10 /* A */

+#define XM_POSITION_JUMP           11 /* B */

+#define XM_SET_CHANNEL_VOLUME      12 /* C */

+#define XM_PATTERN_BREAK           13 /* D */

+#define XM_E                       14 /* E */

+#define XM_SET_TEMPO_BPM           15 /* F */

+#define XM_SET_GLOBAL_VOLUME       16 /* G */

+#define XM_GLOBAL_VOLUME_SLIDE     17 /* H */

+#define XM_KEY_OFF                 20 /* K (undocumented) */

+#define XM_SET_ENVELOPE_POSITION   21 /* L */

+#define XM_PANNING_SLIDE           25 /* P */

+#define XM_MULTI_RETRIG            27 /* R */

+#define XM_TREMOR                  29 /* T */

+#define XM_X                       33 /* X */

+#define XM_N_EFFECTS               (10+26)

+

+#define XM_E_SET_FILTER            0x0

+#define XM_E_FINE_PORTA_UP         0x1

+#define XM_E_FINE_PORTA_DOWN       0x2

+#define XM_E_SET_GLISSANDO_CONTROL 0x3

+#define XM_E_SET_VIBRATO_CONTROL   0x4

+#define XM_E_SET_FINETUNE          0x5

+#define XM_E_SET_LOOP              0x6

+#define XM_E_SET_TREMOLO_CONTROL   0x7

+#define XM_E_SET_PANNING           0x8

+#define XM_E_RETRIG_NOTE           0x9

+#define XM_E_FINE_VOLSLIDE_UP      0xA

+#define XM_E_FINE_VOLSLIDE_DOWN    0xB

+#define XM_E_NOTE_CUT              0xC

+#define XM_E_NOTE_DELAY            0xD

+#define XM_E_PATTERN_DELAY         0xE

+

+#define XM_X_EXTRAFINE_PORTA_UP    1

+#define XM_X_EXTRAFINE_PORTA_DOWN  2

+

+/* To make my life a bit simpler during conversion, effect E:xy is converted

+ * to effect number EBASE+x:y. The same applies to effect X, and IT's S. That

+ * way, these effects can be manipulated like regular effects.

+ */

+#define EBASE              (XM_N_EFFECTS)

+#define XBASE              (EBASE+16)

+#define SBASE              (IT_N_EFFECTS)

+

+#define EFFECT_VALUE(x, y) (((x)<<4)|(y))

+#define HIGH(v)            ((v)>>4)

+#define LOW(v)             ((v)&0x0F)

+#define SET_HIGH(v, x)     v = (((x)<<4)|((v)&0x0F))

+#define SET_LOW(v, y)      v = (((v)&0xF0)|(y))

+#define BCD_TO_NORMAL(v)   (HIGH(v)*10+LOW(v))

+

+

+

+#if 0

+unsigned char **_dumb_malloc2(int w, int h);

+void _dumb_free2(unsigned char **line);

+#endif

+

+void _dumb_it_xm_convert_effect(int effect, int value, IT_ENTRY *entry, int mod);

+int _dumb_it_fix_invalid_orders(DUMB_IT_SIGDATA *sigdata);

+

+

+#define PTM_APPREGIO                0

+#define PTM_PORTAMENTO_UP           1

+#define PTM_PORTAMENTO_DOWN         2

+#define PTM_TONE_PORTAMENTO         3

+#define PTM_VIBRATO                 4

+#define PTM_VOLSLIDE_TONEPORTA      5

+#define PTM_VOLSLIDE_VIBRATO        6

+#define PTM_TREMOLO                 7

+#define PTM_SAMPLE_OFFSET           9

+#define PTM_VOLUME_SLIDE            10 /* A */

+#define PTM_POSITION_JUMP           11 /* B */

+#define PTM_SET_CHANNEL_VOLUME      12 /* C */

+#define PTM_PATTERN_BREAK           13 /* D */

+#define PTM_E                       14 /* E */

+#define PTM_SET_TEMPO_BPM           15 /* F */

+#define PTM_SET_GLOBAL_VOLUME       16 /* G */

+#define PTM_RETRIGGER               17 /* H */

+#define PTM_FINE_VIBRATO            18 /* I */

+#define PTM_NOTE_SLIDE_UP           19 /* J */

+#define PTM_NOTE_SLIDE_DOWN         20 /* K */

+#define PTM_NOTE_SLIDE_UP_RETRIG    21 /* L */

+#define PTM_NOTE_SLIDE_DOWN_RETRIG  22 /* M */

+#define PTM_N_EFFECTS               23

+

+#define PTM_E_FINE_PORTA_DOWN       0x1

+#define PTM_E_FINE_PORTA_UP         0x2

+#define PTM_E_SET_VIBRATO_CONTROL   0x4

+#define PTM_E_SET_FINETUNE          0x5

+#define PTM_E_SET_LOOP              0x6

+#define PTM_E_SET_TREMOLO_CONTROL   0x7

+#define PTM_E_SET_PANNING           0x8

+#define PTM_E_RETRIG_NOTE           0x9

+#define PTM_E_FINE_VOLSLIDE_UP      0xA

+#define PTM_E_FINE_VOLSLIDE_DOWN    0xB

+#define PTM_E_NOTE_CUT              0xC

+#define PTM_E_NOTE_DELAY            0xD

+#define PTM_E_PATTERN_DELAY         0xE

+

+/* To make my life a bit simpler during conversion, effect E:xy is converted

+ * to effect number EBASE+x:y. The same applies to effect X, and IT's S. That

+ * way, these effects can be manipulated like regular effects.

+ */

+#define PTM_EBASE              (PTM_N_EFFECTS)

+

+void _dumb_it_ptm_convert_effect(int effect, int value, IT_ENTRY *entry);

+

+long _dumb_it_read_sample_data_adpcm4(IT_SAMPLE *sample, DUMBFILE *f);

+

+#define min(x,y) ((x)<(y)?(x):(y))

+#define max(x,y) ((x)>(y)?(x):(y))

+

+#endif /* INTERNAL_IT_H */

diff --git a/plugins/dumb/dumb-kode54/include/internal/riff.h b/plugins/dumb/dumb-kode54/include/internal/riff.h
new file mode 100644
index 00000000..344a24ea
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/include/internal/riff.h
@@ -0,0 +1,21 @@
+#ifndef RIFF_H

+#define RIFF_H

+

+struct riff_chunk

+{

+	unsigned type;

+	void * data;

+	unsigned size;

+};

+

+struct riff

+{

+	unsigned type;

+	unsigned chunk_count;

+	struct riff_chunk * chunks;

+};

+

+struct riff * riff_parse( unsigned char *, unsigned size, unsigned proper );

+void riff_free( struct riff * );

+

+#endif

diff --git a/plugins/dumb/dumb-kode54/licence.txt b/plugins/dumb/dumb-kode54/licence.txt
new file mode 100644
index 00000000..506ec17b
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/licence.txt
@@ -0,0 +1,54 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * licence.txt - Conditions for use of DUMB.          / / \  \

+ *                                                   | <  /   \_

+ * If you do not agree to these terms, please        |  \/ /\   /

+ * do not use DUMB.                                   \_  /  > /

+ *                                                      | \ / /

+ * Information in [brackets] is provided to aid         |  ' /

+ * interpretation of the licence.                        \__/

+ */

+

+

+Dynamic Universal Music Bibliotheque

+

+Copyright (C) 2001-2003 Ben Davis, Robert J Ohannessian and Julien Cugniere

+

+This software is provided 'as-is', without any express or implied warranty.

+In no event shall the authors be held liable for any damages arising from the

+use of this software.

+

+Permission is granted to anyone to use this software for any purpose,

+including commercial applications, and to alter it and redistribute it

+freely, subject to the following restrictions:

+

+1. The origin of this software must not be misrepresented; you must not claim

+   that you wrote the original software. If you use this software in a

+   product, you are requested to acknowledge its use in the product

+   documentation, along with details on where to get an unmodified version of

+   this software, but this is not a strict requirement.

+

+   [Note that the above point asks for a link to DUMB, not just a mention.

+   Googling for DUMB doesn't help much! The URL is "http://dumb.sf.net/".]

+

+   [The only reason why the link is not strictly required is that such a

+   requirement prevents DUMB from being used in projects with certain other

+   licences, notably the GPL. See http://www.gnu.org/philosophy/bsd.html .]

+

+2. Altered source versions must be plainly marked as such, and must not be

+   misrepresented as being the original software.

+

+3. This notice may not be removed from or altered in any source distribution.

+

+4. If you are using the Program in someone else's bedroom at any Monday

+   3:05 PM, you are not allowed to modify the Program for ten minutes. [This

+   clause provided by Inphernic; every licence should contain at least one

+   clause, the reasoning behind which is far from obvious.]

diff --git a/plugins/dumb/dumb-kode54/make/Makefile.am b/plugins/dumb/dumb-kode54/make/Makefile.am
new file mode 100644
index 00000000..b82e0847
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/make/Makefile.am
@@ -0,0 +1,8 @@
+EXTRA_DIST = \

+	config.bat \

+	config.sh \

+	djgpp.inc \

+	dumbask.c \

+	Makefile.inc \

+	mingw.inc \

+	unix.inc

diff --git a/plugins/dumb/dumb-kode54/make/Makefile.inc b/plugins/dumb/dumb-kode54/make/Makefile.inc
new file mode 100644
index 00000000..d7e276cd
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/make/Makefile.inc
@@ -0,0 +1,39 @@
+# This file contains the main rules for compiling the library. It is included

+# twice with different values for CFLAGS and OBJDIR, so the optimised and

+# debugging libraries are both built.

+

+CORE_OBJECTS := $(addprefix $(OBJDIR)/, $(notdir $(patsubst %.c, %.o, $(CORE_MODULES))))

+ALLEGRO_OBJECTS := $(addprefix $(OBJDIR)/, $(notdir $(patsubst %.c, %.o, $(ALLEGRO_MODULES))))

+

+

+# Pass the current value of CFLAGS through to the commands. Or, more

+# accurately, create a local copy of the current CFLAGS variable. This is

+# necessary because Make doesn't expand variables in commands until they are

+# executed.

+$(CORE_LIB_FILE): CFLAGS := $(CFLAGS)

+$(ALLEGRO_LIB_FILE): CFLAGS := $(CFLAGS)

+

+

+$(OBJDIR)/%.o: src/core/%.c include/dumb.h include/internal/dumb.h

+	$(CC) $(CFLAGS) -c -o $@ $<

+

+$(OBJDIR)/%.o: src/helpers/%.c include/dumb.h

+	$(CC) $(CFLAGS) -c -o $@ $<

+

+$(OBJDIR)/resample.o: src/helpers/resample.inc

+

+$(OBJDIR)/%.o: src/it/%.c include/dumb.h include/internal/it.h

+	$(CC) $(CFLAGS) -c -o $@ $<

+

+$(OBJDIR)/%.o: src/sigtypes/%.c include/dumb.h

+	$(CC) $(CFLAGS) -c -o $@ $<

+

+$(OBJDIR)/%.o: src/allegro/%.c include/aldumb.h include/dumb.h \

+                      include/internal/aldumb.h include/internal/dumb.h

+	$(CC) $(CFLAGS) $(WFLAGS_ALLEGRO) -c -o $@ $<

+

+$(CORE_LIB_FILE): $(CORE_OBJECTS)

+	$(AR) rs $@ $^

+

+$(ALLEGRO_LIB_FILE): $(ALLEGRO_OBJECTS)

+	$(AR) rs $@ $^

diff --git a/plugins/dumb/dumb-kode54/make/config.bat b/plugins/dumb/dumb-kode54/make/config.bat
new file mode 100644
index 00000000..5c5f3272
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/make/config.bat
@@ -0,0 +1,33 @@
+@ECHO OFF

+

+REM This file does an interactive configuration for users of DOS and Windows.

+REM It creates a config.txt file for inclusion in the Makefile. This batch

+REM file should be run indirectly through the 'make config' target (or the

+REM 'make' target the first time).

+

+IF EXIST make\dumbask.exe GOTO dumbaskok

+ECHO You should not be running this directly! Use 'make' or 'make config'.

+GOTO end

+:dumbaskok

+

+make\dumbask.exe "Would you like to compile DUMB for DJGPP or MinGW (D/M)? " DM

+IF ERRORLEVEL 1 GOTO mingw

+ECHO include make/djgpp.inc>make\config.tmp

+GOTO djgpp

+:mingw

+ECHO include make/mingw.inc>make\config.tmp

+:djgpp

+

+ECHO ALL_TARGETS := core core-examples core-headers>>make\config.tmp

+

+make\dumbask.exe "Would you like support for Allegro (Y/N)? "

+IF NOT ERRORLEVEL 1 ECHO ALL_TARGETS += allegro allegro-examples allegro-headers>>make\config.tmp

+

+IF EXIST make\config.txt DEL make\config.txt

+REN make\config.tmp config.txt

+

+ECHO Configuration complete.

+ECHO Run 'make config' to change it in the future.

+PAUSE

+

+:end

diff --git a/plugins/dumb/dumb-kode54/make/config.sh b/plugins/dumb/dumb-kode54/make/config.sh
new file mode 100644
index 00000000..923b3ccc
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/make/config.sh
@@ -0,0 +1,35 @@
+#!/bin/sh

+

+# This file does an interactive configuration for users of Unix-like systems.

+# It creates a config.txt file for inclusion in the Makefile. This script

+# should be run indirectly through the 'make config' target (or the 'make'

+# target the first time).

+

+if [ ! -e make/dumbask ]; then

+  echo "You should not be running this directly! Use 'make' or 'make config'."

+  exit

+fi

+

+echo 'include make/unix.inc' > make/config.tmp

+

+echo 'ALL_TARGETS := core core-examples core-headers' >> make/config.tmp

+

+if make/dumbask 'Would you like support for Allegro (Y/N)? ' YN; then

+  echo 'ALL_TARGETS += allegro allegro-examples allegro-headers' >> make/config.tmp

+fi

+

+

+if [ ! -z $DEFAULT_PREFIX ]; then

+echo "Please specify an installation prefix (default $DEFAULT_PREFIX)."

+echo -n '> '

+read PREFIX

+if [ -z $PREFIX ]; then PREFIX=$DEFAULT_PREFIX; fi

+echo "PREFIX := $PREFIX" >> make/config.tmp

+fi

+

+mv -f make/config.tmp make/config.txt

+

+echo 'Configuration complete.'

+echo "Run 'make config' to change it in the future."

+echo -n 'Press Enter to continue ... '

+read dummy

diff --git a/plugins/dumb/dumb-kode54/make/djgpp.inc b/plugins/dumb/dumb-kode54/make/djgpp.inc
new file mode 100644
index 00000000..009533ce
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/make/djgpp.inc
@@ -0,0 +1,28 @@
+# This file contains DJGPP-specific definitions. It will be included by the

+# main Makefile when you compile with DJGPP.

+

+PLATFORM := djgpp

+

+APOST := \'

+

+# Macro for replacing / with \ where necessary. Usage: $(call FIX,path)

+FIX = $(subst /,\,$(subst /*,\\\*,$(1)))

+

+ECHO = @$(COMSPEC) /C ECHO $(1)

+# Note: the following two macros only work for single files!

+DELETE = $(COMSPEC) /C DEL $(call FIX,$(1))

+COPY = $(COMSPEC) /C COPY $(call FIX,$(1)) $(call FIX,$(2))

+

+EXE_SUFFIX := .exe

+

+LINK_MATH :=

+LINK_ALLEGRO := -lalleg

+

+ifndef DJDIR

+.PHONY: error

+error:

+	$(call ECHO,Your DJDIR environment variable is not set!)

+	$(call ECHO,Please refer to DJGPP's documentation and install it properly.)

+endif

+

+PREFIX := $(DJDIR)

diff --git a/plugins/dumb/dumb-kode54/make/dumbask.c b/plugins/dumb/dumb-kode54/make/dumbask.c
new file mode 100644
index 00000000..8c1b3757
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/make/dumbask.c
@@ -0,0 +1,30 @@
+#include <stdio.h>

+#include <ctype.h>

+

+

+int main(int argc, const char *const argv[])

+{

+	const char *message = argv[1];

+	const char *options;

+

+	if (!message) {

+		fprintf(stderr,

+			"dumbask: asks the user a question.\n"

+			"Specify a message as the first argument (quoted!).\n"

+			"You may optionally specify the choices as the second argument.\n"

+			"Default choices are YN. Exit code is 0 for first, 1 for second, etc.\n");

+		return 0;

+	}

+

+	options = argv[2] ? : "YN"; /* I _had_ to use a GNU Extension _somewhere_! */

+

+	printf("%s", argv[1]);

+

+	for (;;) {

+		char c = toupper(getchar());

+		int i;

+		for (i = 0; options[i]; i++)

+			if (c == toupper(options[i]))

+				return i;

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/make/mingw.inc b/plugins/dumb/dumb-kode54/make/mingw.inc
new file mode 100644
index 00000000..065f2e5f
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/make/mingw.inc
@@ -0,0 +1,28 @@
+# This file contains MinGW-specific definitions. It will be included by the

+# main Makefile when you compile with MinGW.

+

+PLATFORM := mingw

+

+APOST := \'

+

+# Macro for replacing / with \ where necessary. Usage: $(call FIX,path)

+FIX = $(subst /,\,$(subst /*,\\\*,$(1)))

+

+ECHO = @$(COMSPEC) /C ECHO $(1)

+# Note: the following two macros only work for single files!

+DELETE = $(COMSPEC) /C DEL $(call FIX,$(1))

+COPY = $(COMSPEC) /C COPY $(call FIX,$(1)) $(call FIX,$(2))

+

+EXE_SUFFIX := .exe

+

+LINK_MATH :=

+LINK_ALLEGRO := -lalleg

+

+ifndef MINGDIR

+.PHONY: error

+error:

+	$(call ECHO,Your MINGDIR environment variable is not set!)

+	$(call ECHO,Please set it to point to the directory containing your MinGW installation.)

+endif

+

+PREFIX := $(MINGDIR)

diff --git a/plugins/dumb/dumb-kode54/make/unix.inc b/plugins/dumb/dumb-kode54/make/unix.inc
new file mode 100644
index 00000000..2ab5259a
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/make/unix.inc
@@ -0,0 +1,20 @@
+# This file contains definitions suitable for Unix-compatible systems. It will

+# be included by the main Makefile when you compile on such a system.

+

+PLATFORM := unix

+

+APOST := \'

+

+# Macro that on DOS and Windows would replace / with \. Usage: $(call FIX,path)

+FIX = $(1)

+

+ECHO = @echo $(1)

+DELETE = rm -f $(1)

+COPY = cp $(1) $(2)

+

+EXE_SUFFIX :=

+

+LINK_MATH := -lm

+LINK_ALLEGRO := `allegro-config --libs`

+

+# PREFIX is set by config.sh.

diff --git a/plugins/dumb/dumb-kode54/readme.txt b/plugins/dumb/dumb-kode54/readme.txt
new file mode 100644
index 00000000..f8517bac
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/readme.txt
@@ -0,0 +1,421 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readme.txt - General information on DUMB.          / / \  \

+ *                                                   | <  /   \_

+ *                                                   |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+********************

+*** Introduction ***

+********************

+

+

+Thank you for downloading DUMB! You should have the following documentation:

+

+   readme.txt    - This file

+   licence.txt   - Conditions for the use of this software

+   release.txt   - Release notes and changes for this and past releases

+   docs/

+     howto.txt   - Step-by-step instructions on adding DUMB to your project

+     faq.txt     - Frequently asked questions and answers to them

+     dumb.txt    - DUMB library reference

+     deprec.txt  - Information about deprecated parts of the API

+     ptr.txt     - Quick introduction to pointers for those who need it

+     fnptr.txt   - Explanation of function pointers for those who need it

+     modplug.txt - Our official position regarding ModPlug Tracker

+

+This file will help you get DUMB set up. If you have not yet done so, please

+read licence.txt and release.txt before proceeding. After you've got DUMB set

+up, please refer to the files in the docs/ directory at your convenience. I

+recommend you start with howto.txt.

+

+

+****************

+*** Features ***

+****************

+

+

+Here is the statutory feature list:

+

+- Freeware

+

+- Supports playback of IT, XM, S3M and MOD files

+

+- Faithful to the original trackers, especially IT; if it plays your module

+  wrongly, please tell me so I can fix the bug! (But please don't complain

+  about differences between DUMB and ModPlug Tracker; see docs/modplug.txt)

+

+- Accurate support for low-pass resonant filters for IT files

+

+- Very accurate timing and pitching; completely deterministic playback

+

+- Click removal

+

+- Facility to embed music files in other files (e.g. Allegro datafiles)

+

+- Three resampling quality settings: aliasing, linear interpolation and cubic

+  interpolation

+

+- Number of samples playing at once can be limited to reduce processor usage,

+  but samples will come back in when other louder ones stop

+

+- All notes will be present and correct even if you start a piece of music in

+  the middle

+

+- Fast seeking to any point before the music first loops (seeking time

+  increases beyond this point)

+

+- Audio generated can be used in any way; DUMB does not necessarily send it

+  straight to a sound output system

+

+- Makefile provided for DJGPP, MinGW, Linux, BeOS and Mac OS X; project file

+  provided for MSVC 6 (please contact me if you'd like to submit or request

+  support for a new platform; the code itself should port anywhere that has a

+  32-bit C compiler)

+

+- Can be used with Allegro, can be used without (if you'd like to help make

+  DUMB more approachable to people who aren't using Allegro, please contact

+  me)

+

+

+*********************

+*** What you need ***

+*********************

+

+

+To use DUMB, you need a 32-bit C compiler (GCC and MSVC are fine). If you

+have Allegro, DUMB can integrate with its audio streams and datafiles, making

+your life easier. If you do not wish to use Allegro, you will have to do some

+work to get music playing back. The 'dumbplay' example program requires

+Allegro.

+

+   Allegro - http://alleg.sf.net/

+

+Neil Walker has kindly uploaded some DUMB binaries at

+http://retrospec.sgn.net/allegro/ . They may not always be up to date, so you

+should try to compile it yourself first.

+

+

+**********************************************

+*** How to set DUMB up with DJGPP or MinGW ***

+**********************************************

+

+

+You should have got the .zip version. If for some reason you got the .tar.gz

+version instead, you may have to convert make/config.bat to DOS text file

+format. WinZip does this automatically by default. Otherwise, loading it into

+MS EDIT and saving it again should do the trick. You will have to do the same

+for any files you want to view in Windows Notepad. If you have problems, just

+go and download the .zip instead.

+

+Make sure you preserved the directory structure when you extracted DUMB from

+the archive. Most unzipping programs will do this by default, but pkunzip

+requires you to pass -d. If not, please delete DUMB and extract it again

+properly.

+

+If you are using Windows, open an MS-DOS Prompt or a Windows Command Line.

+Change to the directory into which you unzipped DUMB.

+

+Type the following:

+

+   make

+

+DUMB will ask you whether you wish to compile for DJGPP or MinGW. Then it

+will ask you whether you want support for Allegro. (You have to have made and

+installed Allegro's optimised library for this to work.) Finally, it will

+compile optimised and debugging builds of DUMB, along with the example

+programs. When it has finished, run the following to install the libraries:

+

+   make install

+

+All done! If you ever need the configuration again (e.g. if you compiled for

+DJGPP before and you want to compile for MinGW now), run the following:

+

+   make config

+

+See the comments in the makefile for other targets.

+

+Note: the makefile will only work properly if you have COMSPEC or ComSpec set

+to point to command.com or cmd.exe. If you set it to point to a Unix-style

+shell, the makefile won't work.

+

+Please let me know if you have any trouble.

+

+Scroll down for information on the example programs. Refer to docs/howto.txt

+when you are ready to start programming with DUMB. If you use DUMB in a game,

+let me know - I might decide to place a link to your game on DUMB's website!

+

+

+******************************************************

+*** How to set DUMB up with Microsoft Visual C++ 6 ***

+******************************************************

+

+

+You should have got the .zip version. If for some reason you got the .tar.gz

+version instead, you may have to convert some files to DOS text file format.

+WinZip does this automatically by default. Otherwise, loading such files into

+MS EDIT and saving them again should do the trick. You will have to do this

+for any files you want to view in Windows Notepad. If you have problems, just

+go and download the .zip instead.

+

+Make sure you preserved the directory structure when you extracted DUMB from

+the archive. Most unzipping programs will do this by default, but pkunzip

+requires you to pass -d. If not, please delete DUMB and extract it again

+properly.

+

+DUMB now comes with a project file for Microsoft Visual C++ 6. To add DUMB to

+your project:

+

+1. Open your project in VC++.

+2. Select Project|Insert Project into Workspace...

+3. Navigate to the dumb\vc6 directory, and select dumb.dsp.

+4. Select Build|Set Active Configuration..., and reselect one of your

+   project's configurations.

+5. Select Project|Dependencies... and ensure your project is dependent on

+   DUMB.

+6. Select Project|Settings..., Settings for: All Configurations, C/C++ tab,

+   Preprocessor category. Add the DUMB include directory to the Additional

+   Include Directories box.

+7. Ensure that for all the projects in the workspace (or more likely just all

+   the projects in a particular dependency chain) the run-time libraries are

+   the same. That's in Project|Settings, C/C++ tab, Code generation category,

+   Use run-time library dropdown. The settings for Release and Debug are

+   separate, so you'll have to change them one at a time. Exactly which run-

+   time library you use will depend on what you need; it doesn't appear that

+   DUMB has any particular requirements, so set it to whatever you're using

+   now.

+

+Good thing you only have to do all that once ...

+

+If you have the Intel compiler installed, it will - well, should - be used to

+compile DUMB. The only setting I added is /QxiM. This allows the compiler to

+use PPro and MMX instructions, and so when compiling with Intel the resultant

+EXE will require a Pentium II or greater. I don't think this is unreasonable.

+After all, it is 2003 :)

+

+If you don't have the Intel compiler, VC will compile DUMB as normal.

+

+This project file and these instructions were provided by Tom Seddon (I hope

+I got his name right; I had to guess it from his e-mail address!). They are

+untested by me. If you have problems, check the download page at

+http://dumb.sf.net/ to see if they are addressed; failing that, direct

+queries to me and I'll try to figure them out.

+

+When you are ready to start using DUMB, refer to docs/howto.txt. If you use

+DUMB in a game, let me know - I might decide to place a link to your game on

+DUMB's website!

+

+

+********************************************************************

+*** How to set DUMB up on Linux, BeOS and possibly even Mac OS X ***

+********************************************************************

+

+

+You should have got the .tar.gz version. If for some reason you got the .zip

+version instead, you may have to use dtou on some or all of the text files.

+If you have problems, just go and download the .tar.gz instead.

+

+First, run the following command as a normal user:

+

+   make

+

+You will be asked whether you want Allegro support. Then, unless you are on

+BeOS, you will be asked where you'd like DUMB to install its headers,

+libraries and examples (which will go in the include/, lib/ and bin/

+subdirectories of the prefix you specify). BeOS has fixed locations for these

+files. Once you have specified these pieces of information, the optimised and

+debugging builds of DUMB will be compiled, along with the examples. When it

+has finished, you can install them with:

+

+   make install

+

+You may need to be root for this to work. It depends on the prefix you chose.

+

+Note: the makefile will only work if COMSPEC and ComSpec are both undefined.

+If either of these is defined, the makefile will try to build for a Windows

+system, and will fail.

+

+Please let me know if you have any trouble.

+

+Information on the example programs is just below. Refer to docs/howto.txt

+when you are ready to start programming with DUMB. If you use DUMB in a game,

+let me know - I might decide to place a link to your game on DUMB's website!

+

+

+****************************

+*** The example programs ***

+****************************

+

+

+Two example programs are provided. On DOS and Windows, you can find them in

+the examples subdirectory. On other systems they will be installed system-

+wide.

+

+dumbplay

+   This program will only be built if you have Allegro. Pass it the filename

+   of an IT, XM, S3M or MOD file, and it will play it. It's not a polished

+   player with real-time threading or anything - so don't complain about it

+   stuttering while you use other programs - but it does show DUMB's fidelity

+   nicely. You can control the playback quality by editing dumb.ini, which

+   must be in the current working directory. (This is a flaw for systems

+   where the program is installed system-wide, but it is non-fatal.) Have a

+   look at the examples/dumb.ini file for further information.

+

+dumbout

+   This program does not need Allegro. You can use it to stream an IT, XM,

+   S3M or MOD file to raw PCM. This can be used as input to an encoder like

+   oggenc (with appropriate command-line options), or it can be sent to a

+   .pcm file which can be read by any respectable waveform editor. No .wav

+   support yet, sorry. This program is also convenient for timing DUMB.

+   Compare the time it takes to render a module with the module's playing

+   time! dumbout doesn't try to read any configuration file; the options are

+   set on the command line.

+

+

+*********************************************

+*** Downloading music or writing your own ***

+*********************************************

+

+

+If you would like to compose your own music modules, then first I must offer

+a word of warning: not everyone is capable of composing music. Do not assume

+you will be able to learn the art. By all means have a go; if you can learn

+to play tunes on the computer keyboard, you're well on the way to being a

+composer!

+

+The best programs for the job are the trackers that pioneered the file

+formats:

+

+   Impulse Tracker - IT files - http://www.noisemusic.org/it/

+   Fast Tracker II - XM files - http://www.gwinternet.com/music/ft2/

+   Scream Tracker 3 - S3M files -

+          http://www.united-trackers.org/resources/software/screamtracker.htm

+

+MOD files come from the Amiga; I do not know what PC tracker to recommend for

+editing these. If you know of one, let me know! In the meantime, I would

+recommend using a more advanced file format. However, don't convert your

+existing MODs just for the sake of it.

+

+Note that Fast Tracker II is Shareware. It arguably offers the best

+interface, but the IT file format is more powerful and better defined.

+Impulse Tracker and Scream Tracker 3 are Freeware. DUMB is likely to be at

+its best with IT files.

+

+These editors are DOS programs. Users of DOS-incapable operating systems may

+like to try ModPlug Tracker, but should read docs/modplug.txt before using it

+for any serious work. If you use a different operating system, or if you know

+of any module editors for Windows that are more faithful to the original

+trackers' playback, please give me some links so I can put them here!

+

+   ModPlug Tracker - http://www.modplug.com/

+

+BEWARE OF WINAMP! Although it's excellent for MP3s, it is notorious for being

+one of the worst module players in existence; very few modules play correctly

+with it. There are plug-ins available to improve Winamp's module support, for

+example WSP.

+

+   Winamp - http://www.winamp.com/

+   WSP - http://www.spytech.cz/index.php?sec=demo

+

+Samples and instruments are the building blocks of music modules. You can

+download samples at:

+

+   http://www.tump.net/

+

+If you would like to download module files composed by other people, check

+the following sites:

+

+   http://www.modarchive.com/

+   http://www.scene.org/

+   http://www.tump.net/

+   http://www.homemusic.cc/main.php

+   http://www.modplug.com/

+

+Once again, if you know of more sites where samples or module files are

+available for download, please let me know.

+

+If you wish to use someone's music in your game, please respect the

+composer's wishes. In general, you should ask the composer. Music that has

+been placed in the Public Domain can be used by anyone for anything, but it

+wouldn't do any harm to ask anyway if you know who the author is. In most

+cases the author will be thrilled, so don't hesitate!

+

+A note about converting modules from one format to another: don't do it,

+unless you are a musician and are prepared to go through the file and make

+sure everything sounds the way it should! The module formats are all slightly

+different, and converting from one format to another will usually do some

+damage.

+

+Instead, it is recommended that you allow DUMB to interpret the original file

+as it sees fit. DUMB may make mistakes (it does a lot of conversion on

+loading), but future versions of DUMB will be able to rectify these mistakes.

+On the other hand, if you convert the file, the damage is permanent.

+

+

+***********************

+*** Contact details ***

+***********************

+

+

+If you have trouble with DUMB, or want to contact me for any other reason, my

+e-mail address is given below. However, I may be able to help more if you

+come on to IRC EFnet #dumb.

+

+IRC stands for Internet Relay Chat, and is a type of chat network. Several

+such networks exist, and EFnet is a popular one. In order to connect to an

+IRC network, you first need an IRC client. Here are some:

+

+   http://www.xchat.org/

+   http://www.visualirc.net/beta.php

+   http://www.mirc.com/

+

+Getting on to IRC can be a steep cliff, but it is not insurmountable, and

+it's well worth it. Once you have set up the client software, you need to

+connect to a server. Here is a list of EFnet servers I have had success with.

+Type "/server" (without quotes), then a space, then the name of a server.

+

+   irc.homelien.no

+   irc.webgiro.se

+   efnet.vuurwerk.nl

+   efnet.demon.co.uk

+   irc.isdnet.fr

+   irc.prison.net

+

+If these servers do not work, visit http://efnet.org/ircdb/servers.php for a

+huge list of other EFnet servers to try.

+

+Once you're connected, type the following:

+

+   /join #dumb

+

+A window will appear, and you can ask your question. It should be clear

+what's going on from this point onwards. I am 'entheh'. Note that unlike many

+other nerds I am not always at my computer, so if I don't answer your

+question, don't take it personally! I will usually be able to read your

+question when I come back.

+

+

+******************

+*** Conclusion ***

+******************

+

+

+This is the conclusion.

+

+

+Ben Davis

+entheh@users.sf.net

+IRC EFnet #dumb

diff --git a/plugins/dumb/dumb-kode54/release.txt b/plugins/dumb/dumb-kode54/release.txt
new file mode 100644
index 00000000..cd164887
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/release.txt
@@ -0,0 +1,468 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * release.txt - Release notes for DUMB.              / / \  \

+ *                                                   | <  /   \_

+ *                                                   |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+******************************************

+*** DUMB v

+******************************************

+

+Pattern loop stuff improved; not quite right for XM files, but better than

+before

+

+say where ModPlug's source can be obtained

+

+Notes now cease to exist if they have faded out, even if they are still in

+the foreground. This means a new note will be started even if a Gxx occurs

+on the same row, as Impulse Tracker does in this scenario.

+

+XM key off fixed more: now the effect value acts as a delay, matching FT2

+

+Added dumb2wav example to convert mod files to WAV files.  (Chad

+Austin)

+

+Major update to VC6 build.  It builds every example as well as both

+dumb.lib and aldumb.lib.  (Chad Austin)

+

+Added first pass of the automake build.  Unix users can compile and

+install dumb with the standard "./configure && make && make install"

+dance.  Caveats: Allegro isn't searched for at configuration time, so

+the examples don't build.  The build also does not attempt to install

+aldumb.h.  (Chad Austin)

+

+For IT files, tone portamento didn't work properly when no note was playing.

+The effect value wasn't stored. Thanks to Maim from #trax on EFnet for

+discovering this bug.

+

+XM key off fixed - doesn't overwrite note any more

+

+tagging system added - title

+sample/instrument names/filenames

+more functions (n_samples n_instruments)

+

+made timing more accurate; this may affect length by a second or two ...

+

+Thanks to networm for valgrinding the new envelope handling code

+

+DUMB used to process the first row when you created the DUMB_IT_SIGRENDERER.

+This happened before you had a chance to install any callbacks. If an F00

+effect occurred on the first row, the music would stop immediately and the

+xm_speed_zero callback would be called if it were present. Unfortunately, it

+wasn't present, and the algorithm for calculating the length subsequently

+went into an endless loop while waiting for it. Worse still, the same

+algorithm accumulated data for fast seeking, and never stopped, so it pretty

+quickly consumed all the resources.

+

+DUMB will now not process the first row until you first request some samples,

+provided you pass zero for pos. Ironically, any MOD or XM file with F00 in

+the very first row won't play anyway! But at least such files won't crash the

+library now.

+

+    * The make/config.bat file, responsible for generating make/config.txt, wrote a crucial line to the wrong place, causing it to be left out of the file. As a result, the makefile would fail to install everything for Allegro users, and enter infinite recursion for other users. If you are trying to compile with DJGPP or MinGW, please download dumb-0.9.2-fixed.zip (linked below, and incidentally including the fix for the bug detailed in the next point).

+    * DUMB's makefile doesn't install the example programs on any platforms. (It is supposed to install them on all platforms except DOS and Windows.) You can fix this by editing Makefile and changing the one occurrence of $COMSPEC to $(COMSPEC). Alternatively you can run the example programs from the examples directory.

+    * There is a subtle bug that affects a few XM files. For instruments with no associated samples, the array mapping notes to samples is uninitialised. This becomes a problem if such instruments are then used, which does happen sometimes. On many systems, memory is initialised to zero when first given to a program (for security reasons), so the problem won't come up most of the time. However, on platforms like DOS where memory isn't initialised, or in programs that reuse memory later on (this includes the XMMS plug-in), a rogue note will occasionally play. If you are worried that this might happen to you, then use DUMB CVS or wait for the next release (which won't be for a while). If you have access to an i386 Linux system, you can use Valgrind on the 'dumbout' example program to determine whether your XM file causes DUMB to use uninitialised values.

+    * For IT files, DUMB breaks out of single-point envelope sustain loops one tick too early. The correct behaviour for multi-point sustain loops is yet to be determined. The worst that can happen is that notes may seem to be ever so slightly shorter than they should be, except in pathological cases. This bug has not yet been fixed in CVS.

+

+

+

+******************************************

+*** DUMB v0.9.2, released 2 April 2003 ***

+******************************************

+

+Yes, there really has been a release. This is not a day-late April fools'

+joke.

+

+DUMB's full name has changed! The old "Dedicated Universal Music

+Bastardisation" was rather silly, and not much more than a forced attempt at

+finding words beginning with D, U, M and B. I spent weeks and weeks browsing

+dictionaries and hopelessly asking others for bright ideas, until the

+brilliant Chris "Kitty Cat" Robinson came up with "Dynamic". I decided to

+keep the U as Universal, since a DUH struct can hold digital music in any

+format. Now all that remained was the B, but it didn't take me long to come

+up with Bibliotheque, which, despite looking French, is indeed considered an

+English word by Oxford English Dictionary Online, to which my university has

+a subscription. So there you have it - the name now makes sense.

+

+The two most significant additions to the project would have to be the new

+thread safety (with an important restriction, detailed in docs/dumb.txt), and

+the new build system. The silly 'makeall' and 'makecore' scripts are gone. If

+you are a GCC user, all you need do now is run 'make' and 'make install', as

+for other projects. You don't even have to run a 'fix' script any more! There

+are some caveats, which are covered in readme.txt. If you use Microsoft

+Visual C++ 6, you no longer need to obtain GCC and GNU Make - there is a

+project file just for you.

+

+Huge thanks go to Steve Terry for testing on Windows XP - about five times -

+and to lillo for testing on BeOS and Mac OS X. Thanks also to X-G for testing

+on a Windows system that has consistently posed problems for DUMB's old

+makefiles.

+

+There was a bug whereby al_poll_duh() would sometimes cause the music to

+resume playing if you called it after al_pause_duh(). Whether this was DUMB's

+fault for misusing Allegro's API, or a bug in Allegro, is unclear, but this

+release makes it work.

+

+In one of my projects, I found that my AL_DUH_PLAYER stopped playing when

+there were lots of other sound effects. In order to fix this, I programmed

+DUMB to set the priority of the stream's voice to 255, the maximum. I also

+added al_duh_set_priority(), so you can set the priority yourself if you need

+to.

+

+The resampling code has undergone a transformation. The bad news is that the

+linear average code is no longer in use. The good news is that where DUMB's

+resamplers used to require three extra samples' worth of memory to be

+allocated and initialised, it now copes with just the sample data. And it

+does a very good job at bouncing off loop points and otherwise hurtling

+around the sample. The resampling code is considerably more complicated, but

+the code that uses the resamplers is considerably simpler - and if you

+noticed a slight click in some bidirectionally looping samples, you'll be

+pleased to know that that click is gone!

+

+I have also devoted some effort to optimisation. It seemed hopeless for a

+while, but then I actually figured out a way of making it faster AND more

+accurate at the same time! DUMB is now quite a bit faster than it was, and it

+mixes not with 16-bit precision, but with 24-bit precision. (It used 32-bit

+integers all along, but the difference is that it now makes use of 256 times

+as much of the integer's range.)

+

+There have been the usual improvements to playback. The last release occurred

+rather too soon after I had fixed the XM effect memories; EAx and EBx, fine

+volume ramps, had been neglected. These are now handled properly.

+

+In previous versions of DUMB, muted channels in IT were actually played with

+surround sound panning (where the right-hand channel is inverted). This has

+been fixed, so muted channels will really be muted now.

+

+There were also some subtle problems with the way DUMB handled New Note

+Actions for IT files. It turned out that, in all releases of DUMB so far,

+pitch, filter and panning envelopes and sample vibrato were not being

+processed for any note that was forced into the background by a new note on

+the same channel! This only affected IT files. Not only has this been fixed,

+but envelope interpolation is much more accurate. Long trailing envelope-

+driven fade-outs sound a lot better now!

+

+Since panning and filter envelopes are more precise, extra fields have been

+added to the DUMB_IT_CHANNEL_STATE struct, used by

+dumb_it_sr_get_channel_state(). These fields hold the 'decimal' parts of the

+pan and filter cut-off. See dumb.txt for details.

+

+Mxx (set channel volume) now correctly only modifies the last note played on

+the channel, not any previous notes that have been forced into the background

+by New Note Actions, and filter effect processing is now closer to what

+Impulse Tracker does.

+

+The XM loader was slightly flawed and could crash on files containing samples

+with out-of-range loop points. One such file was given to me. This has been

+fixed.

+

+Finally, the legal stuff. Julien Cugniere has been added to the list of

+copyright owners. He deserves it, for all the work he did on the XM support!

+And the licence has been changed. You are no longer required to include a

+link to DUMB in a project that uses DUMB; the reasons for this relaxation are

+explained in licence.txt. However, the request is still there ...

+

+As usual, enjoy!

+

+

+**********************************************

+*** DUMB v0.9.1, released 19 December 2002 ***

+**********************************************

+

+Hi again! Lots to say this time, so I shall cut right to the chase.

+

+DUMB now supports Impulse Tracker's low-pass resonant filters! Huge thanks go

+to Jeffrey Lim, author of Impulse Tracker, for giving me what information he

+still had regarding the algorithm; to cut a long story short, modifying

+ModPlug Tracker's source code (which is in the Public Domain) led to an

+algorithm whose output matched Impulse Tracker's perfectly.

+

+Please note that ModPlug Tracker's filters as they stand do not match Impulse

+Tracker's, and I have no interest in supporting ModPlug Tracker's variant

+(especially not the integer rounding problems). Please see docs/modplug.txt,

+new in this release, for details.

+

+Thanks also go to Fatso Huuskonen for motivating me to add filter support,

+and providing me with several great IT files to test it with!

+

+The other important feature added for this release is click removal. Up until

+now, DUMB has generated clicks when cutting notes, starting samples in the

+middle, and so on. This version of DUMB will remove any such clicks. Note

+that DUMB does not use volume ramps to accomplish this; the algorithm will

+not take the bite out of the music!

+

+In other news, DUMB now supports sample vibrato for IT files, and instrument

+vibrato for XM files. A slight bug in New Note Action handling for IT files

+has been fixed; Note Fade will not break the sustain loops of the sample and

+envelope, as it did before. Tremor handling (Ixy) had a strange bug in it,

+which has been fixed.

+

+Support for XM files has been greatly enhanced. The XM envelope handling new

+in the last release contained a huge bug, resulting in notes seeming not to

+stop when they should; this has been fixed. Some XM files crashed DUMB, while

+others failed to load; these problems have been solved. Effect memories now

+work properly for XM and MOD files, to the best of my knowledge. Some other

+differences between IT and XM have been accounted for, most notably the

+Retrigger Note effects, Rxy and E9x.

+

+DUMB's sound quality and accuracy are not the only areas that have been

+enhanced. The API has been expanded, at last. You can now detect when a

+module loops, or make it play through just once. You can ask DUMB to inform

+you every time it generates some samples; this is useful for visualisation.

+For IT files, you can intercept the MIDI messages generated by Zxx macros,

+enabling you to synchronise your game with the music to some extent. (There

+is no such method for XM, S3M or MOD files yet; sorry. Also note that the

+function will be called before you actually hear the sound; I cannot improve

+this until DUMB has its own sound drivers, which won't be for a while.) You

+can query the current order and row. Finally, operations like changing the

+speed and tempo are now possible, and you can query the playback state on

+each channel.

+

+Some parts of DUMB's API have been deprecated. Simple programs that use

+Allegro will be unaffected, but if you get some compiler warnings or errors,

+please review docs/deprec.txt. This file explains why those parts of the API

+were deprecated, and tells you how to adapt your code; the changes you need

+to make are straightforward. Sorry for the inconvenience.

+

+For various reasons, I have made DUMB's makefiles use different compiler

+flags depending on your GCC version (unless you are using MSVC). There is no

+elegant way of getting the makefiles to detect when GCC is upgraded. If you

+upgrade GCC, you should execute 'make clean' in order to make DUMB detect the

+GCC version again. Otherwise you may get some annoying error messages. (It is

+wise to do this in any case, so that all the object files are built with the

+same GCC version.)

+

+DUMB's example players have been unified into a single player called

+'dumbplay'. The player has been enhanced to display messages when the music

+loops, and when XM and MOD files freeze (effect F00; more information on this

+in docs/howto.txt).

+

+Finally, as noted on DUMB's website, the release notes from the last release

+were inaccurate. It has been verified that DUMBOGG v0.5 does still work with

+that release, and still works with this release. The esoteric DUMBOGG v0.6

+has not been created yet, since DUMBOGG v0.5 still works.

+

+Please scroll down and read through the indented paragraphs in the notes for

+the last release; they are relevant for this release too.

+

+That's all folks! Until next time.

+

+

+*******************************************

+*** DUMB v0.9, released 16 October 2002 ***

+*******************************************

+

+MOD support is here! DUMB now supports all four of the common module formats.

+As usual, there have also been some improvements to the way modules are

+played back. Most notably, handling of tone portamento in IT files has been

+improved a lot, and XM envelopes are now processed correctly.

+

+The other major change is that DUMB now does a dummy run through each module

+on loading. It stores the playback state at thirty-second intervals. It stops

+when the module first loops, and then stores the playback time. This results

+in a slightly longer load time and a greater memory overhead, but seeking is

+faster (to any point before the module first loops) and the length is

+calculated! duh_get_length() will return this and is now documented in

+docs/howto.txt and docs/dumb.txt.

+

+DUMB's build process has been changed to use 'mingw' wherever it used

+'mingw32' before; some directories have been renamed, and the 'fix' command

+you had to run for MinGW has been changed from 'fix mingw32' to 'fix mingw'.

+

+Last time, I directed you to scroll down and read the notes from a past

+release, but ignore this point, and that point applies to something else, and

+so on. Did anyone do so? Well, if you're reading this at all, you probably

+did. Nevertheless, this time I shall be much less confusing and restate any

+relevant information. So the least you can do is read it!

+

+- If your program ever aborts with exit code 37 while loading an IT file,

+  PLEASE LET ME KNOW! The IT file in question has a stereo compressed sample

+  in it, and the format is unspecified for this case (Impulse Tracker itself

+  doesn't use stereo samples at all). I will need the IT file in question,

+  and any information you can give me about how the IT file was created (e.g.

+  what program). (If you don't get to see an exit code, let me know anyway.)

+

+- If your program ever outputs a line resembling "Inst 01 Env: 0,64 8,32

+  15,48" to stderr while loading an IT file, PLEASE LET ME KNOW! You have an

+  old IT file (saved by an Impulse Tracker version older than 2.00), and

+  support for such files is STILL untested.

+

+- Not all parts of DUMB's API are documented yet. You will find some

+  functions in dumb.h which are not listed in docs/dumb.txt; the reason is

+  that these functions still need work and will probably change. If you

+  really, really want to use them, talk to me first (IRC EFnet #dumb is a

+  good place for this; see readme.txt for details on using IRC). I intend to

+  finalise and document the whole of DUMB's API for Version 1.0.

+

+There have been some changes to the naming conventions in DUMB's undocumented

+API. DUMBOGG v0.5 will not work with this and subsequent releases of DUMB;

+please upgrade to DUMBOGG v0.6. These changes should not break anything in

+your own code, since you didn't use those parts of the API, did you ;)

+

+There is still a great deal of work to be done before DUMB's API can be

+finalised, and thus it will be a while before DUMB v1.0 comes out. It should

+be worth the wait. In the meantime, there will be 0.9.x releases with

+additional functionality, improved playback, and possibly support for some

+extra file formats.

+

+Finally I should like to offer an apology; there is a strong possibility that

+some of DUMB's official API will change in the near future. There will not be

+any drastic changes, and the corresponding changes to your source code will

+be simple enough. If I didn't make these changes, DUMB's API would start to

+become limited, or messy, or both, so it's for the better. I apologise in

+advance for this.

+

+Now scroll down and read the notes for the first r... oh wait, we already did

+that. I guess that's it then. You can stop reading now.

+

+Right after you've read this.

+

+And this.

+

+Off you go.

+

+Bye.

+

+

+********************************************

+*** DUMB v0.8.1, released 11 August 2002 ***

+********************************************

+

+This is a minor release that fixes a few bugs. One of these bugs, however,

+was pretty serious. dumb_register_dat_xm() was never coded! It was prototyped

+in aldumb.h, so code would compile, but there would be an unresolved symbol

+at the linking stage. This has been fixed.

+

+Platforms other than Unix did not have a working 'make veryclean' target;

+this has been fixed. In addition, the makefiles now use 'xcopy' instead of

+'copy', since on some systems GNU Make seems to have trouble calling commands

+built in to the shell.

+

+Contrary to the errata that was on the DUMB website, the makeall.sh and

+makecore.sh scripts actually DID install in /usr. This has now been

+corrected, and regardless of whether you use these scripts or call make

+directly, the files will now be installed to /usr/local by default.

+

+The XM loader used to treat stereo samples as mono samples with the data for

+the right channel positioned after the data for the left channel. This

+generally resulted in an unwanted echo effect. This has been fixed.

+

+When playing XM files, specifying an invalid instrument would cause an old

+note on that channel to come back (roughly speaking). Fast Tracker 2 does not

+exhibit this behaviour. This has been fixed.

+

+The GCC makefiles used -mpentium, which is deprecated in gcc 3.x. This was

+generating warnings, and has now been fixed.

+

+In XM files, the length of a sample is stored in bytes. DUMB was assuming

+that the length of a 16-bit sample would be even. I had two XM files where

+this was not the case, and DUMB was unable to load them. This has been fixed.

+

+In order to accommodate the extra part of the version number,

+DUMB_REVISION_VERSION has been added. DUMB_VERSION has also been added in

+order to facilitate checking if the version of DUMB installed is sufficient.

+See docs/dumb.txt for details.

+

+As a last-minute fix, the XM "Break to row" effect is now loaded properly. It

+was necessary to convert from binary-coded decimal to hexadecimal (those who

+have experience with Fast Tracker 2 will know what I mean). In short, this

+means the effect will now work properly when breaking to row 10 or greater.

+

+DUMB v0.8 had faulty release date constants; DUMB_MONTH and DUMB_DAY were

+swapped! For this reason, DUMB_DATE should not be compared against any date

+in 2002. This note has been added to docs/dumb.txt and also to dumb.h.

+

+Please scroll to the end and read the release notes for the first version,

+DUMB v0.7. Most of them apply equally to this release. However, the

+non-portable code was rewritten for DUMB v0.8, so that point does not apply.

+The point about length not being calculated also applies to XM files.

+

+Enjoy :)

+

+

+****************************************

+*** DUMB v0.8, released 14 June 2002 ***

+****************************************

+

+Welcome to the second release of DUMB!

+

+In addition to these notes, please read below the release notes for the

+previous version, DUMB v0.7. Most of them apply equally to this release.

+However, the non-portable code has been rewritten; DUMB should now port to

+big-endian platforms.

+

+The main improvement in this release of DUMB is the support for XM files.

+Enormous thanks go to Julien Cugniere for working on this while I had to

+revise for my exams!

+

+There was a mistake in the makefiles in the last release. The debugging

+Allegro interface library was mistakenly named libaldmbd.a instead of

+libaldmd.a, meaning you had to compile with -laldmbd, contrary to what the

+docs said. Apologies to everyone who lost sleep trying to work out what was

+wrong! The reason for using libaldmd.a is to maintain compatibility with

+plain DOS, where filenames are limited to eight characters (plus a three-

+letter extension). The makefiles have now been changed to match the

+information in the docs, so you may have to alter your project files

+accordingly.

+

+The example programs were faulty, and crashed on Windows if they were unable

+to load the file. It was also difficult to work out how to exit them (you had

+to click the taskbar button that didn't have a window, then press a key).

+They have been improved in both these respects.

+

+I have now added a docs/faq.txt file (Frequently Asked Questions), which is

+based on problems and misconceptions people have had with the first release.

+Please refer to it before contacting me with problems.

+

+Thanks to networm for touching up the Unix makefile and writing the

+instructions on using it.

+

+Incidentally, today (Friday 14 June) is the Robinson College May Ball at

+Cambridge Uni. God knows why it's called a May Ball if it's in June. I'm not

+going myself (72 GBP, and I'd have to wear a suit, ugh), but with all the

+noise outside I shall enjoy pumping up the speakers tonight!

+

+

+****************************************

+*** DUMB v0.7, released 2 March 2002 ***

+****************************************

+

+This is the first release of DUMB, and parts of the library are not

+crystallised. Don't let this put you off! Provided you don't try to use any

+features that aren't documented in docs/dumb.txt, the library should be rock

+solid and you should be able to upgrade more or less without problems.

+

+Here are some notes on this release:

+

+- There is some non-portable code in this release of DUMB. It is likely that

+  the library will fail to load IT files with compressed samples on

+  big-endian machines such as the Apple Macintosh.

+

+- If your program ever aborts with exit code 37 while loading an IT file,

+  PLEASE LET ME KNOW! The IT file in question has a stereo compressed sample

+  in it, and the format is unspecified for this case (Impulse Tracker itself

+  doesn't use stereo samples at all). I will need the IT file in question,

+  and any information you can give me about how the IT file was created (e.g.

+  what program). (If you don't get to see an exit code, let me know anyway.)

+

+- If your program ever outputs a line resembling "Inst 01 Env: 0,64 8,32

+  15,48" to stderr while loading an IT file, PLEASE LET ME KNOW! You have an

+  old IT file (saved by an Impulse Tracker version older than 2.00), and

+  support for such files is untested.

+

+- The length of IT and S3M files is not currently calculated. It is just set

+  to ten minutes.

diff --git a/plugins/dumb/dumb-kode54/src/Makefile.am b/plugins/dumb/dumb-kode54/src/Makefile.am
new file mode 100644
index 00000000..ecd71af7
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/Makefile.am
@@ -0,0 +1,41 @@
+INCLUDES = \

+	-I $(top_srcdir)/include

+

+lib_LTLIBRARIES = libdumb.la

+

+libdumb_la_SOURCES = \

+	core/atexit.c \

+	core/duhlen.c \

+	core/duhtag.c \

+	core/dumbfile.c \

+	core/loadduh.c \

+	core/makeduh.c \

+	core/rawsig.c \

+	core/readduh.c \

+	core/register.c \

+	core/rendduh.c \

+	core/rendsig.c \

+	core/unload.c \

+	helpers/clickrem.c \

+	helpers/memfile.c \

+	helpers/resample.c \

+	helpers/resample.inc \

+	helpers/sampbuf.c \

+	helpers/silence.c \

+	helpers/stdfile.c \

+	it/itload.c \

+	it/itmisc.c \

+	it/itorder.c \

+	it/itread.c \

+	it/itrender.c \

+	it/itunload.c \

+	it/loadmod.c \

+	it/loads3m.c \

+	it/loadxm.c \

+	it/readmod.c \

+	it/reads3m.c \

+	it/readxm.c \

+	it/xmeffect.c

+

+libdumb_la_LDFLAGS = \

+	-release $(VERSION)

diff --git a/plugins/dumb/dumb-kode54/src/allegro/alplay.c b/plugins/dumb/dumb-kode54/src/allegro/alplay.c
new file mode 100644
index 00000000..85e2079a
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/allegro/alplay.c
@@ -0,0 +1,277 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * alplay.c - Functions to play a DUH through         / / \  \

+ *            an Allegro audio stream.               | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+

+#include <allegro.h>

+

+#include "aldumb.h"

+

+

+

+#define ADP_PLAYING 1

+

+struct AL_DUH_PLAYER

+{

+	int flags;

+	long bufsize;

+	int freq;

+	AUDIOSTREAM *stream;

+	DUH_SIGRENDERER *sigrenderer; /* If this is NULL, stream is invalid. */

+	float volume;

+	int silentcount;

+};

+

+

+

+AL_DUH_PLAYER *al_start_duh(DUH *duh, int n_channels, long pos, float volume, long bufsize, int freq)

+{

+	AL_DUH_PLAYER *dp;

+

+	/* This restriction is imposed by Allegro. */

+	ASSERT(n_channels > 0);

+	ASSERT(n_channels <= 2);

+

+	if (!duh)

+		return NULL;

+

+	dp = malloc(sizeof(*dp));

+	if (!dp)

+		return NULL;

+

+	dp->flags = ADP_PLAYING;

+	dp->bufsize = bufsize;

+	dp->freq = freq;

+

+	dp->stream = play_audio_stream(bufsize, 16, n_channels - 1, freq, 255, 128);

+

+	if (!dp->stream) {

+		free(dp);

+		return NULL;

+	}

+

+	voice_set_priority(dp->stream->voice, 255);

+

+	dp->sigrenderer = duh_start_sigrenderer(duh, 0, n_channels, pos);

+

+	if (!dp->sigrenderer) {

+		stop_audio_stream(dp->stream);

+		free(dp);

+		return NULL;

+	}

+

+	dp->volume = volume;

+	dp->silentcount = 0;

+

+	return dp;

+}

+

+

+

+void al_stop_duh(AL_DUH_PLAYER *dp)

+{

+	if (dp) {

+		if (dp->sigrenderer) {

+			duh_end_sigrenderer(dp->sigrenderer);

+			stop_audio_stream(dp->stream);

+		}

+		free(dp);

+	}

+}

+

+

+

+void al_pause_duh(AL_DUH_PLAYER *dp)

+{

+	if (dp && dp->sigrenderer && (dp->flags & ADP_PLAYING)) {

+		voice_stop(dp->stream->voice);

+		dp->flags &= ~ADP_PLAYING;

+	}

+}

+

+

+

+void al_resume_duh(AL_DUH_PLAYER *dp)

+{

+	if (dp && dp->sigrenderer && !(dp->flags & ADP_PLAYING)) {

+		voice_start(dp->stream->voice);

+		dp->flags |= ADP_PLAYING;

+	}

+}

+

+

+

+void al_duh_set_priority(AL_DUH_PLAYER *dp, int priority)

+{

+	if (dp && dp->sigrenderer)

+		voice_set_priority(dp->stream->voice, priority);

+}

+

+

+

+void al_duh_set_volume(AL_DUH_PLAYER *dp, float volume)

+{

+	if (dp)

+		dp->volume = volume;

+}

+

+

+

+float al_duh_get_volume(AL_DUH_PLAYER *dp)

+{

+	return dp ? dp->volume : 0;

+}

+

+

+

+int al_poll_duh(AL_DUH_PLAYER *dp)

+{

+	unsigned short *sptr;

+	long n;

+	long size;

+	int n_channels;

+

+	if (!dp || !dp->sigrenderer)

+		return 1;

+

+	if (!(dp->flags & ADP_PLAYING))

+		return 0;

+

+	sptr = get_audio_stream_buffer(dp->stream);

+

+	if (!sptr)

+		return 0;

+

+	n = duh_render(dp->sigrenderer, 16, 1, dp->volume, 65536.0 / dp->freq, dp->bufsize, sptr);

+

+	if (n == 0) {

+		if (++dp->silentcount >= 2) {

+			duh_end_sigrenderer(dp->sigrenderer);

+			free_audio_stream_buffer(dp->stream);

+			stop_audio_stream(dp->stream);

+			dp->sigrenderer = NULL;

+			return 1;

+		}

+	}

+

+	n_channels = duh_sigrenderer_get_n_channels(dp->sigrenderer);

+	n *= n_channels;

+	size = dp->bufsize * n_channels;

+	for (; n < size; n++)

+		sptr[n] = 0x8000;

+

+	free_audio_stream_buffer(dp->stream);

+

+	return 0;

+}

+

+

+

+long al_duh_get_position(AL_DUH_PLAYER *dp)

+{

+	return dp ? duh_sigrenderer_get_position(dp->sigrenderer) : -1;

+}

+

+

+

+AL_DUH_PLAYER *al_duh_encapsulate_sigrenderer(DUH_SIGRENDERER *sigrenderer, float volume, long bufsize, int freq)

+{

+	AL_DUH_PLAYER *dp;

+	int n_channels;

+

+	if (!sigrenderer)

+		return NULL;

+

+	dp = malloc(sizeof(*dp));

+	if (!dp)

+		return NULL;

+

+	n_channels = duh_sigrenderer_get_n_channels(sigrenderer);

+

+	/* This restriction is imposed by Allegro. */

+	ASSERT(n_channels > 0);

+	ASSERT(n_channels <= 2);

+

+	dp->flags = ADP_PLAYING;

+	dp->bufsize = bufsize;

+	dp->freq = freq;

+

+	dp->stream = play_audio_stream(bufsize, 16, n_channels - 1, freq, 255, 128);

+

+	if (!dp->stream) {

+		free(dp);

+		return NULL;

+	}

+

+	voice_set_priority(dp->stream->voice, 255);

+

+	dp->sigrenderer = sigrenderer;

+

+	dp->volume = volume;

+	dp->silentcount = 0;

+

+	return dp;

+}

+

+

+

+DUH_SIGRENDERER *al_duh_get_sigrenderer(AL_DUH_PLAYER *dp)

+{

+	return dp ? dp->sigrenderer : NULL;

+}

+

+

+

+/* IMPORTANT: This function will return NULL if the music has ended. */

+// Should this be changed? User might want to hack the underlying SIGRENDERER

+// and resurrect it (e.g. change pattern number), before it gets destroyed...

+DUH_SIGRENDERER *al_duh_decompose_to_sigrenderer(AL_DUH_PLAYER *dp)

+{

+	if (dp) {

+		DUH_SIGRENDERER *sigrenderer = dp->sigrenderer;

+		if (sigrenderer) stop_audio_stream(dp->stream);

+		free(dp);

+		return sigrenderer;

+	}

+	return NULL;

+}

+

+

+

+/* DEPRECATED */

+AL_DUH_PLAYER *al_duh_encapsulate_renderer(DUH_SIGRENDERER *dr, float volume, long bufsize, int freq)

+{

+	return al_duh_encapsulate_sigrenderer(dr, volume, bufsize, freq);

+}

+

+

+

+/* DEPRECATED */

+DUH_SIGRENDERER *al_duh_get_renderer(AL_DUH_PLAYER *dp)

+{

+	return al_duh_get_sigrenderer(dp);

+}

+

+

+

+/* DEPRECATED */

+DUH_SIGRENDERER *al_duh_decompose_to_renderer(AL_DUH_PLAYER *dp)

+{

+	return al_duh_decompose_to_sigrenderer(dp);

+}

diff --git a/plugins/dumb/dumb-kode54/src/allegro/datduh.c b/plugins/dumb/dumb-kode54/src/allegro/datduh.c
new file mode 100644
index 00000000..5dec3975
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/allegro/datduh.c
@@ -0,0 +1,60 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * datduh.c - Integration with Allegro's              / / \  \

+ *            datafiles.                             | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <allegro.h>

+

+#include "aldumb.h"

+#include "internal/aldumb.h"

+

+

+

+static void *dat_read_duh(PACKFILE *f, long size)

+{

+	DUMBFILE *df;

+	DUH *duh;

+

+	(void)size;

+

+	df = dumbfile_open_packfile(f);

+

+	if (!df)

+		return NULL;

+

+	duh = read_duh(df);

+

+	dumbfile_close(df);

+

+	return duh;

+}

+

+

+

+/* dumb_register_dat_duh(): tells Allegro about the DUH datafile object. If

+ * you intend to load a datafile containing a DUH object, you must call this

+ * function first. It is recommended you pass DAT_DUH, but you may have a

+ * reason to use a different type (apart from pride, that doesn't count).

+ */

+void dumb_register_dat_duh(long type)

+{

+	register_datafile_object(

+		type,

+		&dat_read_duh,

+		&_dat_unload_duh

+	);

+}

diff --git a/plugins/dumb/dumb-kode54/src/allegro/datit.c b/plugins/dumb/dumb-kode54/src/allegro/datit.c
new file mode 100644
index 00000000..1a6ce2f6
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/allegro/datit.c
@@ -0,0 +1,62 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * datit.c - Integration of IT files with             / / \  \

+ *           Allegro's datafiles.                    | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <allegro.h>

+

+#include "aldumb.h"

+#include "internal/aldumb.h"

+

+

+

+static void *dat_read_it(PACKFILE *f, long size)

+{

+	DUMBFILE *df;

+	DUH *duh;

+

+	(void)size;

+

+	df = dumbfile_open_packfile(f);

+

+	if (!df)

+		return NULL;

+

+	duh = dumb_read_it(df);

+

+	dumbfile_close(df);

+

+	return duh;

+}

+

+

+

+/* dumb_register_dat_it(): tells Allegro about the IT datafile object. If you

+ * intend to load a datafile containing an IT object, you must call this

+ * function first. It is recommended you pass DUMB_DAT_IT, but you may have a

+ * reason to use a different type (perhaps you already have a datafile with

+ * IT files in and they use a different type).

+ */

+void dumb_register_dat_it(long type)

+{

+	register_datafile_object(

+		type,

+		&dat_read_it,

+		&_dat_unload_duh

+	);

+}

+

diff --git a/plugins/dumb/dumb-kode54/src/allegro/datmod.c b/plugins/dumb/dumb-kode54/src/allegro/datmod.c
new file mode 100644
index 00000000..abbc1d9a
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/allegro/datmod.c
@@ -0,0 +1,61 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * datmod.c - Integration of MOD files with           / / \  \

+ *            Allegro's datafiles.                   | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <allegro.h>

+

+#include "aldumb.h"

+#include "internal/aldumb.h"

+

+

+

+static void *dat_read_mod(PACKFILE *f, long size)

+{

+	DUMBFILE *df;

+	DUH *duh;

+

+	(void)size;

+

+	df = dumbfile_open_packfile(f);

+

+	if (!df)

+		return NULL;

+

+	duh = dumb_read_mod(df);

+

+	dumbfile_close(df);

+

+	return duh;

+}

+

+

+

+/* dumb_register_dat_mod(): tells Allegro about the MOD datafile object. If

+ * you intend to load a datafile containing a MOD object, you must call this

+ * function first. It is recommended you pass DUMB_DAT_MOD, but you may have

+ * a reason to use a different type (perhaps you already have a datafile with

+ * MOD files in and they use a different type).

+ */

+void dumb_register_dat_mod(long type)

+{

+	register_datafile_object(

+		type,

+		&dat_read_mod,

+		&_dat_unload_duh

+	);

+}

diff --git a/plugins/dumb/dumb-kode54/src/allegro/dats3m.c b/plugins/dumb/dumb-kode54/src/allegro/dats3m.c
new file mode 100644
index 00000000..8fe21666
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/allegro/dats3m.c
@@ -0,0 +1,61 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * dats3m.c - Integration of S3M files with           / / \  \

+ *            Allegro's datafiles.                   | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <allegro.h>

+

+#include "aldumb.h"

+#include "internal/aldumb.h"

+

+

+

+static void *dat_read_s3m(PACKFILE *f, long size)

+{

+	DUMBFILE *df;

+	DUH *duh;

+

+	(void)size;

+

+	df = dumbfile_open_packfile(f);

+

+	if (!df)

+		return NULL;

+

+	duh = dumb_read_s3m(df);

+

+	dumbfile_close(df);

+

+	return duh;

+}

+

+

+

+/* dumb_register_dat_s3m(): tells Allegro about the S3M datafile object. If

+ * you intend to load a datafile containing an S3M object, you must call this

+ * function first. It is recommended you pass DUMB_DAT_S3M, but you may have

+ * a reason to use a different type (perhaps you already have a datafile with

+ * S3M files in and they use a different type).

+ */

+void dumb_register_dat_s3m(long type)

+{

+	register_datafile_object(

+		type,

+		&dat_read_s3m,

+		&_dat_unload_duh

+	);

+}

diff --git a/plugins/dumb/dumb-kode54/src/allegro/datunld.c b/plugins/dumb/dumb-kode54/src/allegro/datunld.c
new file mode 100644
index 00000000..68d359fb
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/allegro/datunld.c
@@ -0,0 +1,31 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * datunld.c - Unload function for integration        / / \  \

+ *             with Allegro's datafiles.             | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <allegro.h>

+

+#include "aldumb.h"

+#include "internal/aldumb.h"

+

+

+

+void _dat_unload_duh(void *duh)

+{

+	unload_duh(duh);

+}

+

diff --git a/plugins/dumb/dumb-kode54/src/allegro/datxm.c b/plugins/dumb/dumb-kode54/src/allegro/datxm.c
new file mode 100644
index 00000000..ff3ff25a
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/allegro/datxm.c
@@ -0,0 +1,62 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * datxm.c - Integration of XM files with             / / \  \

+ *           Allegro's datafiles.                    | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <allegro.h>

+

+#include "aldumb.h"

+#include "internal/aldumb.h"

+

+

+

+static void *dat_read_xm(PACKFILE *f, long size)

+{

+	DUMBFILE *df;

+	DUH *duh;

+

+	(void)size;

+

+	df = dumbfile_open_packfile(f);

+

+	if (!df)

+		return NULL;

+

+	duh = dumb_read_xm(df);

+

+	dumbfile_close(df);

+

+	return duh;

+}

+

+

+

+/* dumb_register_dat_xm(): tells Allegro about the XM datafile object. If you

+ * intend to load a datafile containing an XM object, you must call this

+ * function first. It is recommended you pass DUMB_DAT_XM, but you may have a

+ * reason to use a different type (perhaps you already have a datafile with

+ * XM files in and they use a different type).

+ */

+void dumb_register_dat_xm(long type)

+{

+	register_datafile_object(

+		type,

+		&dat_read_xm,

+		&_dat_unload_duh

+	);

+}

+

diff --git a/plugins/dumb/dumb-kode54/src/allegro/packfile.c b/plugins/dumb/dumb-kode54/src/allegro/packfile.c
new file mode 100644
index 00000000..5a07bdb5
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/allegro/packfile.c
@@ -0,0 +1,98 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * packfile.c - Packfile input module.                / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ * Note that this does not use file compression;        | \ / /

+ * for that you must open the file yourself and         |  ' /

+ * then use dumbfile_open_packfile().                    \__/

+ */

+

+#include <allegro.h>

+

+#include "aldumb.h"

+

+

+

+static void *dumb_packfile_open(const char *filename)

+{

+	return pack_fopen(filename, F_READ);

+}

+

+

+

+static int dumb_packfile_skip(void *f, long n)

+{

+	return pack_fseek(f, n);

+}

+

+

+

+static int dumb_packfile_getc(void *f)

+{

+	return pack_getc(f);

+}

+

+

+

+static long dumb_packfile_getnc(char *ptr, long n, void *f)

+{

+	return pack_fread(ptr, n, f);

+}

+

+

+

+static void dumb_packfile_close(void *f)

+{

+	pack_fclose(f);

+}

+

+

+

+static DUMBFILE_SYSTEM packfile_dfs = {

+	&dumb_packfile_open,

+	&dumb_packfile_skip,

+	&dumb_packfile_getc,

+	&dumb_packfile_getnc,

+	&dumb_packfile_close

+};

+

+

+

+void dumb_register_packfiles(void)

+{

+	register_dumbfile_system(&packfile_dfs);

+}

+

+

+

+static DUMBFILE_SYSTEM packfile_dfs_leave_open = {

+	NULL,

+	&dumb_packfile_skip,

+	&dumb_packfile_getc,

+	&dumb_packfile_getnc,

+	NULL

+};

+

+

+

+DUMBFILE *dumbfile_open_packfile(PACKFILE *p)

+{

+	return dumbfile_open_ex(p, &packfile_dfs_leave_open);

+}

+

+

+

+DUMBFILE *dumbfile_from_packfile(PACKFILE *p)

+{

+	return p ? dumbfile_open_ex(p, &packfile_dfs) : NULL;

+}

diff --git a/plugins/dumb/dumb-kode54/src/core/atexit.c b/plugins/dumb/dumb-kode54/src/core/atexit.c
new file mode 100644
index 00000000..64814efd
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/atexit.c
@@ -0,0 +1,71 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * atexit.c - Library Clean-up Management.            / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+

+#include "dumb.h"

+#include "internal/dumb.h"

+

+

+

+typedef struct DUMB_ATEXIT_PROC

+{

+	struct DUMB_ATEXIT_PROC *next;

+	void (*proc)(void);

+}

+DUMB_ATEXIT_PROC;

+

+

+

+static DUMB_ATEXIT_PROC *dumb_atexit_proc = NULL;

+

+

+

+int dumb_atexit(void (*proc)(void))

+{

+	DUMB_ATEXIT_PROC *dap = dumb_atexit_proc;

+

+	while (dap) {

+		if (dap->proc == proc) return 0;

+		dap = dap->next;

+	}

+

+	dap = malloc(sizeof(*dap));

+

+	if (!dap)

+		return -1;

+

+	dap->next = dumb_atexit_proc;

+	dap->proc = proc;

+	dumb_atexit_proc = dap;

+

+	return 0;

+}

+

+

+

+void dumb_exit(void)

+{

+	while (dumb_atexit_proc) {

+		DUMB_ATEXIT_PROC *next = dumb_atexit_proc->next;

+		(*dumb_atexit_proc->proc)();

+		free(dumb_atexit_proc);

+		dumb_atexit_proc = next;

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/core/duhlen.c b/plugins/dumb/dumb-kode54/src/core/duhlen.c
new file mode 100644
index 00000000..2c3a3576
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/duhlen.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * duhlen.c - Functions to set and return the         / / \  \

+ *            length of a DUH.                       | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ * Note that the length of a DUH is a constant          |  ' /

+ * stored in the DUH struct and in the DUH disk          \__/

+ * format. It will be calculated on loading for

+ * other formats in which the length is not explicitly stored. Also note that

+ * it does not necessarily correspond to the length of time for which the DUH

+ * will generate samples. Rather it represents a suitable point for a player

+ * such as Winamp to stop, and in any good DUH it will allow for any final

+ * flourish to fade out and be appreciated.

+ */

+

+#include "dumb.h"

+#include "internal/dumb.h"

+

+

+

+long duh_get_length(DUH *duh)

+{

+	return duh ? duh->length : 0;

+}

+

+

+

+void duh_set_length(DUH *duh, long length)

+{

+	if (duh)

+		duh->length = length;

+}

diff --git a/plugins/dumb/dumb-kode54/src/core/duhtag.c b/plugins/dumb/dumb-kode54/src/core/duhtag.c
new file mode 100644
index 00000000..77061094
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/duhtag.c
@@ -0,0 +1,38 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * duhtag.c - Function to return the tags stored      / / \  \

+ *            in a DUH struct (typically author      | <  /   \_

+ *            information).                          |  \/ /\   /

+ *                                                    \_  /  > /

+ * By entheh.                                           | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <string.h>

+

+#include "dumb.h"

+#include "internal/dumb.h"

+

+

+

+const char *duh_get_tag(DUH *duh, const char *key)

+{

+	int i;

+	ASSERT(key);

+	if (!duh || !duh->tag) return NULL;

+

+	for (i = 0; i < duh->n_tags; i++)

+		if (strcmp(key, duh->tag[i][0]) == 0)

+			return duh->tag[i][1];

+

+	return NULL;

+}

diff --git a/plugins/dumb/dumb-kode54/src/core/dumbfile.c b/plugins/dumb/dumb-kode54/src/core/dumbfile.c
new file mode 100644
index 00000000..ae738bf7
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/dumbfile.c
@@ -0,0 +1,401 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * dumbfile.c - Hookable, strictly sequential         / / \  \

+ *              file input functions.                | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+

+#include "dumb.h"

+

+

+

+static DUMBFILE_SYSTEM *the_dfs = NULL;

+

+

+

+void register_dumbfile_system(DUMBFILE_SYSTEM *dfs)

+{

+	ASSERT(dfs);

+	ASSERT(dfs->open);

+	ASSERT(dfs->getc);

+	ASSERT(dfs->close);

+	the_dfs = dfs;

+}

+

+

+

+struct DUMBFILE

+{

+	DUMBFILE_SYSTEM *dfs;

+	void *file;

+	long pos;

+};

+

+

+

+DUMBFILE *dumbfile_open(const char *filename)

+{

+	DUMBFILE *f;

+

+	ASSERT(the_dfs);

+

+	f = malloc(sizeof(*f));

+

+	if (!f)

+		return NULL;

+

+	f->dfs = the_dfs;

+

+	f->file = (*the_dfs->open)(filename);

+

+	if (!f->file) {

+		free(f);

+		return NULL;

+	}

+

+	f->pos = 0;

+

+	return f;

+}

+

+

+

+DUMBFILE *dumbfile_open_ex(void *file, DUMBFILE_SYSTEM *dfs)

+{

+	DUMBFILE *f;

+

+	ASSERT(dfs);

+	ASSERT(dfs->getc);

+	ASSERT(file);

+

+	f = malloc(sizeof(*f));

+

+	if (!f) {

+		if (dfs->close)

+			(*dfs->close)(file);

+		return NULL;

+	}

+

+	f->dfs = dfs;

+	f->file = file;

+

+	f->pos = 0;

+

+	return f;

+}

+

+

+

+long dumbfile_pos(DUMBFILE *f)

+{

+	ASSERT(f);

+

+	return f->pos;

+}

+

+

+

+int dumbfile_skip(DUMBFILE *f, long n)

+{

+	int rv;

+

+	ASSERT(f);

+	ASSERT(n >= 0);

+

+	if (f->pos < 0)

+		return -1;

+

+	f->pos += n;

+

+	if (f->dfs->skip) {

+		rv = (*f->dfs->skip)(f->file, n);

+		if (rv) {

+			f->pos = -1;

+			return rv;

+		}

+	} else {

+		while (n) {

+			rv = (*f->dfs->getc)(f->file);

+			if (rv < 0) {

+				f->pos = -1;

+				return rv;

+			}

+			n--;

+		}

+	}

+

+	return 0;

+}

+

+

+

+int dumbfile_getc(DUMBFILE *f)

+{

+	int rv;

+

+	ASSERT(f);

+

+	if (f->pos < 0)

+		return -1;

+

+	rv = (*f->dfs->getc)(f->file);

+

+	if (rv < 0) {

+		f->pos = -1;

+		return rv;

+	}

+

+	f->pos++;

+

+	return rv;

+}

+

+

+

+int dumbfile_igetw(DUMBFILE *f)

+{

+	int l, h;

+

+	ASSERT(f);

+

+	if (f->pos < 0)

+		return -1;

+

+	l = (*f->dfs->getc)(f->file);

+	if (l < 0) {

+		f->pos = -1;

+		return l;

+	}

+

+	h = (*f->dfs->getc)(f->file);

+	if (h < 0) {

+		f->pos = -1;

+		return h;

+	}

+

+	f->pos += 2;

+

+	return l | (h << 8);

+}

+

+

+

+int dumbfile_mgetw(DUMBFILE *f)

+{

+	int l, h;

+

+	ASSERT(f);

+

+	if (f->pos < 0)

+		return -1;

+

+	h = (*f->dfs->getc)(f->file);

+	if (h < 0) {

+		f->pos = -1;

+		return h;

+	}

+

+	l = (*f->dfs->getc)(f->file);

+	if (l < 0) {

+		f->pos = -1;

+		return l;

+	}

+

+	f->pos += 2;

+

+	return l | (h << 8);

+}

+

+

+

+long dumbfile_igetl(DUMBFILE *f)

+{

+	unsigned long rv, b;

+

+	ASSERT(f);

+

+	if (f->pos < 0)

+		return -1;

+

+	rv = (*f->dfs->getc)(f->file);

+	if ((signed long)rv < 0) {

+		f->pos = -1;

+		return rv;

+	}

+

+	b = (*f->dfs->getc)(f->file);

+	if ((signed long)b < 0) {

+		f->pos = -1;

+		return b;

+	}

+	rv |= b << 8;

+

+	b = (*f->dfs->getc)(f->file);

+	if ((signed long)b < 0) {

+		f->pos = -1;

+		return b;

+	}

+	rv |= b << 16;

+

+	b = (*f->dfs->getc)(f->file);

+	if ((signed long)b < 0) {

+		f->pos = -1;

+		return b;

+	}

+	rv |= b << 24;

+

+	f->pos += 4;

+

+	return rv;

+}

+

+

+

+long dumbfile_mgetl(DUMBFILE *f)

+{

+	unsigned long rv, b;

+

+	ASSERT(f);

+

+	if (f->pos < 0)

+		return -1;

+

+	rv = (*f->dfs->getc)(f->file);

+	if ((signed long)rv < 0) {

+		f->pos = -1;

+		return rv;

+	}

+	rv <<= 24;

+

+	b = (*f->dfs->getc)(f->file);

+	if ((signed long)b < 0) {

+		f->pos = -1;

+		return b;

+	}

+	rv |= b << 16;

+

+	b = (*f->dfs->getc)(f->file);

+	if ((signed long)b < 0) {

+		f->pos = -1;

+		return b;

+	}

+	rv |= b << 8;

+

+	b = (*f->dfs->getc)(f->file);

+	if ((signed long)b < 0) {

+		f->pos = -1;

+		return b;

+	}

+	rv |= b;

+

+	f->pos += 4;

+

+	return rv;

+}

+

+

+

+unsigned long dumbfile_cgetul(DUMBFILE *f)

+{

+	unsigned long rv = 0;

+	int v;

+

+	do {

+		v = dumbfile_getc(f);

+

+		if (v < 0)

+			return v;

+

+		rv <<= 7;

+		rv |= v & 0x7F;

+	} while (v & 0x80);

+

+	return rv;

+}

+

+

+

+signed long dumbfile_cgetsl(DUMBFILE *f)

+{

+	unsigned long rv = dumbfile_cgetul(f);

+

+	if (f->pos < 0)

+		return rv;

+

+	return (rv >> 1) | (rv << 31);

+}

+

+

+

+long dumbfile_getnc(char *ptr, long n, DUMBFILE *f)

+{

+	long rv;

+

+	ASSERT(f);

+	ASSERT(n >= 0);

+

+	if (f->pos < 0)

+		return -1;

+

+	if (f->dfs->getnc) {

+		rv = (*f->dfs->getnc)(ptr, n, f->file);

+		if (rv < n) {

+			f->pos = -1;

+			return MAX(rv, 0);

+		}

+	} else {

+		for (rv = 0; rv < n; rv++) {

+			int c = (*f->dfs->getc)(f->file);

+			if (c < 0) {

+				f->pos = -1;

+				return rv;

+			}

+			*ptr++ = c;

+		}

+	}

+

+	f->pos += rv;

+

+	return rv;

+}

+

+

+

+int dumbfile_error(DUMBFILE *f)

+{

+	ASSERT(f);

+

+	return f->pos < 0;

+}

+

+

+

+int dumbfile_close(DUMBFILE *f)

+{

+	int rv;

+

+	ASSERT(f);

+

+	rv = f->pos < 0;

+

+	if (f->dfs->close)

+		(*f->dfs->close)(f->file);

+

+	free(f);

+

+	return rv;

+}

diff --git a/plugins/dumb/dumb-kode54/src/core/loadduh.c b/plugins/dumb/dumb-kode54/src/core/loadduh.c
new file mode 100644
index 00000000..e954fe24
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/loadduh.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadduh.c - Code to read a DUH from a file,        / / \  \

+ *             opening and closing the file for      | <  /   \_

+ *             you.                                  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By entheh.                                           | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/dumb.h"

+

+

+

+/* load_duh(): loads a .duh file, returning a pointer to a DUH struct.

+ * When you have finished with it, you must pass the pointer to unload_duh()

+ * so that the memory can be freed.

+ */

+DUH *load_duh(const char *filename)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = read_duh(f);

+

+	dumbfile_close(f);

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/core/makeduh.c b/plugins/dumb/dumb-kode54/src/core/makeduh.c
new file mode 100644
index 00000000..1edf2b1f
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/makeduh.c
@@ -0,0 +1,132 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * makeduh.c - Function to construct a DUH from       / / \  \

+ *             its components.                       | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+#include "internal/dumb.h"

+

+

+

+static DUH_SIGNAL *make_signal(DUH_SIGTYPE_DESC *desc, sigdata_t *sigdata)

+{

+	DUH_SIGNAL *signal;

+

+	ASSERT((desc->start_sigrenderer && desc->end_sigrenderer) || (!desc->start_sigrenderer && !desc->end_sigrenderer));

+	ASSERT(desc->sigrenderer_generate_samples && desc->sigrenderer_get_current_sample);

+

+	signal = malloc(sizeof(*signal));

+

+	if (!signal) {

+		if (desc->unload_sigdata)

+			if (sigdata)

+				(*desc->unload_sigdata)(sigdata);

+		return NULL;

+	}

+

+	signal->desc = desc;

+	signal->sigdata = sigdata;

+

+	return signal;

+}

+

+

+

+DUH *make_duh(

+	long length,

+	int n_tags,

+	const char *const tags[][2],

+	int n_signals,

+	DUH_SIGTYPE_DESC *desc[],

+	sigdata_t *sigdata[]

+)

+{

+	DUH *duh = malloc(sizeof(*duh));

+	int i;

+	int fail;

+

+	if (duh) {

+		duh->n_signals = n_signals;

+

+		duh->signal = malloc(n_signals * sizeof(*duh->signal));

+

+		if (!duh->signal) {

+			free(duh);

+			duh = NULL;

+		}

+	}

+

+	if (!duh) {

+		for (i = 0; i < n_signals; i++)

+			if (desc[i]->unload_sigdata)

+				if (sigdata[i])

+					(*desc[i]->unload_sigdata)(sigdata[i]);

+		return NULL;

+	}

+

+	duh->n_tags = 0;

+	duh->tag = NULL;

+

+	fail = 0;

+

+	for (i = 0; i < n_signals; i++) {

+		duh->signal[i] = make_signal(desc[i], sigdata[i]);

+		if (!duh->signal[i])

+			fail = 1;

+	}

+

+	if (fail) {

+		unload_duh(duh);

+		return NULL;

+	}

+

+	duh->length = length;

+

+	{

+		int mem = n_tags * 2; /* account for NUL terminators here */

+		char *ptr;

+

+		for (i = 0; i < n_tags; i++)

+			mem += strlen(tags[i][0]) + strlen(tags[i][1]);

+

+		if (mem <= 0) return duh;

+

+		duh->tag = malloc(n_tags * sizeof(*duh->tag));

+		if (!duh->tag) return duh;

+		duh->tag[0][0] = malloc(mem);

+		if (!duh->tag[0][0]) {

+			free(duh->tag);

+			duh->tag = NULL;

+			return duh;

+		}

+		duh->n_tags = n_tags;

+		ptr = duh->tag[0][0];

+		for (i = 0; i < n_tags; i++) {

+			duh->tag[i][0] = ptr;

+			strcpy(ptr, tags[i][0]);

+			ptr += strlen(tags[i][0]) + 1;

+			duh->tag[i][1] = ptr;

+			strcpy(ptr, tags[i][1]);

+			ptr += strlen(tags[i][1]) + 1;

+		}

+	}

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/core/rawsig.c b/plugins/dumb/dumb-kode54/src/core/rawsig.c
new file mode 100644
index 00000000..75c41eb0
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/rawsig.c
@@ -0,0 +1,44 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * rawsig.c - Function to retrieve raw signal         / / \  \

+ *            data from a DUH provided you know      | <  /   \_

+ *            what type of signal it is.             |  \/ /\   /

+ *                                                    \_  /  > /

+ * By entheh.                                           | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+

+#include "dumb.h"

+#include "internal/dumb.h"

+

+

+

+/* You have to specify the type of sigdata, proving you know what to do with

+ * the pointer. If you get it wrong, you can expect NULL back.

+ */

+sigdata_t *duh_get_raw_sigdata(DUH *duh, int sig, long type)

+{

+	DUH_SIGNAL *signal;

+

+	if (!duh) return NULL;

+

+	if ((unsigned int)sig >= (unsigned int)duh->n_signals) return NULL;

+

+	signal = duh->signal[sig];

+

+	if (signal && signal->desc->type == type)

+		return signal->sigdata;

+

+	return NULL;

+}

diff --git a/plugins/dumb/dumb-kode54/src/core/readduh.c b/plugins/dumb/dumb-kode54/src/core/readduh.c
new file mode 100644
index 00000000..0fb775b2
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/readduh.c
@@ -0,0 +1,107 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readduh.c - Code to read a DUH from an open        / / \  \

+ *             file.                                 | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+

+#include "dumb.h"

+#include "internal/dumb.h"

+

+

+

+static DUH_SIGNAL *read_signal(DUH *duh, DUMBFILE *f)

+{

+	DUH_SIGNAL *signal;

+	long type;

+

+	signal = malloc(sizeof(*signal));

+

+	if (!signal)

+		return NULL;

+

+	type = dumbfile_mgetl(f);

+	if (dumbfile_error(f)) {

+		free(signal);

+		return NULL;

+	}

+

+	signal->desc = _dumb_get_sigtype_desc(type);

+	if (!signal->desc) {

+		free(signal);

+		return NULL;

+	}

+

+	if (signal->desc->load_sigdata) {

+		signal->sigdata = (*signal->desc->load_sigdata)(duh, f);

+		if (!signal->sigdata) {

+			free(signal);

+			return NULL;

+		}

+	} else

+		signal->sigdata = NULL;

+

+	return signal;

+}

+

+

+

+/* read_duh(): reads a DUH from an already open DUMBFILE, and returns its

+ * pointer, or null on error. The file is not closed.

+ */

+DUH *read_duh(DUMBFILE *f)

+{

+	DUH *duh;

+	int i;

+

+	if (dumbfile_mgetl(f) != DUH_SIGNATURE)

+		return NULL;

+

+	duh = malloc(sizeof(*duh));

+	if (!duh)

+		return NULL;

+

+	duh->length = dumbfile_igetl(f);

+	if (dumbfile_error(f) || duh->length <= 0) {

+		free(duh);

+		return NULL;

+	}

+

+	duh->n_signals = dumbfile_igetl(f);

+	if (dumbfile_error(f) || duh->n_signals <= 0) {

+		free(duh);

+		return NULL;

+	}

+

+	duh->signal = malloc(sizeof(*duh->signal) * duh->n_signals);

+	if (!duh->signal) {

+		free(duh);

+		return NULL;

+	}

+

+	for (i = 0; i < duh->n_signals; i++)

+		duh->signal[i] = NULL;

+

+	for (i = 0; i < duh->n_signals; i++) {

+		if (!(duh->signal[i] = read_signal(duh, f))) {

+			unload_duh(duh);

+			return NULL;

+		}

+	}

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/core/register.c b/plugins/dumb/dumb-kode54/src/core/register.c
new file mode 100644
index 00000000..2e16c9a7
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/register.c
@@ -0,0 +1,104 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * register.c - Signal type registration.             / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+

+#include "dumb.h"

+#include "internal/dumb.h"

+

+

+

+static DUH_SIGTYPE_DESC_LINK *sigtype_desc = NULL;

+static DUH_SIGTYPE_DESC_LINK **sigtype_desc_tail = &sigtype_desc;

+

+

+

+/* destroy_sigtypes(): frees all memory allocated while registering signal

+ * types. This function is set up to be called by dumb_exit().

+ */

+static void destroy_sigtypes(void)

+{

+	DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc, *next;

+	sigtype_desc = NULL;

+	sigtype_desc_tail = &sigtype_desc;

+

+	while (desc_link) {

+		next = desc_link->next;

+		free(desc_link);

+		desc_link = next;

+	}

+}

+

+

+

+/* dumb_register_sigtype(): registers a new signal type with DUMB. The signal

+ * type is identified by a four-character string (e.g. "WAVE"), which you can

+ * encode using the the DUMB_ID() macro (e.g. DUMB_ID('W','A','V','E')). The

+ * signal's behaviour is defined by four functions, whose pointers you pass

+ * here. See the documentation for details.

+ *

+ * If a DUH tries to use a signal that has not been registered using this

+ * function, then the library will fail to load the DUH.

+ */

+void dumb_register_sigtype(DUH_SIGTYPE_DESC *desc)

+{

+	DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc;

+

+	ASSERT((desc->load_sigdata && desc->unload_sigdata) || (!desc->load_sigdata && !desc->unload_sigdata));

+	ASSERT((desc->start_sigrenderer && desc->end_sigrenderer) || (!desc->start_sigrenderer && !desc->end_sigrenderer));

+	ASSERT(desc->sigrenderer_generate_samples && desc->sigrenderer_get_current_sample);

+

+	if (desc_link) {

+		do {

+			if (desc_link->desc->type == desc->type) {

+				desc_link->desc = desc;

+				return;

+			}

+			desc_link = desc_link->next;

+		} while (desc_link);

+	} else

+		dumb_atexit(&destroy_sigtypes);

+

+	desc_link = *sigtype_desc_tail = malloc(sizeof(DUH_SIGTYPE_DESC_LINK));

+

+	if (!desc_link)

+		return;

+

+	desc_link->next = NULL;

+	sigtype_desc_tail = &desc_link->next;

+

+	desc_link->desc = desc;

+}

+

+

+

+/* _dumb_get_sigtype_desc(): searches the registered functions for a signal

+ * type matching the parameter. If such a sigtype is found, it returns a

+ * pointer to a sigtype descriptor containing the necessary functions to

+ * manage the signal. If none is found, it returns NULL.

+ */

+DUH_SIGTYPE_DESC *_dumb_get_sigtype_desc(long type)

+{

+	DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc;

+

+	while (desc_link && desc_link->desc->type != type)

+		desc_link = desc_link->next;

+

+	return desc_link ? desc_link->desc : NULL;

+}

diff --git a/plugins/dumb/dumb-kode54/src/core/rendduh.c b/plugins/dumb/dumb-kode54/src/core/rendduh.c
new file mode 100644
index 00000000..1effa3eb
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/rendduh.c
@@ -0,0 +1,184 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * rendduh.c - Functions for rendering a DUH into     / / \  \

+ *             an end-user sample format.            | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <limits.h>

+

+#include "dumb.h"

+#include "internal/dumb.h"

+

+

+

+/* On the x86, we can use some tricks to speed stuff up */

+#if (defined _MSC_VER) || (defined __DJGPP__) || (defined __MINGW__)

+// Can't we detect Linux and other x86 platforms here? :/

+

+#define FAST_MID(var, min, max) {                  \

+	var -= (min);                                  \

+	var &= (~var) >> (sizeof(var) * CHAR_BIT - 1); \

+	var += (min);                                  \

+	var -= (max);                                  \

+	var &= var >> (sizeof(var) * CHAR_BIT - 1);    \

+	var += (max);                                  \

+}

+

+#define CONVERT8(src, pos, signconv) {       \

+	signed int f = (src + 0x8000) >> 16;     \

+	FAST_MID(f, -128, 127);                  \

+	((char*)sptr)[pos] = (char)f ^ signconv; \

+}

+

+#define CONVERT16(src, pos, signconv) {          \

+	signed int f = (src + 0x80) >> 8;            \

+	FAST_MID(f, -32768, 32767);                  \

+	((short*)sptr)[pos] = (short)(f ^ signconv); \

+}

+

+#else

+

+#define CONVERT8(src, pos, signconv)		  \

+{											  \

+	signed int f = (src + 0x8000) >> 16;	  \

+	f = MID(-128, f, 127);					  \

+	((char *)sptr)[pos] = (char)f ^ signconv; \

+}

+

+

+

+#define CONVERT16(src, pos, signconv)			  \

+{												  \

+	signed int f = (src + 0x80) >> 8;			  \

+	f = MID(-32768, f, 32767);					  \

+	((short *)sptr)[pos] = (short)(f ^ signconv); \

+}

+

+#endif

+

+

+

+/* DEPRECATED */

+DUH_SIGRENDERER *duh_start_renderer(DUH *duh, int n_channels, long pos)

+{

+	return duh_start_sigrenderer(duh, 0, n_channels, pos);

+}

+

+

+

+long duh_render(

+	DUH_SIGRENDERER *sigrenderer,

+	int bits, int unsign,

+	float volume, float delta,

+	long size, void *sptr

+)

+{

+	long n;

+

+	sample_t **sampptr;

+

+	int n_channels;

+

+	ASSERT(bits == 8 || bits == 16);

+	ASSERT(sptr);

+

+	if (!sigrenderer)

+		return 0;

+

+	n_channels = duh_sigrenderer_get_n_channels(sigrenderer);

+

+	ASSERT(n_channels > 0);

+	/* This restriction will be removed when need be. At the moment, tightly

+	 * optimised loops exist for exactly one or two channels.

+	 */

+	ASSERT(n_channels <= 2);

+

+	sampptr = allocate_sample_buffer(n_channels, size);

+

+	if (!sampptr)

+		return 0;

+

+	dumb_silence(sampptr[0], n_channels * size);

+

+	size = duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, sampptr);

+

+	if (bits == 16) {

+		int signconv = unsign ? 0x8000 : 0x0000;

+

+		for (n = 0; n < size * n_channels; n++) {

+			CONVERT16(sampptr[0][n], n, signconv);

+		}

+	} else {

+		char signconv = unsign ? 0x80 : 0x00;

+

+		for (n = 0; n < size * n_channels; n++) {

+			CONVERT8(sampptr[0][n], n, signconv);

+		}

+	}

+

+	destroy_sample_buffer(sampptr);

+

+	return size;

+}

+

+

+

+/* DEPRECATED */

+int duh_renderer_get_n_channels(DUH_SIGRENDERER *dr)

+{

+	return duh_sigrenderer_get_n_channels(dr);

+}

+

+

+

+/* DEPRECATED */

+long duh_renderer_get_position(DUH_SIGRENDERER *dr)

+{

+	return duh_sigrenderer_get_position(dr);

+}

+

+

+

+/* DEPRECATED */

+void duh_end_renderer(DUH_SIGRENDERER *dr)

+{

+	duh_end_sigrenderer(dr);

+}

+

+

+

+/* DEPRECATED */

+DUH_SIGRENDERER *duh_renderer_encapsulate_sigrenderer(DUH_SIGRENDERER *sigrenderer)

+{

+	return sigrenderer;

+}

+

+

+

+/* DEPRECATED */

+DUH_SIGRENDERER *duh_renderer_get_sigrenderer(DUH_SIGRENDERER *dr)

+{

+	return dr;

+}

+

+

+

+/* DEPRECATED */

+DUH_SIGRENDERER *duh_renderer_decompose_to_sigrenderer(DUH_SIGRENDERER *dr)

+{

+	return dr;

+}

diff --git a/plugins/dumb/dumb-kode54/src/core/rendsig.c b/plugins/dumb/dumb-kode54/src/core/rendsig.c
new file mode 100644
index 00000000..b8f866c5
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/rendsig.c
@@ -0,0 +1,344 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * rendsig.c - Wrappers to render samples from        / / \  \

+ *             the signals in a DUH.                 | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+

+#include "dumb.h"

+#include "internal/dumb.h"

+

+

+

+struct DUH_SIGRENDERER

+{

+	DUH_SIGTYPE_DESC *desc;

+

+	sigrenderer_t *sigrenderer;

+

+	int n_channels;

+

+	long pos;

+	int subpos;

+

+	DUH_SIGRENDERER_SAMPLE_ANALYSER_CALLBACK callback;

+	void *callback_data;

+};

+

+

+

+DUH_SIGRENDERER *duh_start_sigrenderer(DUH *duh, int sig, int n_channels, long pos)

+{

+	DUH_SIGRENDERER *sigrenderer;

+

+	DUH_SIGNAL *signal;

+	DUH_START_SIGRENDERER proc;

+

+	if (!duh)

+		return NULL;

+

+	if ((unsigned int)sig >= (unsigned int)duh->n_signals)

+		return NULL;

+

+	signal = duh->signal[sig];

+	if (!signal)

+		return NULL;

+

+	sigrenderer = malloc(sizeof(*sigrenderer));

+	if (!sigrenderer)

+		return NULL;

+

+	sigrenderer->desc = signal->desc;

+

+	proc = sigrenderer->desc->start_sigrenderer;

+

+	if (proc) {

+		duh->signal[sig] = NULL;

+		sigrenderer->sigrenderer = (*proc)(duh, signal->sigdata, n_channels, pos);

+		duh->signal[sig] = signal;

+

+		if (!sigrenderer->sigrenderer) {

+			free(sigrenderer);

+			return NULL;

+		}

+	} else

+		sigrenderer->sigrenderer = NULL;

+

+	sigrenderer->n_channels = n_channels;

+

+	sigrenderer->pos = pos;

+	sigrenderer->subpos = 0;

+

+	sigrenderer->callback = NULL;

+

+	return sigrenderer;

+}

+

+

+

+#include <stdio.h>

+void duh_sigrenderer_set_callback(

+	DUH_SIGRENDERER *sigrenderer,

+	DUH_SIGRENDERER_CALLBACK callback, void *data

+)

+{

+	(void)sigrenderer;

+	(void)callback;

+	(void)data;

+	/*fprintf(stderr,

+		"Call to deprecated function duh_sigrenderer_set_callback(). The callback\n"

+		"was not installed. See dumb/docs/deprec.txt for how to fix this.\n");*/

+}

+

+

+

+void duh_sigrenderer_set_analyser_callback(

+	DUH_SIGRENDERER *sigrenderer,

+	DUH_SIGRENDERER_ANALYSER_CALLBACK callback, void *data

+)

+{

+	(void)sigrenderer;

+	(void)callback;

+	(void)data;

+	fprintf(stderr,

+		"Call to deprecated function duh_sigrenderer_set_analyser_callback(). The\n"

+		"callback was not installed. See dumb/docs/deprec.txt for how to fix this.\n");

+}

+

+

+

+void duh_sigrenderer_set_sample_analyser_callback(

+	DUH_SIGRENDERER *sigrenderer,

+	DUH_SIGRENDERER_SAMPLE_ANALYSER_CALLBACK callback, void *data

+)

+{

+	if (sigrenderer) {

+		sigrenderer->callback = callback;

+		sigrenderer->callback_data = data;

+	}

+}

+

+

+

+int duh_sigrenderer_get_n_channels(DUH_SIGRENDERER *sigrenderer)

+{

+	return sigrenderer ? sigrenderer->n_channels : 0;

+}

+

+

+

+long duh_sigrenderer_get_position(DUH_SIGRENDERER *sigrenderer)

+{

+	return sigrenderer ? sigrenderer->pos : -1;

+}

+

+

+

+void duh_sigrenderer_set_sigparam(

+	DUH_SIGRENDERER *sigrenderer,

+	unsigned char id, long value

+)

+{

+	DUH_SIGRENDERER_SET_SIGPARAM proc;

+

+	if (!sigrenderer) return;

+

+	proc = sigrenderer->desc->sigrenderer_set_sigparam;

+	if (proc)

+		(*proc)(sigrenderer->sigrenderer, id, value);

+	else

+		TRACE("Parameter #%d = %ld for signal %c%c%c%c, which does not take parameters.\n",

+			(int)id,

+			value,

+			(int)(sigrenderer->desc->type >> 24),

+			(int)(sigrenderer->desc->type >> 16),

+			(int)(sigrenderer->desc->type >> 8),

+			(int)(sigrenderer->desc->type));

+}

+

+

+

+long duh_sigrenderer_generate_samples(

+	DUH_SIGRENDERER *sigrenderer,

+	float volume, float delta,

+	long size, sample_t **samples

+)

+{

+	long rendered;

+	LONG_LONG t;

+

+	if (!sigrenderer) return 0;

+

+	rendered = (*sigrenderer->desc->sigrenderer_generate_samples)

+				(sigrenderer->sigrenderer, volume, delta, size, samples);

+

+	if (rendered) {

+		if (sigrenderer->callback)

+			(*sigrenderer->callback)(sigrenderer->callback_data,

+				(const sample_t *const *)samples, sigrenderer->n_channels, rendered);

+

+		t = sigrenderer->subpos + (LONG_LONG)(delta * 65536.0 + 0.5) * rendered;

+

+		sigrenderer->pos += (long)(t >> 16);

+		sigrenderer->subpos = (int)t & 65535;

+	}

+

+	return rendered;

+}

+

+

+

+/* DEPRECATED */

+long duh_sigrenderer_get_samples(

+	DUH_SIGRENDERER *sigrenderer,

+	float volume, float delta,

+	long size, sample_t **samples

+)

+{

+	sample_t **s;

+	long rendered;

+	long i;

+	int j;

+	if (!samples) return duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, NULL);

+	s = allocate_sample_buffer(sigrenderer->n_channels, size);

+	if (!s) return 0;

+	dumb_silence(s[0], sigrenderer->n_channels * size);

+	rendered = duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, s);

+	for (j = 0; j < sigrenderer->n_channels; j++)

+		for (i = 0; i < rendered; i++)

+			samples[j][i] += s[0][i*sigrenderer->n_channels+j];

+	destroy_sample_buffer(s);

+	return rendered;

+}

+

+

+

+/* DEPRECATED */

+long duh_render_signal(

+	DUH_SIGRENDERER *sigrenderer,

+	float volume, float delta,

+	long size, sample_t **samples

+)

+{

+	sample_t **s;

+	long rendered;

+	long i;

+	int j;

+	if (!samples) return duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, NULL);

+	s = allocate_sample_buffer(sigrenderer->n_channels, size);

+	if (!s) return 0;

+	dumb_silence(s[0], sigrenderer->n_channels * size);

+	rendered = duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, s);

+	for (j = 0; j < sigrenderer->n_channels; j++)

+		for (i = 0; i < rendered; i++)

+			samples[j][i] += s[0][i*sigrenderer->n_channels+j] >> 8;

+	destroy_sample_buffer(s);

+	return rendered;

+}

+

+

+

+void duh_sigrenderer_get_current_sample(DUH_SIGRENDERER *sigrenderer, float volume, sample_t *samples)

+{

+	if (sigrenderer)

+		(*sigrenderer->desc->sigrenderer_get_current_sample)(sigrenderer->sigrenderer, volume, samples);

+}

+

+

+

+void duh_end_sigrenderer(DUH_SIGRENDERER *sigrenderer)

+{

+	if (sigrenderer) {

+		if (sigrenderer->desc->end_sigrenderer)

+			if (sigrenderer->sigrenderer)

+				(*sigrenderer->desc->end_sigrenderer)(sigrenderer->sigrenderer);

+

+		free(sigrenderer);

+	}

+}

+

+

+

+DUH_SIGRENDERER *duh_encapsulate_raw_sigrenderer(sigrenderer_t *vsigrenderer, DUH_SIGTYPE_DESC *desc, int n_channels, long pos)

+{

+	DUH_SIGRENDERER *sigrenderer;

+

+	if (desc->start_sigrenderer && !vsigrenderer) return NULL;

+

+	sigrenderer = malloc(sizeof(*sigrenderer));

+	if (!sigrenderer) {

+		if (desc->end_sigrenderer)

+			if (vsigrenderer)

+				(*desc->end_sigrenderer)(vsigrenderer);

+		return NULL;

+	}

+

+	sigrenderer->desc = desc;

+	sigrenderer->sigrenderer = vsigrenderer;

+

+	sigrenderer->n_channels = n_channels;

+

+	sigrenderer->pos = pos;

+	sigrenderer->subpos = 0;

+

+	sigrenderer->callback = NULL;

+

+	return sigrenderer;

+}

+

+

+

+sigrenderer_t *duh_get_raw_sigrenderer(DUH_SIGRENDERER *sigrenderer, long type)

+{

+	if (sigrenderer && sigrenderer->desc->type == type)

+		return sigrenderer->sigrenderer;

+

+	return NULL;

+}

+

+

+

+#if 0

+// This function is disabled because we don't know whether we want to destroy

+// the sigrenderer if the type doesn't match. We don't even know if we need

+// the function at all. Who would want to keep an IT_SIGRENDERER (for

+// instance) without keeping the DUH_SIGRENDERER?

+sigrenderer_t *duh_decompose_to_raw_sigrenderer(DUH_SIGRENDERER *sigrenderer, long type)

+{

+	if (sigrenderer && sigrenderer->desc->type == type) {

+

+

+

+	if (sigrenderer) {

+		if (sigrenderer->desc->end_sigrenderer)

+			if (sigrenderer->sigrenderer)

+				(*sigrenderer->desc->end_sigrenderer)(sigrenderer->sigrenderer);

+

+		free(sigrenderer);

+	}

+

+

+

+

+

+

+		return sigrenderer->sigrenderer;

+	}

+

+	return NULL;

+}

+#endif

diff --git a/plugins/dumb/dumb-kode54/src/core/unload.c b/plugins/dumb/dumb-kode54/src/core/unload.c
new file mode 100644
index 00000000..f241f718
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/core/unload.c
@@ -0,0 +1,64 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * unload.c - Code to free a DUH from memory.         / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+

+#include "dumb.h"

+#include "internal/dumb.h"

+

+

+

+static void destroy_signal(DUH_SIGNAL *signal)

+{

+	if (signal) {

+		if (signal->desc)

+			if (signal->desc->unload_sigdata)

+				if (signal->sigdata)

+					(*signal->desc->unload_sigdata)(signal->sigdata);

+

+		free(signal);

+	}

+}

+

+

+

+/* unload_duh(): destroys a DUH struct. You must call this for every DUH

+ * struct created, when you've finished with it.

+ */

+void unload_duh(DUH *duh)

+{

+	int i;

+

+	if (duh) {

+		if (duh->signal) {

+			for (i = 0; i < duh->n_signals; i++)

+				destroy_signal(duh->signal[i]);

+

+			free(duh->signal);

+		}

+

+		if (duh->tag) {

+			if (duh->tag[0][0])

+				free(duh->tag[0][0]);

+			free(duh->tag);

+		}

+

+		free(duh);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/helpers/barray.c b/plugins/dumb/dumb-kode54/src/helpers/barray.c
new file mode 100644
index 00000000..95fe7af1
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/helpers/barray.c
@@ -0,0 +1,159 @@
+#include "internal/barray.h"

+

+#include <string.h>

+

+

+void * bit_array_create(size_t size)

+{

+	size_t bsize = ((size + 7) >> 3) + sizeof(size_t);

+	void * ret = calloc(1, bsize);

+	if (ret) *(size_t *)ret = size;

+	return ret;

+}

+

+void bit_array_destroy(void * array)

+{

+	if (array) free(array);

+}

+

+void * bit_array_dup(void * array)

+{

+	if (array)

+	{

+		size_t * size = (size_t *) array;

+		size_t bsize = ((*size + 7) >> 3) + sizeof(*size);

+		void * ret = malloc(bsize);

+		if (ret) memcpy(ret, array, bsize);

+		return ret;

+	}

+	return NULL;

+}

+

+void bit_array_reset(void * array)

+{

+	if (array)

+	{

+		size_t * size = (size_t *) array;

+		size_t bsize = (*size + 7) >> 3;

+		memset(size + 1, 0, bsize);

+	}

+}

+

+

+void bit_array_set(void * array, size_t bit)

+{

+	if (array)

+	{

+		size_t * size = (size_t *) array;

+		if (bit < *size)

+		{

+			unsigned char * ptr = (unsigned char *)(size + 1);

+			ptr[bit >> 3] |= (1U << (bit & 7));

+		}

+	}

+}

+

+int bit_array_test(void * array, size_t bit)

+{

+	if (array)

+	{

+		size_t * size = (size_t *) array;

+		if (bit < *size)

+		{

+			unsigned char * ptr = (unsigned char *)(size + 1);

+			if (ptr[bit >> 3] & (1U << (bit & 7)))

+			{

+				return 1;

+			}

+		}

+	}

+	return 0;

+}

+

+int bit_array_test_range(void * array, size_t bit, size_t count)

+{

+	if (array)

+	{

+		size_t * size = (size_t *) array;

+		if (bit < *size)

+		{

+			unsigned char * ptr = (unsigned char *)(size + 1);

+			if ((bit & 7) && (count > 8))

+			{

+				while ((bit < *size) && count && (bit & 7))

+				{

+					if (ptr[bit >> 3] & (1U << (bit & 7))) return 1;

+					bit++;

+					count--;

+				}

+			}

+			if (!(bit & 7))

+			{

+				while (((*size - bit) >= 8) && (count >= 8))

+				{

+					if (ptr[bit >> 3]) return 1;

+					bit += 8;

+					count -= 8;

+				}

+			}

+			while ((bit < *size) && count)

+			{

+				if (ptr[bit >> 3] & (1U << (bit & 7))) return 1;

+				bit++;

+				count--;

+			}

+		}

+	}

+	return 0;

+}

+

+void bit_array_clear(void * array, size_t bit)

+{

+	if (array)

+	{

+		size_t * size = (size_t *) array;

+		if (bit < *size)

+		{

+			unsigned char * ptr = (unsigned char *)(size + 1);

+			ptr[bit >> 3] &= ~(1U << (bit & 7));

+		}

+	}

+}

+

+void bit_array_merge(void * dest, void * source, size_t offset)

+{

+	if (dest && source)

+	{

+		size_t * dsize = (size_t *) dest;

+		size_t * ssize = (size_t *) source;

+		size_t soffset = 0;

+		while (offset < *dsize && soffset < *ssize)

+		{

+			if (bit_array_test(source, soffset))

+			{

+				bit_array_set(dest, offset);

+			}

+			soffset++;

+			offset++;

+		}

+	}

+}

+

+void bit_array_mask(void * dest, void * source, size_t offset)

+{

+	if (dest && source)

+	{

+		size_t * dsize = (size_t *) dest;

+		size_t * ssize = (size_t *) source;

+		size_t soffset = 0;

+		while (offset < *dsize && soffset < *ssize)

+		{

+			if (bit_array_test(source, soffset))

+			{

+				bit_array_clear(dest, offset);

+			}

+			soffset++;

+			offset++;

+		}

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/helpers/clickrem.c b/plugins/dumb/dumb-kode54/src/helpers/clickrem.c
new file mode 100644
index 00000000..336b492d
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/helpers/clickrem.c
@@ -0,0 +1,281 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * clickrem.c - Click removal helpers.                / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <math.h>

+#include "dumb.h"

+

+

+

+typedef struct DUMB_CLICK DUMB_CLICK;

+

+

+struct DUMB_CLICK_REMOVER

+{

+	DUMB_CLICK *click;

+	int n_clicks;

+

+	int offset;

+};

+

+

+struct DUMB_CLICK

+{

+	DUMB_CLICK *next;

+	long pos;

+	sample_t step;

+};

+

+

+

+DUMB_CLICK_REMOVER *dumb_create_click_remover(void)

+{

+	DUMB_CLICK_REMOVER *cr = malloc(sizeof(*cr));

+	if (!cr) return NULL;

+

+	cr->click = NULL;

+	cr->n_clicks = 0;

+

+	cr->offset = 0;

+

+	return cr;

+}

+

+

+

+void dumb_record_click(DUMB_CLICK_REMOVER *cr, long pos, sample_t step)

+{

+	DUMB_CLICK *click;

+

+	ASSERT(pos >= 0);

+

+	if (!cr || !step) return;

+

+	if (pos == 0) {

+		cr->offset -= step;

+		return;

+	}

+

+	click = malloc(sizeof(*click));

+	if (!click) return;

+

+	click->pos = pos;

+	click->step = step;

+

+	click->next = cr->click;

+	cr->click = click;

+	cr->n_clicks++;

+}

+

+

+

+static DUMB_CLICK *dumb_click_mergesort(DUMB_CLICK *click, int n_clicks)

+{

+	int i;

+	DUMB_CLICK *c1, *c2, **cp;

+

+	if (n_clicks <= 1) return click;

+

+	/* Split the list into two */

+	c1 = click;

+	cp = &c1;

+	for (i = 0; i < n_clicks; i += 2) cp = &(*cp)->next;

+	c2 = *cp;

+	*cp = NULL;

+

+	/* Sort the sublists */

+	c1 = dumb_click_mergesort(c1, (n_clicks + 1) >> 1);

+	c2 = dumb_click_mergesort(c2, n_clicks >> 1);

+

+	/* Merge them */

+	cp = &click;

+	while (c1 && c2) {

+		if (c1->pos > c2->pos) {

+			*cp = c2;

+			c2 = c2->next;

+		} else {

+			*cp = c1;

+			c1 = c1->next;

+		}

+		cp = &(*cp)->next;

+	}

+	if (c2)

+		*cp = c2;

+	else

+		*cp = c1;

+

+	return click;

+}

+

+

+

+void dumb_remove_clicks(DUMB_CLICK_REMOVER *cr, sample_t *samples, long length, int step, float halflife)

+{

+	DUMB_CLICK *click;

+	long pos = 0;

+	int offset;

+	int factor;

+

+	if (!cr) return;

+

+	factor = (int)floor(pow(0.5, 1.0/halflife) * (1U << 31));

+

+	click = dumb_click_mergesort(cr->click, cr->n_clicks);

+	cr->click = NULL;

+	cr->n_clicks = 0;

+

+	length *= step;

+

+	while (click) {

+		DUMB_CLICK *next = click->next;

+		int end = click->pos * step;

+		ASSERT(end <= length);

+		offset = cr->offset;

+		if (offset < 0) {

+			offset = -offset;

+			while (pos < end) {

+				samples[pos] -= offset;

+				offset = (int)(((LONG_LONG)(offset << 1) * factor) >> 32);

+				pos += step;

+			}

+			offset = -offset;

+		} else {

+			while (pos < end) {

+				samples[pos] += offset;

+				offset = (int)(((LONG_LONG)(offset << 1) * factor) >> 32);

+				pos += step;

+			}

+		}

+		cr->offset = offset - click->step;

+		free(click);

+		click = next;

+	}

+

+	offset = cr->offset;

+	if (offset < 0) {

+		offset = -offset;

+		while (pos < length) {

+			samples[pos] -= offset;

+			offset = (int)((LONG_LONG)(offset << 1) * factor >> 32);

+			pos += step;

+		}

+		offset = -offset;

+	} else {

+		while (pos < length) {

+			samples[pos] += offset;

+			offset = (int)((LONG_LONG)(offset << 1) * factor >> 32);

+			pos += step;

+		}

+	}

+	cr->offset = offset;

+}

+

+

+

+sample_t dumb_click_remover_get_offset(DUMB_CLICK_REMOVER *cr)

+{

+	return cr ? cr->offset : 0;

+}

+

+

+

+void dumb_destroy_click_remover(DUMB_CLICK_REMOVER *cr)

+{

+	if (cr) {

+		DUMB_CLICK *click = cr->click;

+		while (click) {

+			DUMB_CLICK *next = click->next;

+			free(click);

+			click = next;

+		}

+		free(cr);

+	}

+}

+

+

+

+DUMB_CLICK_REMOVER **dumb_create_click_remover_array(int n)

+{

+	int i;

+	DUMB_CLICK_REMOVER **cr;

+	if (n <= 0) return NULL;

+	cr = malloc(n * sizeof(*cr));

+	if (!cr) return NULL;

+	for (i = 0; i < n; i++) cr[i] = dumb_create_click_remover();

+	return cr;

+}

+

+

+

+void dumb_record_click_array(int n, DUMB_CLICK_REMOVER **cr, long pos, sample_t *step)

+{

+	if (cr) {

+		int i;

+		for (i = 0; i < n; i++)

+			dumb_record_click(cr[i], pos, step[i]);

+	}

+}

+

+

+

+void dumb_record_click_negative_array(int n, DUMB_CLICK_REMOVER **cr, long pos, sample_t *step)

+{

+	if (cr) {

+		int i;

+		for (i = 0; i < n; i++)

+			dumb_record_click(cr[i], pos, -step[i]);

+	}

+}

+

+

+

+void dumb_remove_clicks_array(int n, DUMB_CLICK_REMOVER **cr, sample_t **samples, long length, float halflife)

+{

+	if (cr) {

+		int i;

+		for (i = 0; i < n >> 1; i++) {

+			dumb_remove_clicks(cr[i << 1], samples[i], length, 2, halflife);

+			dumb_remove_clicks(cr[(i << 1) + 1], samples[i] + 1, length, 2, halflife);

+		}

+		if (n & 1)

+			dumb_remove_clicks(cr[i << 1], samples[i], length, 1, halflife);

+	}

+}

+

+

+

+void dumb_click_remover_get_offset_array(int n, DUMB_CLICK_REMOVER **cr, sample_t *offset)

+{

+	if (cr) {

+		int i;

+		for (i = 0; i < n; i++)

+			if (cr[i]) offset[i] += cr[i]->offset;

+	}

+}

+

+

+

+void dumb_destroy_click_remover_array(int n, DUMB_CLICK_REMOVER **cr)

+{

+	if (cr) {

+		int i;

+		for (i = 0; i < n; i++) dumb_destroy_click_remover(cr[i]);

+		free(cr);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/helpers/memfile.c b/plugins/dumb/dumb-kode54/src/helpers/memfile.c
new file mode 100644
index 00000000..6fcbbc7c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/helpers/memfile.c
@@ -0,0 +1,96 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * memfile.c - Module for reading data from           / / \  \

+ *             memory using a DUMBFILE.              | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+

+

+

+typedef struct MEMFILE MEMFILE;

+

+struct MEMFILE

+{

+	const char *ptr;

+	long left;

+};

+

+

+

+static int dumb_memfile_skip(void *f, long n)

+{

+	MEMFILE *m = f;

+	if (n > m->left) return -1;

+	m->ptr += n;

+	m->left -= n;

+	return 0;

+}

+

+

+

+static int dumb_memfile_getc(void *f)

+{

+	MEMFILE *m = f;

+	if (m->left <= 0) return -1;

+	m->left--;

+	return *(const unsigned char *)m->ptr++;

+}

+

+

+

+static long dumb_memfile_getnc(char *ptr, long n, void *f)

+{

+	MEMFILE *m = f;

+	if (n > m->left) n = m->left;

+	memcpy(ptr, m->ptr, n);

+	m->ptr += n;

+	m->left -= n;

+	return n;

+}

+

+

+

+static void dumb_memfile_close(void *f)

+{

+	free(f);

+}

+

+

+

+static const DUMBFILE_SYSTEM memfile_dfs = {

+	NULL,

+	&dumb_memfile_skip,

+	&dumb_memfile_getc,

+	&dumb_memfile_getnc,

+	&dumb_memfile_close

+};

+

+

+

+DUMBFILE *dumbfile_open_memory(const char *data, long size)

+{

+	MEMFILE *m = malloc(sizeof(*m));

+	if (!m) return NULL;

+

+	m->ptr = data;

+	m->left = size;

+

+	return dumbfile_open_ex(m, &memfile_dfs);

+}

diff --git a/plugins/dumb/dumb-kode54/src/helpers/resamp2.inc b/plugins/dumb/dumb-kode54/src/helpers/resamp2.inc
new file mode 100644
index 00000000..ecdc400c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/helpers/resamp2.inc
@@ -0,0 +1,160 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * resamp2.inc - Resampling helper template.          / / \  \

+ *                                                   | <  /   \_

+ * By Bob and entheh.                                |  \/ /\   /

+ *                                                    \_  /  > /

+ * In order to find a good trade-off between            | \ / /

+ * speed and accuracy in this code, some tests          |  ' /

+ * were carried out regarding the behaviour of           \__/

+ * long long ints with gcc. The following code

+ * was tested:

+ *

+ * int a, b, c;

+ * c = ((long long)a * b) >> 16;

+ *

+ * DJGPP GCC Version 3.0.3 generated the following assembly language code for

+ * the multiplication and scaling, leaving the 32-bit result in EAX.

+ *

+ * movl  -8(%ebp), %eax    ; read one int into EAX

+ * imull -4(%ebp)          ; multiply by the other; result goes in EDX:EAX

+ * shrdl $16, %edx, %eax   ; shift EAX right 16, shifting bits in from EDX

+ *

+ * Note that a 32*32->64 multiplication is performed, allowing for high

+ * accuracy. On the Pentium 2 and above, shrdl takes two cycles (generally),

+ * so it is a minor concern when four multiplications are being performed

+ * (the cubic resampler). On the Pentium MMX and earlier, it takes four or

+ * more cycles, so this method is unsuitable for use in the low-quality

+ * resamplers.

+ *

+ * Since "long long" is a gcc-specific extension, we use LONG_LONG instead,

+ * defined in dumb.h. We may investigate later what code MSVC generates, but

+ * if it seems too slow then we suggest you use a good compiler.

+ *

+ * FIXME: these comments are somewhat out of date now.

+ */

+

+

+

+#define SUFFIX3 _1

+

+/* For convenience, returns nonzero on stop. */

+static int process_pickup(DUMB_RESAMPLER *resampler)

+{

+	if (resampler->overshot < 0) {

+		resampler->overshot = 0;

+		dumb_resample(resampler, NULL, 2, MONO_DEST_VOLUME_ZEROS, 1.0f); /* Doesn't matter which SUFFIX3. */

+		COPYSRC(resampler->X, 0, resampler->X, 1);

+	}

+

+	for (;;) {

+		SRCTYPE *src = resampler->src;

+

+		if (resampler->dir < 0) {

+			if (resampler->overshot >= 3 && resampler->pos+3 >= resampler->start) COPYSRC(resampler->X, 0, src, resampler->pos+3);

+			if (resampler->overshot >= 2 && resampler->pos+2 >= resampler->start) COPYSRC(resampler->X, 1, src, resampler->pos+2);

+			if (resampler->overshot >= 1 && resampler->pos+1 >= resampler->start) COPYSRC(resampler->X, 2, src, resampler->pos+1);

+			resampler->overshot = resampler->start - resampler->pos - 1;

+		} else {

+			if (resampler->overshot >= 3 && resampler->pos-3 < resampler->end) COPYSRC(resampler->X, 0, src, resampler->pos-3);

+			if (resampler->overshot >= 2 && resampler->pos-2 < resampler->end) COPYSRC(resampler->X, 1, src, resampler->pos-2);

+			if (resampler->overshot >= 1 && resampler->pos-1 < resampler->end) COPYSRC(resampler->X, 2, src, resampler->pos-1);

+			resampler->overshot = resampler->pos - resampler->end;

+		}

+

+		if (resampler->overshot < 0) {

+			resampler->overshot = 0;

+			return 0;

+		}

+

+		if (!resampler->pickup) {

+			resampler->dir = 0;

+			return 1;

+		}

+		(*resampler->pickup)(resampler, resampler->pickup_data);

+		if (resampler->dir == 0) return 1;

+		ASSERT(resampler->dir == -1 || resampler->dir == 1);

+	}

+}

+

+

+

+/* Create mono destination resampler. */

+/* SUFFIX3 was set above. */

+#define VOLUME_PARAMETERS MONO_DEST_VOLUME_PARAMETERS

+#define VOLUME_VARIABLES MONO_DEST_VOLUME_VARIABLES

+#define SET_VOLUME_VARIABLES SET_MONO_DEST_VOLUME_VARIABLES

+#define RETURN_VOLUME_VARIABLES RETURN_MONO_DEST_VOLUME_VARIABLES

+#define VOLUMES_ARE_ZERO MONO_DEST_VOLUMES_ARE_ZERO

+#define MIX_ALIAS(op, upd, offset) MONO_DEST_MIX_ALIAS(op, upd, offset)

+#define MIX_LINEAR(op, upd, o0, o1) MONO_DEST_MIX_LINEAR(op, upd, o0, o1)

+#define MIX_CUBIC(op, upd, x0, x3, o0, o1, o2, o3) MONO_DEST_MIX_CUBIC(op, upd, x0, x3, o0, o1, o2, o3)

+#define MIX_ZEROS(op) *dst++ op 0

+#include "resamp3.inc"

+

+/* Create stereo destination resampler. */

+#define SUFFIX3 _2

+#define VOLUME_PARAMETERS DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right

+#define VOLUME_VARIABLES lvol=0, lvolr=0, lvold=0, lvolt=0, lvolm=0, rvol=0, rvolr=0, rvold=0, rvolt=0, rvolm=0

+#define SET_VOLUME_VARIABLES { \

+	if ( volume_left ) { \

+		lvolr = (int)(volume_left->volume * 16777216.0); \

+		lvold = (int)(volume_left->delta * 16777216.0); \

+		lvolt = (int)(volume_left->target * 16777216.0); \

+		lvolm = (int)(volume_left->mix * 16777216.0); \

+		lvol = MULSCV( lvolr, lvolm ); \

+		if ( lvolr == lvolt ) volume_left = NULL; \

+	} else { \

+		lvol = 0; \

+		lvolt = 0; \

+	} \

+	if ( volume_right ) { \

+		rvolr = (int)(volume_right->volume * 16777216.0); \

+		rvold = (int)(volume_right->delta * 16777216.0); \

+		rvolt = (int)(volume_right->target * 16777216.0); \

+		rvolm = (int)(volume_right->mix * 16777216.0); \

+		rvol = MULSCV( rvolr, rvolm ); \

+		if ( rvolr == rvolt ) volume_right = NULL; \

+	} else { \

+		rvol = 0; \

+		rvolt = 0; \

+	} \

+}

+#define RETURN_VOLUME_VARIABLES { \

+	if ( volume_left ) volume_left->volume = (float)lvolr / 16777216.0f; \

+	if ( volume_right ) volume_right->volume = (float)rvolr / 16777216.0f; \

+}

+#define VOLUMES_ARE_ZERO (lvol == 0 && lvolt == 0 && rvol == 0 && rvolt == 0)

+#define MIX_ALIAS(op, upd, offset) STEREO_DEST_MIX_ALIAS(op, upd, offset)

+#define MIX_LINEAR(op, upd, o0, o1) STEREO_DEST_MIX_LINEAR(op, upd, o0, o1)

+#define MIX_CUBIC(op, upd, x0, x3, o0, o1, o2, o3) STEREO_DEST_MIX_CUBIC(op, upd, x0, x3, o0, o1, o2, o3)

+#define MIX_ZEROS(op) { *dst++ op 0; *dst++ op 0; }

+#include "resamp3.inc"

+

+

+

+#undef STEREO_DEST_MIX_CUBIC

+#undef MONO_DEST_MIX_CUBIC

+#undef STEREO_DEST_MIX_LINEAR

+#undef MONO_DEST_MIX_LINEAR

+#undef STEREO_DEST_MIX_ALIAS

+#undef MONO_DEST_MIX_ALIAS

+#undef MONO_DEST_VOLUMES_ARE_ZERO

+#undef SET_MONO_DEST_VOLUME_VARIABLES

+#undef RETURN_MONO_DEST_VOLUME_VARIABLES

+#undef MONO_DEST_VOLUME_ZEROS

+#undef MONO_DEST_VOLUME_VARIABLES

+#undef MONO_DEST_VOLUME_PARAMETERS

+#undef COPYSRC2

+#undef COPYSRC

+#undef DIVIDE_BY_SRC_CHANNELS

+#undef SRC_CHANNELS

+#undef SUFFIX2

diff --git a/plugins/dumb/dumb-kode54/src/helpers/resamp3.inc b/plugins/dumb/dumb-kode54/src/helpers/resamp3.inc
new file mode 100644
index 00000000..0c13f201
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/helpers/resamp3.inc
@@ -0,0 +1,376 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * resamp3.inc - Resampling helper template.          / / \  \

+ *                                                   | <  /   \_

+ * By Bob and entheh.                                |  \/ /\   /

+ *                                                    \_  /  > /

+ * In order to find a good trade-off between            | \ / /

+ * speed and accuracy in this code, some tests          |  ' /

+ * were carried out regarding the behaviour of           \__/

+ * long long ints with gcc. The following code

+ * was tested:

+ *

+ * int a, b, c;

+ * c = ((long long)a * b) >> 16;

+ *

+ * DJGPP GCC Version 3.0.3 generated the following assembly language code for

+ * the multiplication and scaling, leaving the 32-bit result in EAX.

+ *

+ * movl  -8(%ebp), %eax    ; read one int into EAX

+ * imull -4(%ebp)          ; multiply by the other; result goes in EDX:EAX

+ * shrdl $16, %edx, %eax   ; shift EAX right 16, shifting bits in from EDX

+ *

+ * Note that a 32*32->64 multiplication is performed, allowing for high

+ * accuracy. On the Pentium 2 and above, shrdl takes two cycles (generally),

+ * so it is a minor concern when four multiplications are being performed

+ * (the cubic resampler). On the Pentium MMX and earlier, it takes four or

+ * more cycles, so this method is unsuitable for use in the low-quality

+ * resamplers.

+ *

+ * Since "long long" is a gcc-specific extension, we use LONG_LONG instead,

+ * defined in dumb.h. We may investigate later what code MSVC generates, but

+ * if it seems too slow then we suggest you use a good compiler.

+ *

+ * FIXME: these comments are somewhat out of date now.

+ */

+

+

+

+long dumb_resample(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, VOLUME_PARAMETERS, float delta)

+{

+	int dt;

+	int VOLUME_VARIABLES;

+	long done;

+	long todo;

+	LONG_LONG todo64;

+	int quality;

+

+	if (!resampler || resampler->dir == 0) return 0;

+	ASSERT(resampler->dir == -1 || resampler->dir == 1);

+

+	done = 0;

+	dt = (int)(delta * 65536.0 + 0.5);

+	if (dt == 0) return 0;

+	SET_VOLUME_VARIABLES;

+

+	if (VOLUMES_ARE_ZERO) dst = NULL;

+

+	init_cubic();

+

+	quality = resampler->quality;

+

+	while (done < dst_size) {

+		if (process_pickup(resampler)) {

+			RETURN_VOLUME_VARIABLES;

+			return done;

+		}

+

+		if ((resampler->dir ^ dt) < 0)

+			dt = -dt;

+

+		if (resampler->dir < 0)

+			todo64 = ((((LONG_LONG)(resampler->pos - resampler->start) << 16) + resampler->subpos - dt) / -dt);

+		else

+			todo64 = ((((LONG_LONG)(resampler->end - resampler->pos) << 16) - resampler->subpos - 1 + dt) / dt);

+

+		if (todo64 < 0)

+			todo = 0;

+		else if (todo64 > dst_size - done)

+			todo = dst_size - done;

+		else

+			todo = (long) todo64;

+

+		done += todo;

+

+		{

+			SRCTYPE *src = resampler->src;

+			long pos = resampler->pos;

+			int subpos = resampler->subpos;

+			long diff = pos;

+			long overshot;

+			if (resampler->dir < 0) {

+				if (!dst) {

+					/* Silence or simulation */

+					LONG_LONG new_subpos = subpos + (LONG_LONG)dt * todo;

+					pos += (long)(new_subpos >> 16);

+					subpos = (long)new_subpos & 65535;

+				} else if (quality <= DUMB_RQ_ALIASING) {

+					/* Aliasing, backwards */

+					SRCTYPE xbuf[2*SRC_CHANNELS];

+					SRCTYPE *x = &xbuf[0];

+					SRCTYPE *xstart;

+					COPYSRC(xbuf, 0, resampler->X, 1);

+					COPYSRC(xbuf, 1, resampler->X, 2);

+					while (todo && x < &xbuf[2*SRC_CHANNELS]) {

+						// TODO: check what happens when multiple tempo slides occur per row

+						HEAVYASSERT(pos >= resampler->start);

+						MIX_ALIAS(+=, 1, 0);

+						subpos += dt;

+						pos += subpos >> 16;

+						x -= (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+						todo--;

+					}

+					x = xstart = &src[pos*SRC_CHANNELS];

+					LOOP4(todo,

+						MIX_ALIAS(+=, 1, 2);

+						subpos += dt;

+						x += (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+					);

+					pos += DIVIDE_BY_SRC_CHANNELS(x - xstart);

+				} else if (quality <= DUMB_RQ_LINEAR) {

+					/* Linear interpolation, backwards */

+					SRCTYPE xbuf[3*SRC_CHANNELS];

+					SRCTYPE *x = &xbuf[1*SRC_CHANNELS];

+					COPYSRC(xbuf, 0, resampler->X, 1);

+					COPYSRC(xbuf, 1, resampler->X, 2);

+					COPYSRC(xbuf, 2, src, pos);

+					while (todo && x < &xbuf[3*SRC_CHANNELS]) {

+						HEAVYASSERT(pos >= resampler->start);

+						MIX_LINEAR(+=, 1, 0, -1);

+						subpos += dt;

+						pos += subpos >> 16;

+						x -= (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+						todo--;

+					}

+					// TODO: use xstart for others too

+					x = &src[pos*SRC_CHANNELS];

+					LOOP4(todo,

+						HEAVYASSERT(pos >= resampler->start);

+						MIX_LINEAR(+=, 1, 1, 2);

+						subpos += dt;

+						pos += subpos >> 16;

+						x += (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+					);

+				} else {

+					/* Cubic interpolation, backwards */

+					SRCTYPE xbuf[6*SRC_CHANNELS];

+					SRCTYPE *x = &xbuf[3*SRC_CHANNELS];

+					COPYSRC(xbuf, 0, resampler->X, 0);

+					COPYSRC(xbuf, 1, resampler->X, 1);

+					COPYSRC(xbuf, 2, resampler->X, 2);

+					COPYSRC(xbuf, 3, src, pos);

+					if (pos-1 >= resampler->start) COPYSRC(xbuf, 4, src, pos-1);

+					if (pos-2 >= resampler->start) COPYSRC(xbuf, 5, src, pos-2);

+					while (todo && x < &xbuf[6*SRC_CHANNELS]) {

+						HEAVYASSERT(pos >= resampler->start);

+						MIX_CUBIC(+=, 1, x, x, 0, -1, -2, -3);

+						subpos += dt;

+						pos += subpos >> 16;

+						x -= (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+						todo--;

+					}

+					x = &src[pos*SRC_CHANNELS];

+					LOOP4(todo,

+						HEAVYASSERT(pos >= resampler->start);

+						MIX_CUBIC(+=, 1, x, x, 0, 1, 2, 3);

+						subpos += dt;

+						pos += subpos >> 16;

+						x += (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+					);

+				}

+				diff = diff - pos;

+				overshot = resampler->start - pos - 1;

+				if (diff >= 3) {

+					COPYSRC2(resampler->X, 0, overshot < 3, src, pos+3);

+					COPYSRC2(resampler->X, 1, overshot < 2, src, pos+2);

+					COPYSRC2(resampler->X, 2, overshot < 1, src, pos+1);

+				} else if (diff >= 2) {

+					COPYSRC(resampler->X, 0, resampler->X, 2);

+					COPYSRC2(resampler->X, 1, overshot < 2, src, pos+2);

+					COPYSRC2(resampler->X, 2, overshot < 1, src, pos+1);

+				} else if (diff >= 1) {

+					COPYSRC(resampler->X, 0, resampler->X, 1);

+					COPYSRC(resampler->X, 1, resampler->X, 2);

+					COPYSRC2(resampler->X, 2, overshot < 1, src, pos+1);

+				}

+			} else {

+				if (!dst) {

+					/* Silence or simulation */

+					LONG_LONG new_subpos = subpos + (LONG_LONG)dt * todo;

+					pos += (long)(new_subpos >> 16);

+					subpos = (long)new_subpos & 65535;

+				} else if (quality <= DUMB_RQ_ALIASING) {

+					/* Aliasing, forwards */

+					SRCTYPE xbuf[2*SRC_CHANNELS];

+					SRCTYPE *x = &xbuf[0];

+					SRCTYPE *xstart;

+					COPYSRC(xbuf, 0, resampler->X, 1);

+					COPYSRC(xbuf, 1, resampler->X, 2);

+					while (todo && x < &xbuf[2*SRC_CHANNELS]) {

+						HEAVYASSERT(pos < resampler->end);

+						MIX_ALIAS(+=, 1, 0);

+						subpos += dt;

+						pos += subpos >> 16;

+						x += (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+						todo--;

+					}

+					x = xstart = &src[pos*SRC_CHANNELS];

+					LOOP4(todo,

+						MIX_ALIAS(+=, 1, -2);

+						subpos += dt;

+						x += (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+					);

+					pos += DIVIDE_BY_SRC_CHANNELS(x - xstart);

+				} else if (quality <= DUMB_RQ_LINEAR) {

+					/* Linear interpolation, forwards */

+					SRCTYPE xbuf[3*SRC_CHANNELS];

+					SRCTYPE *x = &xbuf[1*SRC_CHANNELS];

+					COPYSRC(xbuf, 0, resampler->X, 1);

+					COPYSRC(xbuf, 1, resampler->X, 2);

+					COPYSRC(xbuf, 2, src, pos);

+					while (todo && x < &xbuf[3*SRC_CHANNELS]) {

+						HEAVYASSERT(pos < resampler->end);

+						MIX_LINEAR(+=, 1, -1, 0);

+						subpos += dt;

+						pos += subpos >> 16;

+						x += (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+						todo--;

+					}

+					x = &src[pos*SRC_CHANNELS];

+					LOOP4(todo,

+						HEAVYASSERT(pos < resampler->end);

+						MIX_LINEAR(+=, 1, -2, -1);

+						subpos += dt;

+						pos += subpos >> 16;

+						x += (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+					);

+				} else {

+					/* Cubic interpolation, forwards */

+					SRCTYPE xbuf[6*SRC_CHANNELS];

+					SRCTYPE *x = &xbuf[3*SRC_CHANNELS];

+					COPYSRC(xbuf, 0, resampler->X, 0);

+					COPYSRC(xbuf, 1, resampler->X, 1);

+					COPYSRC(xbuf, 2, resampler->X, 2);

+					COPYSRC(xbuf, 3, src, pos);

+					if (pos+1 < resampler->end) COPYSRC(xbuf, 4, src, pos+1);

+					if (pos+2 < resampler->end) COPYSRC(xbuf, 5, src, pos+2);

+					while (todo && x < &xbuf[6*SRC_CHANNELS]) {

+						HEAVYASSERT(pos < resampler->end);

+						MIX_CUBIC(+=, 1, x, x, -3, -2, -1, 0);

+						subpos += dt;

+						pos += subpos >> 16;

+						x += (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+						todo--;

+					}

+					x = &src[pos*SRC_CHANNELS];

+					LOOP4(todo,

+						HEAVYASSERT(pos < resampler->end);

+						MIX_CUBIC(+=, 1, x, x, -3, -2, -1, 0);

+						subpos += dt;

+						pos += subpos >> 16;

+						x += (subpos >> 16) * SRC_CHANNELS;

+						subpos &= 65535;

+					);

+				}

+				diff = pos - diff;

+				overshot = pos - resampler->end;

+				if (diff >= 3) {

+					COPYSRC2(resampler->X, 0, overshot < 3, src, pos-3);

+					COPYSRC2(resampler->X, 1, overshot < 2, src, pos-2);

+					COPYSRC2(resampler->X, 2, overshot < 1, src, pos-1);

+				} else if (diff >= 2) {

+					COPYSRC(resampler->X, 0, resampler->X, 2);

+					COPYSRC2(resampler->X, 1, overshot < 2, src, pos-2);

+					COPYSRC2(resampler->X, 2, overshot < 1, src, pos-1);

+				} else if (diff >= 1) {

+					COPYSRC(resampler->X, 0, resampler->X, 1);

+					COPYSRC(resampler->X, 1, resampler->X, 2);

+					COPYSRC2(resampler->X, 2, overshot < 1, src, pos-1);

+				}

+			}

+			resampler->pos = pos;

+			resampler->subpos = subpos;

+		}

+	}

+

+	RETURN_VOLUME_VARIABLES;

+	return done;

+}

+

+

+

+void dumb_resample_get_current_sample(DUMB_RESAMPLER *resampler, VOLUME_PARAMETERS, sample_t *dst)

+{

+	int VOLUME_VARIABLES;

+	SRCTYPE *src;

+	long pos;

+	int subpos;

+	int quality;

+	SRCTYPE *x;

+

+	if (!resampler || resampler->dir == 0) { MIX_ZEROS(=); return; }

+	ASSERT(resampler->dir == -1 || resampler->dir == 1);

+

+	if (process_pickup(resampler)) { MIX_ZEROS(=); return; }

+

+	SET_VOLUME_VARIABLES;

+

+	if (VOLUMES_ARE_ZERO) { MIX_ZEROS(=); return; }

+

+	init_cubic();

+

+	quality = resampler->quality;

+

+	src = resampler->src;

+	pos = resampler->pos;

+	subpos = resampler->subpos;

+	x = resampler->X;

+

+	if (resampler->dir < 0) {

+		HEAVYASSERT(pos >= resampler->start);

+		if (dumb_resampling_quality <= DUMB_RQ_ALIASING) {

+			/* Aliasing, backwards */

+			MIX_ALIAS(=, 0, 1);

+		} else if (quality <= DUMB_RQ_LINEAR) {

+			/* Linear interpolation, backwards */

+			MIX_LINEAR(=, 0, 2, 1);

+		} else {

+			/* Cubic interpolation, backwards */

+			MIX_CUBIC(=, 0, src, x, pos, 2, 1, 0);

+		}

+	} else {

+		HEAVYASSERT(pos < resampler->end);

+		if (dumb_resampling_quality <= DUMB_RQ_ALIASING) {

+			/* Aliasing */

+			MIX_ALIAS(=, 0, 1);

+		} else if (dumb_resampling_quality <= DUMB_RQ_LINEAR) {

+			/* Linear interpolation, forwards */

+			MIX_LINEAR(=, 0, 1, 2);

+		} else {

+			/* Cubic interpolation, forwards */

+			MIX_CUBIC(=, 0, x, src, 0, 1, 2, pos);

+		}

+	}

+}

+

+

+

+#undef MIX_ZEROS

+#undef MIX_CUBIC

+#undef MIX_LINEAR

+#undef MIX_ALIAS

+#undef VOLUMES_ARE_ZERO

+#undef SET_VOLUME_VARIABLES

+#undef RETURN_VOLUME_VARIABLES

+#undef VOLUME_VARIABLES

+#undef VOLUME_PARAMETERS

+#undef SUFFIX3

diff --git a/plugins/dumb/dumb-kode54/src/helpers/resample.c b/plugins/dumb/dumb-kode54/src/helpers/resample.c
new file mode 100644
index 00000000..033538c5
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/helpers/resample.c
@@ -0,0 +1,393 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * resample.c - Resampling helpers.                   / / \  \

+ *                                                   | <  /   \_

+ * By Bob and entheh.                                |  \/ /\   /

+ *                                                    \_  /  > /

+ * In order to find a good trade-off between            | \ / /

+ * speed and accuracy in this code, some tests          |  ' /

+ * were carried out regarding the behaviour of           \__/

+ * long long ints with gcc. The following code

+ * was tested:

+ *

+ * int a, b, c;

+ * c = ((long long)a * b) >> 16;

+ *

+ * DJGPP GCC Version 3.0.3 generated the following assembly language code for

+ * the multiplication and scaling, leaving the 32-bit result in EAX.

+ *

+ * movl  -8(%ebp), %eax    ; read one int into EAX

+ * imull -4(%ebp)          ; multiply by the other; result goes in EDX:EAX

+ * shrdl $16, %edx, %eax   ; shift EAX right 16, shifting bits in from EDX

+ *

+ * Note that a 32*32->64 multiplication is performed, allowing for high

+ * accuracy. On the Pentium 2 and above, shrdl takes two cycles (generally),

+ * so it is a minor concern when four multiplications are being performed

+ * (the cubic resampler). On the Pentium MMX and earlier, it takes four or

+ * more cycles, so this method is unsuitable for use in the low-quality

+ * resamplers.

+ *

+ * Since "long long" is a gcc-specific extension, we use LONG_LONG instead,

+ * defined in dumb.h. We may investigate later what code MSVC generates, but

+ * if it seems too slow then we suggest you use a good compiler.

+ *

+ * FIXME: these comments are somewhat out of date now.

+ */

+

+#include <math.h>

+#include "dumb.h"

+

+

+

+/* Compile with -DHEAVYDEBUG if you want to make sure the pick-up function is

+ * called when it should be. There will be a considerable performance hit,

+ * since at least one condition has to be tested for every sample generated.

+ */

+#ifdef HEAVYDEBUG

+#define HEAVYASSERT(cond) ASSERT(cond)

+#else

+#define HEAVYASSERT(cond)

+#endif

+

+

+

+/* Make MSVC shut the hell up about if ( upd ) UPDATE_VOLUME() conditions being constant */

+#ifdef _MSC_VER

+#pragma warning(disable:4127 4701)

+#endif

+

+

+

+/* A global variable for controlling resampling quality wherever a local

+ * specification doesn't override it. The following values are valid:

+ *

+ *  0 - DUMB_RQ_ALIASING - fastest

+ *  1 - DUMB_RQ_LINEAR

+ *  2 - DUMB_RQ_CUBIC    - nicest

+ *

+ * Values outside the range 0-2 will behave the same as the nearest

+ * value within the range.

+ */

+int dumb_resampling_quality = DUMB_RQ_CUBIC;

+

+

+

+//#define MULSC(a, b) ((int)((LONG_LONG)(a) * (b) >> 16))

+//#define MULSC(a, b) ((a) * ((b) >> 2) >> 14)

+#define MULSCV(a, b) ((int)((LONG_LONG)(a) * (b) >> 32))

+#define MULSC(a, b) ((int)((LONG_LONG)((a) << 4) * ((b) << 12) >> 32))

+#define MULSC16(a, b) ((int)((LONG_LONG)((a) << 12) * ((b) << 12) >> 32))

+

+

+

+/* Executes the content 'iterator' times.

+ * Clobbers the 'iterator' variable.

+ * The loop is unrolled by four.

+ */

+#define LOOP4(iterator, CONTENT) \

+{ \

+	if ((iterator) & 2) { \

+		CONTENT; \

+		CONTENT; \

+	} \

+	if ((iterator) & 1) { \

+		CONTENT; \

+	} \

+	(iterator) >>= 2; \

+	while (iterator) { \

+		CONTENT; \

+		CONTENT; \

+		CONTENT; \

+		CONTENT; \

+		(iterator)--; \

+	} \

+}

+

+

+

+#define PASTERAW(a, b) a ## b /* This does not expand macros in b ... */

+#define PASTE(a, b) PASTERAW(a, b) /* ... but b is expanded during this substitution. */

+

+#define X PASTE(x.x, SRCBITS)

+

+

+

+/* Cubic resampler: look-up tables

+ *

+ * a = 1.5*x1 - 1.5*x2 + 0.5*x3 - 0.5*x0

+ * b = 2*x2 + x0 - 2.5*x1 - 0.5*x3

+ * c = 0.5*x2 - 0.5*x0

+ * d = x1

+ *

+ * x = a*t*t*t + b*t*t + c*t + d

+ *   = (-0.5*x0 + 1.5*x1 - 1.5*x2 + 0.5*x3) * t*t*t +

+ *     (   1*x0 - 2.5*x1 + 2  *x2 - 0.5*x3) * t*t +

+ *     (-0.5*x0          + 0.5*x2         ) * t +

+ *     (            1*x1                  )

+ *   = (-0.5*t*t*t + 1  *t*t - 0.5*t    ) * x0 +

+ *     ( 1.5*t*t*t - 2.5*t*t         + 1) * x1 +

+ *     (-1.5*t*t*t + 2  *t*t + 0.5*t    ) * x2 +

+ *     ( 0.5*t*t*t - 0.5*t*t            ) * x3

+ *   = A0(t) * x0 + A1(t) * x1 + A2(t) * x2 + A3(t) * x3

+ *

+ * A0, A1, A2 and A3 stay within the range [-1,1].

+ * In the tables, they are scaled with 14 fractional bits.

+ *

+ * Turns out we don't need to store A2 and A3; they are symmetrical to A1 and A0.

+ *

+ * TODO: A0 and A3 stay very small indeed. Consider different scale/resolution?

+ */

+

+static short cubicA0[1025], cubicA1[1025];

+

+/*static*/ void init_cubic(void)

+{

+	unsigned int t; /* 3*1024*1024*1024 is within range if it's unsigned */

+	static int done = 0;

+	if (done) return;

+	done = 1;

+	for (t = 0; t < 1025; t++) {

+		/* int casts to pacify warnings about negating unsigned values */

+		cubicA0[t] = -(int)(  t*t*t >> 17) + (int)(  t*t >> 6) - (int)(t << 3);

+		cubicA1[t] =  (int)(3*t*t*t >> 17) - (int)(5*t*t >> 7)                 + (int)(1 << 14);

+	}

+}

+

+

+

+/* Create resamplers for 24-in-32-bit source samples. */

+

+/* #define SUFFIX

+ * MSVC warns if we try to paste a null SUFFIX, so instead we define

+ * special macros for the function names that don't bother doing the

+ * corresponding paste. The more generic definitions are further down.

+ */

+#define process_pickup PASTE(process_pickup, SUFFIX2)

+#define dumb_resample PASTE(PASTE(dumb_resample, SUFFIX2), SUFFIX3)

+#define dumb_resample_get_current_sample PASTE(PASTE(dumb_resample_get_current_sample, SUFFIX2), SUFFIX3)

+

+#define SRCTYPE sample_t

+#define SRCBITS 24

+#define ALIAS(x, vol) MULSC(x, vol)

+#define LINEAR(x0, x1) (x0 + MULSC(x1 - x0, subpos))

+/*

+#define SET_CUBIC_COEFFICIENTS(x0, x1, x2, x3) { \

+	a = (3 * (x1 - x2) + (x3 - x0)) >> 1; \

+	b = ((x2 << 2) + (x0 << 1) - (5 * x1 + x3)) >> 1; \

+	c = (x2 - x0) >> 1; \

+}

+#define CUBIC(d) MULSC(MULSC(MULSC(MULSC(a, subpos) + b, subpos) + c, subpos) + d, vol)

+*/

+#define CUBIC(x0, x1, x2, x3) ( \

+	MULSC(x0, cubicA0[subpos >> 6] << 2) + \

+	MULSC(x1, cubicA1[subpos >> 6] << 2) + \

+	MULSC(x2, cubicA1[1 + (subpos >> 6 ^ 1023)] << 2) + \

+	MULSC(x3, cubicA0[1 + (subpos >> 6 ^ 1023)] << 2))

+#define CUBICVOL(x, vol) MULSC(x, vol)

+#include "resample.inc"

+

+/* Undefine the simplified macros. */

+#undef dumb_resample_get_current_sample

+#undef dumb_resample

+#undef process_pickup

+

+

+/* Now define the proper ones that use SUFFIX. */

+#define dumb_reset_resampler PASTE(dumb_reset_resampler, SUFFIX)

+#define dumb_start_resampler PASTE(dumb_start_resampler, SUFFIX)

+#define process_pickup PASTE(PASTE(process_pickup, SUFFIX), SUFFIX2)

+#define dumb_resample PASTE(PASTE(PASTE(dumb_resample, SUFFIX), SUFFIX2), SUFFIX3)

+#define dumb_resample_get_current_sample PASTE(PASTE(PASTE(dumb_resample_get_current_sample, SUFFIX), SUFFIX2), SUFFIX3)

+#define dumb_end_resampler PASTE(dumb_end_resampler, SUFFIX)

+

+/* Create resamplers for 16-bit source samples. */

+#define SUFFIX _16

+#define SRCTYPE short

+#define SRCBITS 16

+#define ALIAS(x, vol) (x * vol >> 8)

+#define LINEAR(x0, x1) ((x0 << 8) + MULSC16(x1 - x0, subpos))

+/*

+#define SET_CUBIC_COEFFICIENTS(x0, x1, x2, x3) { \

+	a = (3 * (x1 - x2) + (x3 - x0)) << 7; \

+	b = ((x2 << 2) + (x0 << 1) - (5 * x1 + x3)) << 7; \

+	c = (x2 - x0) << 7; \

+}

+#define CUBIC(d) MULSC(MULSC(MULSC(MULSC(a, subpos) + b, subpos) + c, subpos) + (d << 8), vol)

+*/

+#define CUBIC(x0, x1, x2, x3) ( \

+	x0 * cubicA0[subpos >> 6] + \

+	x1 * cubicA1[subpos >> 6] + \

+	x2 * cubicA1[1 + (subpos >> 6 ^ 1023)] + \

+	x3 * cubicA0[1 + (subpos >> 6 ^ 1023)])

+#define CUBICVOL(x, vol) (int)((LONG_LONG)(x) * (vol << 10) >> 32)

+#include "resample.inc"

+

+/* Create resamplers for 8-bit source samples. */

+#define SUFFIX _8

+#define SRCTYPE signed char

+#define SRCBITS 8

+#define ALIAS(x, vol) (x * vol)

+#define LINEAR(x0, x1) ((x0 << 16) + (x1 - x0) * subpos)

+/*

+#define SET_CUBIC_COEFFICIENTS(x0, x1, x2, x3) { \

+	a = 3 * (x1 - x2) + (x3 - x0); \

+	b = ((x2 << 2) + (x0 << 1) - (5 * x1 + x3)) << 15; \

+	c = (x2 - x0) << 15; \

+}

+#define CUBIC(d) MULSC(MULSC(MULSC((a * subpos >> 1) + b, subpos) + c, subpos) + (d << 16), vol)

+*/

+#define CUBIC(x0, x1, x2, x3) (( \

+	x0 * cubicA0[subpos >> 6] + \

+	x1 * cubicA1[subpos >> 6] + \

+	x2 * cubicA1[1 + (subpos >> 6 ^ 1023)] + \

+	x3 * cubicA0[1 + (subpos >> 6 ^ 1023)]) << 6)

+#define CUBICVOL(x, vol) (int)((LONG_LONG)(x) * (vol << 12) >> 32)

+#include "resample.inc"

+

+

+#undef dumb_reset_resampler

+#undef dumb_start_resampler

+#undef process_pickup

+#undef dumb_resample

+#undef dumb_resample_get_current_sample

+#undef dumb_end_resampler

+

+

+

+void dumb_reset_resampler_n(int n, DUMB_RESAMPLER *resampler, void *src, int src_channels, long pos, long start, long end, int quality)

+{

+	if (n == 8)

+		dumb_reset_resampler_8(resampler, src, src_channels, pos, start, end, quality);

+	else if (n == 16)

+		dumb_reset_resampler_16(resampler, src, src_channels, pos, start, end, quality);

+	else

+		dumb_reset_resampler(resampler, src, src_channels, pos, start, end, quality);

+}

+

+

+

+DUMB_RESAMPLER *dumb_start_resampler_n(int n, void *src, int src_channels, long pos, long start, long end, int quality)

+{

+	if (n == 8)

+		return dumb_start_resampler_8(src, src_channels, pos, start, end, quality);

+	else if (n == 16)

+		return dumb_start_resampler_16(src, src_channels, pos, start, end, quality);

+	else

+		return dumb_start_resampler(src, src_channels, pos, start, end, quality);

+}

+

+

+

+long dumb_resample_n_1_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume, float delta)

+{

+	if (n == 8)

+		return dumb_resample_8_1_1(resampler, dst, dst_size, volume, delta);

+	else if (n == 16)

+		return dumb_resample_16_1_1(resampler, dst, dst_size, volume, delta);

+	else

+		return dumb_resample_1_1(resampler, dst, dst_size, volume, delta);

+}

+

+

+

+long dumb_resample_n_1_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta)

+{

+	if (n == 8)

+		return dumb_resample_8_1_2(resampler, dst, dst_size, volume_left, volume_right, delta);

+	else if (n == 16)

+		return dumb_resample_16_1_2(resampler, dst, dst_size, volume_left, volume_right, delta);

+	else

+		return dumb_resample_1_2(resampler, dst, dst_size, volume_left, volume_right, delta);

+}

+

+

+

+long dumb_resample_n_2_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta)

+{

+	if (n == 8)

+		return dumb_resample_8_2_1(resampler, dst, dst_size, volume_left, volume_right, delta);

+	else if (n == 16)

+		return dumb_resample_16_2_1(resampler, dst, dst_size, volume_left, volume_right, delta);

+	else

+		return dumb_resample_2_1(resampler, dst, dst_size, volume_left, volume_right, delta);

+}

+

+

+

+long dumb_resample_n_2_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta)

+{

+	if (n == 8)

+		return dumb_resample_8_2_2(resampler, dst, dst_size, volume_left, volume_right, delta);

+	else if (n == 16)

+		return dumb_resample_16_2_2(resampler, dst, dst_size, volume_left, volume_right, delta);

+	else

+		return dumb_resample_2_2(resampler, dst, dst_size, volume_left, volume_right, delta);

+}

+

+

+

+void dumb_resample_get_current_sample_n_1_1(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume, sample_t *dst)

+{

+	if (n == 8)

+		dumb_resample_get_current_sample_8_1_1(resampler, volume, dst);

+	else if (n == 16)

+		dumb_resample_get_current_sample_16_1_1(resampler, volume, dst);

+	else

+		dumb_resample_get_current_sample_1_1(resampler, volume, dst);

+}

+

+

+

+void dumb_resample_get_current_sample_n_1_2(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst)

+{

+	if (n == 8)

+		dumb_resample_get_current_sample_8_1_2(resampler, volume_left, volume_right, dst);

+	else if (n == 16)

+		dumb_resample_get_current_sample_16_1_2(resampler, volume_left, volume_right, dst);

+	else

+		dumb_resample_get_current_sample_1_2(resampler, volume_left, volume_right, dst);

+}

+

+

+

+void dumb_resample_get_current_sample_n_2_1(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst)

+{

+	if (n == 8)

+		dumb_resample_get_current_sample_8_2_1(resampler, volume_left, volume_right, dst);

+	else if (n == 16)

+		dumb_resample_get_current_sample_16_2_1(resampler, volume_left, volume_right, dst);

+	else

+		dumb_resample_get_current_sample_2_1(resampler, volume_left, volume_right, dst);

+}

+

+

+

+void dumb_resample_get_current_sample_n_2_2(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst)

+{

+	if (n == 8)

+		dumb_resample_get_current_sample_8_2_2(resampler, volume_left, volume_right, dst);

+	else if (n == 16)

+		dumb_resample_get_current_sample_16_2_2(resampler, volume_left, volume_right, dst);

+	else

+		dumb_resample_get_current_sample_2_2(resampler, volume_left, volume_right, dst);

+}

+

+

+

+void dumb_end_resampler_n(int n, DUMB_RESAMPLER *resampler)

+{

+	if (n == 8)

+		dumb_end_resampler_8(resampler);

+	else if (n == 16)

+		dumb_end_resampler_16(resampler);

+	else

+		dumb_end_resampler(resampler);

+}

diff --git a/plugins/dumb/dumb-kode54/src/helpers/resample.inc b/plugins/dumb/dumb-kode54/src/helpers/resample.inc
new file mode 100644
index 00000000..d3253cd5
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/helpers/resample.inc
@@ -0,0 +1,264 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * resample.inc - Resampling helper template.         / / \  \

+ *                                                   | <  /   \_

+ * By Bob and entheh.                                |  \/ /\   /

+ *                                                    \_  /  > /

+ * In order to find a good trade-off between            | \ / /

+ * speed and accuracy in this code, some tests          |  ' /

+ * were carried out regarding the behaviour of           \__/

+ * long long ints with gcc. The following code

+ * was tested:

+ *

+ * int a, b, c;

+ * c = ((long long)a * b) >> 16;

+ *

+ * DJGPP GCC Version 3.0.3 generated the following assembly language code for

+ * the multiplication and scaling, leaving the 32-bit result in EAX.

+ *

+ * movl  -8(%ebp), %eax    ; read one int into EAX

+ * imull -4(%ebp)          ; multiply by the other; result goes in EDX:EAX

+ * shrdl $16, %edx, %eax   ; shift EAX right 16, shifting bits in from EDX

+ *

+ * Note that a 32*32->64 multiplication is performed, allowing for high

+ * accuracy. On the Pentium 2 and above, shrdl takes two cycles (generally),

+ * so it is a minor concern when four multiplications are being performed

+ * (the cubic resampler). On the Pentium MMX and earlier, it takes four or

+ * more cycles, so this method is unsuitable for use in the low-quality

+ * resamplers.

+ *

+ * Since "long long" is a gcc-specific extension, we use LONG_LONG instead,

+ * defined in dumb.h. We may investigate later what code MSVC generates, but

+ * if it seems too slow then we suggest you use a good compiler.

+ *

+ * FIXME: these comments are somewhat out of date now.

+ */

+

+

+

+void dumb_reset_resampler(DUMB_RESAMPLER *resampler, SRCTYPE *src, int src_channels, long pos, long start, long end, int quality)

+{

+	int i;

+	resampler->src = src;

+	resampler->pos = pos;

+	resampler->subpos = 0;

+	resampler->start = start;

+	resampler->end = end;

+	resampler->dir = 1;

+	resampler->pickup = NULL;

+	resampler->pickup_data = NULL;

+	if (quality < 0)

+	{

+		resampler->quality = 0;

+	}

+	else if (quality > DUMB_RQ_N_LEVELS - 1)

+	{

+		resampler->quality = DUMB_RQ_N_LEVELS - 1;

+	}

+	else

+	{

+		resampler->quality = quality;

+	}

+	for (i = 0; i < src_channels*3; i++) resampler->X[i] = 0;

+	resampler->overshot = -1;

+}

+

+

+

+DUMB_RESAMPLER *dumb_start_resampler(SRCTYPE *src, int src_channels, long pos, long start, long end, int quality)

+{

+	DUMB_RESAMPLER *resampler = malloc(sizeof(*resampler));

+	if (!resampler) return NULL;

+	dumb_reset_resampler(resampler, src, src_channels, pos, start, end, quality);

+	return resampler;

+}

+

+

+

+#define UPDATE_VOLUME( pvol, vol ) {                               \

+	if (pvol) {                                                    \

+		vol##r += vol##d;                                          \

+		if ((vol##d < 0 && vol##r <= vol##t) ||                    \

+			(vol##d > 0 && vol##r >= vol##t)) {                    \

+			pvol->volume = pvol->target;                           \

+			pvol = NULL;                                           \

+			vol = MULSCV( vol##t, vol##m );                        \

+		} else {                                                   \

+			vol = MULSCV( vol##r, vol##m );                        \

+		}                                                          \

+	}                                                              \

+}

+

+

+

+/* Create mono source resampler. */

+#define SUFFIX2 _1

+#define SRC_CHANNELS 1

+#define DIVIDE_BY_SRC_CHANNELS(x) (x)

+#define COPYSRC(dstarray, dstindex, srcarray, srcindex) (dstarray)[dstindex] = (srcarray)[srcindex]

+#define COPYSRC2(dstarray, dstindex, condition, srcarray, srcindex) (dstarray)[dstindex] = condition ? (srcarray)[srcindex] : 0

+#define MONO_DEST_VOLUME_PARAMETERS DUMB_VOLUME_RAMP_INFO * volume

+#define MONO_DEST_VOLUME_VARIABLES vol=0, volr=0, vold=0, volt=0, volm=0

+#define MONO_DEST_VOLUME_ZEROS 0

+#define SET_MONO_DEST_VOLUME_VARIABLES { \

+	if ( volume ) { \

+		volr = (int)(volume->volume * 16777216.0); \

+		vold = (int)(volume->delta * 16777216.0); \

+		volt = (int)(volume->target * 16777216.0); \

+		volm = (int)(volume->mix * 16777216.0); \

+		vol = MULSCV( volr, volm ); \

+		if ( volr == volt ) volume = NULL; \

+	} else { \

+		vol = 0; \

+		volt = 0; \

+	} \

+}

+#define RETURN_MONO_DEST_VOLUME_VARIABLES if ( volume ) volume->volume = (float)volr / 16777216.0f

+#define MONO_DEST_VOLUMES_ARE_ZERO (vol == 0 && volt == 0)

+#define MONO_DEST_MIX_ALIAS(op, upd, offset) { \

+	*dst++ op ALIAS(x[offset], vol); \

+	if ( upd ) UPDATE_VOLUME( volume, vol ); \

+}

+#define STEREO_DEST_MIX_ALIAS(op, upd, offset) { \

+	int xm = x[offset]; \

+	*dst++ op ALIAS(xm, lvol); \

+	*dst++ op ALIAS(xm, rvol); \

+	if ( upd ) UPDATE_VOLUME( volume_left, lvol ); \

+	if ( upd ) UPDATE_VOLUME( volume_right, rvol ); \

+}

+#define MONO_DEST_MIX_LINEAR(op, upd, o0, o1) { \

+	*dst++ op MULSC(LINEAR(x[o0], x[o1]), vol); \

+	if ( upd ) UPDATE_VOLUME( volume, vol ); \

+}

+#define STEREO_DEST_MIX_LINEAR(op, upd, o0, o1) { \

+	int xm = LINEAR(x[o0], x[o1]); \

+	*dst++ op MULSC(xm, lvol); \

+	*dst++ op MULSC(xm, rvol); \

+	if ( upd ) UPDATE_VOLUME( volume_left, lvol ); \

+	if ( upd ) UPDATE_VOLUME( volume_right, rvol ); \

+}

+#define MONO_DEST_MIX_CUBIC(op, upd, x0, x3, o0, o1, o2, o3) { \

+	*dst++ op CUBICVOL(CUBIC(x0[o0], x[o1], x[o2], x3[o3]), vol); \

+	if ( upd ) UPDATE_VOLUME( volume, vol ); \

+}

+#define STEREO_DEST_MIX_CUBIC(op, upd, x0, x3, o0, o1, o2, o3) { \

+	int xm = CUBIC(x0[o0], x[o1], x[o2], x3[o3]); \

+	*dst++ op CUBICVOL(xm, lvol); \

+	*dst++ op CUBICVOL(xm, rvol); \

+	if ( upd ) UPDATE_VOLUME( volume_left, lvol ); \

+	if ( upd ) UPDATE_VOLUME( volume_right, rvol ); \

+}

+#include "resamp2.inc"

+

+/* Create stereo source resampler. */

+#define SUFFIX2 _2

+#define SRC_CHANNELS 2

+#define DIVIDE_BY_SRC_CHANNELS(x) ((x) >> 1)

+#define COPYSRC(dstarray, dstindex, srcarray, srcindex) { \

+	(dstarray)[(dstindex)*2] = (srcarray)[(srcindex)*2]; \

+	(dstarray)[(dstindex)*2+1] = (srcarray)[(srcindex)*2+1]; \

+}

+#define COPYSRC2(dstarray, dstindex, condition, srcarray, srcindex) { \

+	if (condition) { \

+		(dstarray)[(dstindex)*2] = (srcarray)[(srcindex)*2]; \

+		(dstarray)[(dstindex)*2+1] = (srcarray)[(srcindex)*2+1]; \

+	} else { \

+		(dstarray)[(dstindex)*2] = 0; \

+		(dstarray)[(dstindex)*2+1] = 0; \

+	} \

+}

+

+#define MONO_DEST_VOLUME_PARAMETERS DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right

+#define MONO_DEST_VOLUME_VARIABLES lvol=0, lvolr=0, lvold=0, lvolt=0, lvolm=0, rvol=0, rvolr=0, rvold=0, rvolt=0, rvolm=0

+#define MONO_DEST_VOLUME_ZEROS 0, 0

+#define SET_MONO_DEST_VOLUME_VARIABLES { \

+	if ( volume_left ) { \

+		lvolr = (int)(volume_left->volume * 16777216.0); \

+		lvold = (int)(volume_left->delta * 16777216.0); \

+		lvolt = (int)(volume_left->target * 16777216.0); \

+		lvolm = (int)(volume_left->mix * 16777216.0); \

+		lvol = MULSCV( lvolr, lvolm ); \

+		if ( lvolr == lvolt ) volume_left = NULL; \

+	} else { \

+		lvol = 0; \

+		lvolt = 0; \

+	} \

+	if ( volume_right ) { \

+		rvolr = (int)(volume_right->volume * 16777216.0); \

+		rvold = (int)(volume_right->delta * 16777216.0); \

+		rvolt = (int)(volume_right->target * 16777216.0); \

+		rvolm = (int)(volume_right->mix * 16777216.0); \

+		rvol = MULSCV( rvolr, rvolm ); \

+		if ( rvolr == rvolt ) volume_right = NULL; \

+	} else { \

+		rvol = 0; \

+		rvolt = 0; \

+	} \

+}

+#define RETURN_MONO_DEST_VOLUME_VARIABLES { \

+	if ( volume_left ) volume_left->volume = (float)lvolr / 16777216.0f; \

+	if ( volume_right ) volume_right->volume = (float)rvolr / 16777216.0f; \

+}

+#define MONO_DEST_VOLUMES_ARE_ZERO (lvol == 0 && lvolt == 0 && rvol == 0 && rvolt == 0)

+#define MONO_DEST_MIX_ALIAS(op, upd, offset) { \

+	*dst++ op ALIAS(x[(offset)*2], lvol) + ALIAS(x[(offset)*2+1], rvol); \

+	if ( upd ) UPDATE_VOLUME( volume_left, lvol ); \

+	if ( upd ) UPDATE_VOLUME( volume_right, rvol ); \

+}

+#define STEREO_DEST_MIX_ALIAS(op, upd, offset) { \

+	*dst++ op ALIAS(x[(offset)*2], lvol); \

+	*dst++ op ALIAS(x[(offset)*2+1], rvol); \

+	if ( upd ) UPDATE_VOLUME( volume_left, lvol ); \

+	if ( upd ) UPDATE_VOLUME( volume_right, rvol ); \

+}

+#define MONO_DEST_MIX_LINEAR(op, upd, o0, o1) { \

+	*dst++ op MULSC(LINEAR(x[(o0)*2], x[(o1)*2]), lvol) + MULSC(LINEAR(x[(o0)*2+1], x[(o1)*2+1]), rvol); \

+	if ( upd ) UPDATE_VOLUME( volume_left, lvol ); \

+	if ( upd ) UPDATE_VOLUME( volume_right, rvol ); \

+}

+#define STEREO_DEST_MIX_LINEAR(op, upd, o0, o1) { \

+	*dst++ op MULSC(LINEAR(x[(o0)*2], x[(o1)*2]), lvol); \

+	*dst++ op MULSC(LINEAR(x[(o0)*2+1], x[(o1)*2+1]), rvol); \

+	if ( upd ) UPDATE_VOLUME( volume_left, lvol ); \

+	if ( upd ) UPDATE_VOLUME( volume_right, rvol ); \

+}

+#define MONO_DEST_MIX_CUBIC(op, upd, x0, x3, o0, o1, o2, o3) { \

+	*dst++ op \

+		CUBICVOL(CUBIC(x0[(o0)*2], x[(o1)*2], x[(o2)*2], x3[(o3)*2]), lvol) + \

+		CUBICVOL(CUBIC(x0[(o0)*2+1], x[(o1)*2+1], x[(o2)*2+1], x3[(o3)*2+1]), rvol); \

+	if ( upd ) UPDATE_VOLUME( volume_left, lvol ); \

+	if ( upd ) UPDATE_VOLUME( volume_right, rvol ); \

+}

+#define STEREO_DEST_MIX_CUBIC(op, upd, x0, x3, o0, o1, o2, o3) { \

+	*dst++ op CUBICVOL(CUBIC(x0[(o0)*2], x[(o1)*2], x[(o2)*2], x3[(o3)*2]), lvol); \

+	*dst++ op CUBICVOL(CUBIC(x0[(o0)*2+1], x[(o1)*2+1], x[(o2)*2+1], x3[(o3)*2+1]), rvol); \

+	if ( upd ) UPDATE_VOLUME( volume_left, lvol ); \

+	if ( upd ) UPDATE_VOLUME( volume_right, rvol ); \

+}

+#include "resamp2.inc"

+

+

+

+void dumb_end_resampler(DUMB_RESAMPLER *resampler)

+{

+	if (resampler)

+		free(resampler);

+}

+

+

+

+#undef CUBICVOL

+#undef CUBIC

+#undef LINEAR

+#undef ALIAS

+#undef SRCBITS

+#undef SRCTYPE

+#undef SUFFIX

diff --git a/plugins/dumb/dumb-kode54/src/helpers/riff.c b/plugins/dumb/dumb-kode54/src/helpers/riff.c
new file mode 100644
index 00000000..62a7eccc
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/helpers/riff.c
@@ -0,0 +1,88 @@
+#include "internal/riff.h"

+

+#include <stdlib.h>

+#include <string.h>

+

+struct riff * riff_parse( unsigned char * ptr, unsigned size, unsigned proper )

+{

+	unsigned stream_size;

+	struct riff * stream;

+

+	if ( size < 8 ) return 0;

+

+	if ( ptr[0] != 'R' || ptr[1] != 'I' || ptr[2] != 'F' || ptr[3] != 'F' ) return 0;

+

+	stream_size = ptr[4] | ( ptr[5] << 8 ) | ( ptr[6] << 16 ) | ( ptr[7] << 24 );

+	if ( stream_size + 8 > size ) return 0;

+	if ( stream_size < 4 ) return 0;

+

+	stream = malloc( sizeof( struct riff ) );

+	if ( ! stream ) return 0;

+

+	stream->type = ( ptr[8] << 24 ) | ( ptr[9] << 16 ) | ( ptr[10] << 8 ) | ptr[11];

+	stream->chunk_count = 0;

+	stream->chunks = 0;

+

+	ptr += 12;

+	stream_size -= 4;

+

+	while ( stream_size )

+	{

+		struct riff_chunk * chunk;

+		if ( stream_size < 8 ) break;

+		stream->chunks = realloc( stream->chunks, ( stream->chunk_count + 1 ) * sizeof( struct riff_chunk ) );

+		if ( ! stream->chunks ) break;

+		chunk = stream->chunks + stream->chunk_count;

+		chunk->type = ( ptr[0] << 24 ) | ( ptr[1] << 16 ) | ( ptr[2] << 8 ) | ptr[3];

+		chunk->size = ptr[4] | ( ptr[5] << 8 ) | ( ptr[6] << 16 ) | ( ptr[7] << 24 );

+		ptr += 8;

+		stream_size -= 8;

+		if ( stream_size < chunk->size ) break;

+		if ( chunk->type == 'RIFF' )

+		{

+			chunk->data = riff_parse( ptr - 8, chunk->size + 8, proper );

+			if ( ! chunk->data ) break;

+		}

+		else

+		{

+			chunk->data = malloc( chunk->size );

+			if ( ! chunk->data ) break;

+			memcpy( chunk->data, ptr, chunk->size );

+		}

+		ptr += chunk->size;

+		stream_size -= chunk->size;

+		if ( proper && ( chunk->size & 1 ) )

+		{

+			++ ptr;

+			-- stream_size;

+		}

+		++stream->chunk_count;

+	}

+	

+	if ( stream_size )

+	{

+		riff_free( stream );

+		stream = 0;

+	}

+

+	return stream;

+}

+

+void riff_free( struct riff * stream )

+{

+	if ( stream )

+	{

+		if ( stream->chunks )

+		{

+			unsigned i;

+			for ( i = 0; i < stream->chunk_count; ++i )

+			{

+				struct riff_chunk * chunk = stream->chunks + i;

+				if ( chunk->type == 'RIFF' ) riff_free( ( struct riff * ) chunk->data );

+				else free( chunk->data );

+			}

+			free( stream->chunks );

+		}

+		free( stream );

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/helpers/sampbuf.c b/plugins/dumb/dumb-kode54/src/helpers/sampbuf.c
new file mode 100644
index 00000000..488db449
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/helpers/sampbuf.c
@@ -0,0 +1,64 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * sampbuf.c - Helper for allocating sample           / / \  \

+ *             buffers.                              | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include "dumb.h"

+

+

+

+/* DEPRECATED */

+sample_t **create_sample_buffer(int n_channels, long length)

+{

+	int i;

+	sample_t **samples = malloc(n_channels * sizeof(*samples));

+	if (!samples) return NULL;

+	samples[0] = malloc(n_channels * length * sizeof(*samples[0]));

+	if (!samples[0]) {

+		free(samples);

+		return NULL;

+	}

+	for (i = 1; i < n_channels; i++) samples[i] = samples[i-1] + length;

+	return samples;

+}

+

+

+

+sample_t **allocate_sample_buffer(int n_channels, long length)

+{

+	int i;

+	sample_t **samples = malloc(((n_channels + 1) >> 1) * sizeof(*samples));

+	if (!samples) return NULL;

+	samples[0] = malloc(n_channels * length * sizeof(*samples[0]));

+	if (!samples[0]) {

+		free(samples);

+		return NULL;

+	}

+	for (i = 1; i < (n_channels + 1) >> 1; i++) samples[i] = samples[i-1] + length*2;

+	return samples;

+}

+

+

+

+void destroy_sample_buffer(sample_t **samples)

+{

+	if (samples) {

+		free(samples[0]);

+		free(samples);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/helpers/silence.c b/plugins/dumb/dumb-kode54/src/helpers/silence.c
new file mode 100644
index 00000000..794ae831
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/helpers/silence.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * silence.c - Silencing helper.                      / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <string.h>

+#include "dumb.h"

+

+

+

+void dumb_silence(sample_t *samples, long length)

+{

+	memset(samples, 0, length * sizeof(*samples));

+}

+

diff --git a/plugins/dumb/dumb-kode54/src/helpers/stdfile.c b/plugins/dumb/dumb-kode54/src/helpers/stdfile.c
new file mode 100644
index 00000000..aa398f50
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/helpers/stdfile.c
@@ -0,0 +1,93 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * stdfile.c - stdio file input module.               / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdio.h>

+

+#include "dumb.h"

+

+

+

+static void *dumb_stdfile_open(const char *filename)

+{

+	return fopen(filename, "rb");

+}

+

+

+

+static int dumb_stdfile_skip(void *f, long n)

+{

+	return fseek(f, n, SEEK_CUR);

+}

+

+

+

+static int dumb_stdfile_getc(void *f)

+{

+	return fgetc(f);

+}

+

+

+

+static long dumb_stdfile_getnc(char *ptr, long n, void *f)

+{

+	return fread(ptr, 1, n, f);

+}

+

+

+

+static void dumb_stdfile_close(void *f)

+{

+	fclose(f);

+}

+

+

+

+static DUMBFILE_SYSTEM stdfile_dfs = {

+	&dumb_stdfile_open,

+	&dumb_stdfile_skip,

+	&dumb_stdfile_getc,

+	&dumb_stdfile_getnc,

+	&dumb_stdfile_close

+};

+

+

+

+void dumb_register_stdfiles(void)

+{

+	register_dumbfile_system(&stdfile_dfs);

+}

+

+

+

+static DUMBFILE_SYSTEM stdfile_dfs_leave_open = {

+	NULL,

+	&dumb_stdfile_skip,

+	&dumb_stdfile_getc,

+	&dumb_stdfile_getnc,

+	NULL

+};

+

+

+

+DUMBFILE *dumbfile_open_stdfile(FILE *p)

+{

+	DUMBFILE *d = dumbfile_open_ex(p, &stdfile_dfs_leave_open);

+

+	return d;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/itload.c b/plugins/dumb/dumb-kode54/src/it/itload.c
new file mode 100644
index 00000000..30004233
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/itload.c
@@ -0,0 +1,43 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * itload.c - Code to read an Impulse Tracker         / / \  \

+ *            file, opening and closing it for       | <  /   \_

+ *            you.                                   |  \/ /\   /

+ *                                                    \_  /  > /

+ * By entheh. Don't worry Bob, you're credited          | \ / /

+ * in itread.c!                                         |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_it_quick(): loads an IT file into a DUH struct, returning a

+ * pointer to the DUH struct. When you have finished with it, you must pass

+ * the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_it_quick(const char *filename)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = dumb_read_it_quick(f);

+

+	dumbfile_close(f);

+

+	return duh;

+}

+

diff --git a/plugins/dumb/dumb-kode54/src/it/itload2.c b/plugins/dumb/dumb-kode54/src/it/itload2.c
new file mode 100644
index 00000000..15cff1d0
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/itload2.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * itload2.c - Function to read an Impulse Tracker    / / \  \

+ *             file, opening and closing it for      | <  /   \_

+ *             you, and do an initial run-through.   |  \/ /\   /

+ *                                                    \_  /  > /

+ * Split off from itload.c by entheh.                   | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+

+

+

+DUH *dumb_load_it(const char *filename)

+{

+	DUH *duh = dumb_load_it_quick(filename);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/itmisc.c b/plugins/dumb/dumb-kode54/src/it/itmisc.c
new file mode 100644
index 00000000..22e18b78
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/itmisc.c
@@ -0,0 +1,247 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * itmisc.c - Miscellaneous functions relating        / / \  \

+ *            to module files.                       | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+DUMB_IT_SIGDATA *duh_get_it_sigdata(DUH *duh)

+{

+	return duh_get_raw_sigdata(duh, 0, SIGTYPE_IT);

+}

+

+

+

+const unsigned char *dumb_it_sd_get_song_message(DUMB_IT_SIGDATA *sd)

+{

+	return sd ? sd->song_message : NULL;

+}

+

+

+

+int dumb_it_sd_get_n_orders(DUMB_IT_SIGDATA *sd)

+{

+	return sd ? sd->n_orders : 0;

+}

+

+

+

+int dumb_it_sd_get_n_samples(DUMB_IT_SIGDATA *sd)

+{

+	return sd ? sd->n_samples : 0;

+}

+

+

+

+int dumb_it_sd_get_n_instruments(DUMB_IT_SIGDATA *sd)

+{

+	return sd ? sd->n_instruments : 0;

+}

+

+

+

+const unsigned char *dumb_it_sd_get_sample_name(DUMB_IT_SIGDATA *sd, int i)

+{

+	ASSERT(sd && sd->sample && i >= 0 && i < sd->n_samples);

+	return sd->sample[i].name;

+}

+

+

+

+const unsigned char *dumb_it_sd_get_sample_filename(DUMB_IT_SIGDATA *sd, int i)

+{

+	ASSERT(sd && sd->sample && i >= 0 && i < sd->n_samples);

+	return sd->sample[i].filename;

+}

+

+

+

+const unsigned char *dumb_it_sd_get_instrument_name(DUMB_IT_SIGDATA *sd, int i)

+{

+	ASSERT(sd && sd->instrument && i >= 0 && i < sd->n_instruments);

+	return sd->instrument[i].name;

+}

+

+

+

+const unsigned char *dumb_it_sd_get_instrument_filename(DUMB_IT_SIGDATA *sd, int i)

+{

+	ASSERT(sd && sd->instrument && i >= 0 && i < sd->n_instruments);

+	return sd->instrument[i].filename;

+}

+

+

+

+int dumb_it_sd_get_initial_global_volume(DUMB_IT_SIGDATA *sd)

+{

+	return sd ? sd->global_volume : 0;

+}

+

+

+

+void dumb_it_sd_set_initial_global_volume(DUMB_IT_SIGDATA *sd, int gv)

+{

+	if (sd) sd->global_volume = gv;

+}

+

+

+

+int dumb_it_sd_get_mixing_volume(DUMB_IT_SIGDATA *sd)

+{

+	return sd ? sd->mixing_volume : 0;

+}

+

+

+

+void dumb_it_sd_set_mixing_volume(DUMB_IT_SIGDATA *sd, int mv)

+{

+	if (sd) sd->mixing_volume = mv;

+}

+

+

+

+int dumb_it_sd_get_initial_speed(DUMB_IT_SIGDATA *sd)

+{

+	return sd ? sd->speed : 0;

+}

+

+

+

+void dumb_it_sd_set_initial_speed(DUMB_IT_SIGDATA *sd, int speed)

+{

+	if (sd) sd->speed = speed;

+}

+

+

+

+int dumb_it_sd_get_initial_tempo(DUMB_IT_SIGDATA *sd)

+{

+	return sd ? sd->tempo : 0;

+}

+

+

+

+void dumb_it_sd_set_initial_tempo(DUMB_IT_SIGDATA *sd, int tempo)

+{

+	if (sd) sd->tempo = tempo;

+}

+

+

+

+int dumb_it_sd_get_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel)

+{

+	ASSERT(channel >= 0 && channel < DUMB_IT_N_CHANNELS);

+	return sd ? sd->channel_volume[channel] : 0;

+}

+

+void dumb_it_sd_set_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel, int volume)

+{

+	ASSERT(channel >= 0 && channel < DUMB_IT_N_CHANNELS);

+	if (sd) sd->channel_volume[channel] = volume;

+}

+

+

+

+int dumb_it_sr_get_current_order(DUMB_IT_SIGRENDERER *sr)

+{

+	return sr ? sr->order : -1;

+}

+

+

+

+int dumb_it_sr_get_current_row(DUMB_IT_SIGRENDERER *sr)

+{

+	return sr ? sr->row : -1;

+}

+

+

+

+int dumb_it_sr_get_global_volume(DUMB_IT_SIGRENDERER *sr)

+{

+	return sr ? sr->globalvolume : 0;

+}

+

+

+

+void dumb_it_sr_set_global_volume(DUMB_IT_SIGRENDERER *sr, int gv)

+{

+	if (sr) sr->globalvolume = gv;

+}

+

+

+

+int dumb_it_sr_get_tempo(DUMB_IT_SIGRENDERER *sr)

+{

+	return sr ? sr->tempo : 0;

+}

+

+

+

+void dumb_it_sr_set_tempo(DUMB_IT_SIGRENDERER *sr, int tempo)

+{

+	if (sr) sr->tempo = tempo;

+}

+

+

+

+int dumb_it_sr_get_speed(DUMB_IT_SIGRENDERER *sr)

+{

+	return sr ? sr->speed : 0;

+}

+

+

+

+void dumb_it_sr_set_speed(DUMB_IT_SIGRENDERER *sr, int speed)

+{

+	if (sr) sr->speed = speed;

+}

+

+

+

+int dumb_it_sr_get_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel)

+{

+	return sr ? sr->channel[channel].channelvolume : 0;

+}

+

+

+

+void dumb_it_sr_set_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel, int volume)

+{

+	if (sr) sr->channel[channel].channelvolume = volume;

+}

+

+

+

+void dumb_it_sr_set_channel_muted(DUMB_IT_SIGRENDERER *sr, int channel, int muted)

+{

+	if (sr) {

+		if (muted)

+			sr->channel[channel].flags |= IT_CHANNEL_MUTED;

+		else

+			sr->channel[channel].flags &= ~IT_CHANNEL_MUTED;

+	}

+}

+

+

+

+int dumb_it_sr_get_channel_muted(DUMB_IT_SIGRENDERER *sr, int channel)

+{

+	return sr ? (sr->channel[channel].flags & IT_CHANNEL_MUTED) != 0 : 0;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/itorder.c b/plugins/dumb/dumb-kode54/src/it/itorder.c
new file mode 100644
index 00000000..c3fe51cb
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/itorder.c
@@ -0,0 +1,63 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * itorder.c - Code to fix invalid patterns in        / / \  \

+ *             the pattern table.                    | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Julien Cugniere.                                \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+

+#include <stdlib.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* This function ensures that any pattern mentioned in the order table but

+ * not present in the pattern table is treated as an empty 64 rows pattern.

+ * This is done by adding such a dummy pattern at the end of the pattern

+ * table, and redirect invalid orders to it.

+ * Patterns 254 and 255 are left untouched, unless the signal is an XM.

+ */

+int _dumb_it_fix_invalid_orders(DUMB_IT_SIGDATA *sigdata)

+{

+	int i;

+	int found_some = 0;

+

+	int first_invalid = sigdata->n_patterns;

+	int last_invalid = (sigdata->flags & IT_WAS_AN_XM) ? 255 : 253;

+

+	for (i = 0; i < sigdata->n_orders; i++) {

+		if (sigdata->order[i] >= first_invalid && sigdata->order[i] <= last_invalid) {

+			sigdata->order[i] = sigdata->n_patterns;

+			found_some = 1;

+		}

+	}

+

+	if (found_some) {

+		IT_PATTERN *new_pattern = realloc(sigdata->pattern, sizeof(*sigdata->pattern) * (sigdata->n_patterns + 1));

+		if (!new_pattern)

+			return -1;

+		

+		new_pattern[sigdata->n_patterns].n_rows = 64;

+		new_pattern[sigdata->n_patterns].n_entries = 0;

+		new_pattern[sigdata->n_patterns].entry = NULL;

+		sigdata->pattern = new_pattern;

+		sigdata->n_patterns++;

+	}

+

+	return 0;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/itread.c b/plugins/dumb/dumb-kode54/src/it/itread.c
new file mode 100644
index 00000000..8f5e7ef6
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/itread.c
@@ -0,0 +1,1332 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * itread.c - Code to read an Impulse Tracker         / / \  \

+ *            module from an open file.              | <  /   \_

+ *                                                   |  \/ /\   /

+ * Based on the loader from an IT player by Bob.      \_  /  > /

+ * Adapted for DUMB by entheh.                          | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>//might not be necessary later; required for memset

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+#define INVESTIGATE_OLD_INSTRUMENTS

+

+

+

+static int it_seek(DUMBFILE *f, long offset)

+{

+	long pos = dumbfile_pos(f);

+

+	if (pos > offset)

+		return -1;

+

+	if (pos < offset)

+		if (dumbfile_skip(f, offset - pos))

+			return -1;

+

+	return 0;

+}

+

+

+

+typedef unsigned char byte;

+typedef unsigned short word;

+typedef unsigned long dword;

+

+typedef struct readblock_crap readblock_crap;

+

+struct readblock_crap {

+	unsigned char *sourcebuf;

+	unsigned char *sourcepos;

+	unsigned char *sourceend;

+	int rembits;

+};

+

+

+static int readblock(DUMBFILE *f, readblock_crap * crap)

+{

+	long size;

+	int c;

+

+	size = dumbfile_igetw(f);

+	if (size < 0)

+		return size;

+

+	crap->sourcebuf = malloc(size);

+	if (!crap->sourcebuf)

+		return -1;

+

+	c = dumbfile_getnc((char *)crap->sourcebuf, size, f);

+	if (c < size) {

+		free(crap->sourcebuf);

+		crap->sourcebuf = NULL;

+		return -1;

+	}

+

+	crap->sourcepos = crap->sourcebuf;

+	crap->sourceend = crap->sourcebuf + size;

+	crap->rembits = 8;

+	return 0;

+}

+

+

+

+static void freeblock(readblock_crap * crap)

+{

+	free(crap->sourcebuf);

+	crap->sourcebuf = NULL;

+}

+

+

+

+static int readbits(int bitwidth, readblock_crap * crap)

+{

+	int val = 0;

+	int b = 0;

+

+	if (crap->sourcepos >= crap->sourceend) return val;

+

+	while (bitwidth > crap->rembits) {

+		val |= *crap->sourcepos++ << b;

+		if (crap->sourcepos >= crap->sourceend) return val;

+		b += crap->rembits;

+		bitwidth -= crap->rembits;

+		crap->rembits = 8;

+	}

+

+	val |= (*crap->sourcepos & ((1 << bitwidth) - 1)) << b;

+	*crap->sourcepos >>= bitwidth;

+	crap->rembits -= bitwidth;

+

+	return val;

+}

+

+

+

+/** WARNING - do we even need to pass `right`? */

+/** WARNING - why bother memsetting at all? The whole array is written... */

+// if we do memset, dumb_silence() would be neater...

+static int decompress8(DUMBFILE *f, signed char *data, int len, int it215)

+{

+	int blocklen, blockpos;

+	byte bitwidth;

+	word val;

+	char d1, d2;

+	readblock_crap crap;

+

+	memset(&crap, 0, sizeof(crap));

+

+	memset(data, 0, len * sizeof(*data));

+

+	while (len > 0) {

+		//Read a block of compressed data:

+		if (readblock(f, &crap))

+			return -1;

+		//Set up a few variables

+		blocklen = (len < 0x8000) ? len : 0x8000; //Max block length is 0x8000 bytes

+		blockpos = 0;

+		bitwidth = 9;

+		d1 = d2 = 0;

+		//Start the decompression:

+		while (blockpos < blocklen) {

+			//Read a value:

+			val = (word)readbits(bitwidth, &crap);

+			//Check for bit width change:

+

+			if (bitwidth < 7) { //Method 1:

+				if (val == (1 << (bitwidth - 1))) {

+					val = (word)readbits(3, &crap) + 1;

+					bitwidth = (val < bitwidth) ? val : val + 1;

+					continue;

+				}

+			}

+			else if (bitwidth < 9) { //Method 2

+				byte border = (0xFF >> (9 - bitwidth)) - 4;

+

+				if (val > border && val <= (border + 8)) {

+					val -= border;

+					bitwidth = (val < bitwidth) ? val : val + 1;

+					continue;

+				}

+			}

+			else if (bitwidth == 9) { //Method 3

+				if (val & 0x100) {

+					bitwidth = (val + 1) & 0xFF;

+					continue;

+				}

+			}

+			else { //Illegal width, abort ?

+				freeblock(&crap);

+				return -1;

+			}

+

+			//Expand the value to signed byte:

+			{

+				char v; //The sample value:

+				if (bitwidth < 8) {

+					byte shift = 8 - bitwidth;

+					v = (val << shift);

+					v >>= shift;

+				}

+				else

+					v = (char)val;

+

+				//And integrate the sample value

+				//(It always has to end with integration doesn't it ? ;-)

+				d1 += v;

+				d2 += d1;

+			}

+

+			//Store !

+			/* Version 2.15 was an unofficial version with hacked compression

+			 * code. Yay, better compression :D

+			 */

+			*data++ = it215 ? d2 : d1;

+			len--;

+			blockpos++;

+		}

+		freeblock(&crap);

+	}

+	return 0;

+}

+

+

+

+static int decompress16(DUMBFILE *f, short *data, int len, int it215)

+{

+	int blocklen, blockpos;

+	byte bitwidth;

+	long val;

+	short d1, d2;

+	readblock_crap crap;

+

+	memset(&crap, 0, sizeof(crap));

+

+	memset(data, 0, len * sizeof(*data));

+

+	while (len > 0) {

+		//Read a block of compressed data:

+		if (readblock(f, &crap))

+			return -1;

+		//Set up a few variables

+		blocklen = (len < 0x4000) ? len : 0x4000; // Max block length is 0x4000 bytes

+		blockpos = 0;

+		bitwidth = 17;

+		d1 = d2 = 0;

+		//Start the decompression:

+		while (blockpos < blocklen) {

+			val = readbits(bitwidth, &crap);

+			//Check for bit width change:

+

+			if (bitwidth < 7) { //Method 1:

+				if (val == (1 << (bitwidth - 1))) {

+					val = readbits(4, &crap) + 1;

+					bitwidth = (val < bitwidth) ? val : val + 1;

+					continue;

+				}

+			}

+			else if (bitwidth < 17) { //Method 2

+				word border = (0xFFFF >> (17 - bitwidth)) - 8;

+

+				if (val > border && val <= (border + 16)) {

+					val -= border;

+					bitwidth = val < bitwidth ? val : val + 1;

+					continue;

+				}

+			}

+			else if (bitwidth == 17) { //Method 3

+				if (val & 0x10000) {

+					bitwidth = (val + 1) & 0xFF;

+					continue;

+				}

+			}

+			else { //Illegal width, abort ?

+				freeblock(&crap);

+				return -1;

+			}

+

+			//Expand the value to signed byte:

+			{

+				short v; //The sample value:

+				if (bitwidth < 16) {

+					byte shift = 16 - bitwidth;

+					v = (short)(val << shift);

+					v >>= shift;

+				}

+				else

+					v = (short)val;

+

+				//And integrate the sample value

+				//(It always has to end with integration doesn't it ? ;-)

+				d1 += v;

+				d2 += d1;

+			}

+

+			//Store !

+			/* Version 2.15 was an unofficial version with hacked compression

+			 * code. Yay, better compression :D

+			 */

+			*data++ = it215 ? d2 : d1;

+			len--;

+			blockpos++;

+		}

+		freeblock(&crap);

+	}

+	return 0;

+}

+

+

+

+static int it_read_envelope(IT_ENVELOPE *envelope, DUMBFILE *f)

+{

+	int n;

+

+	envelope->flags = dumbfile_getc(f);

+	envelope->n_nodes = dumbfile_getc(f);

+	envelope->loop_start = dumbfile_getc(f);

+	envelope->loop_end = dumbfile_getc(f);

+	envelope->sus_loop_start = dumbfile_getc(f);

+	envelope->sus_loop_end = dumbfile_getc(f);

+	for (n = 0; n < envelope->n_nodes; n++) {

+		envelope->node_y[n] = dumbfile_getc(f);

+		envelope->node_t[n] = dumbfile_igetw(f);

+	}

+	dumbfile_skip(f, 75 - envelope->n_nodes * 3 + 1);

+

+	if (envelope->n_nodes <= 0)

+		envelope->flags &= ~IT_ENVELOPE_ON;

+	else {

+		if (envelope->loop_end >= envelope->n_nodes || envelope->loop_start > envelope->loop_end) envelope->flags &= ~IT_ENVELOPE_LOOP_ON;

+		if (envelope->sus_loop_end >= envelope->n_nodes || envelope->sus_loop_start > envelope->sus_loop_end) envelope->flags &= ~IT_ENVELOPE_SUSTAIN_LOOP;

+	}

+

+	return dumbfile_error(f);

+}

+

+

+

+static int it_read_old_instrument(IT_INSTRUMENT *instrument, DUMBFILE *f)

+{

+	int n;

+

+	/*if (dumbfile_mgetl(f) != IT_INSTRUMENT_SIGNATURE)

+		return -1;*/

+	// XXX

+	dumbfile_skip(f, 4);

+

+	dumbfile_getnc(instrument->filename, 13, f);

+	instrument->filename[13] = 0;

+

+	instrument->volume_envelope.flags = dumbfile_getc(f);

+	instrument->volume_envelope.loop_start = dumbfile_getc(f);

+	instrument->volume_envelope.loop_end = dumbfile_getc(f);

+	instrument->volume_envelope.sus_loop_start = dumbfile_getc(f);

+	instrument->volume_envelope.sus_loop_end = dumbfile_getc(f);

+

+	/* Skip two unused bytes. */

+	dumbfile_skip(f, 2);

+

+	/* In the old instrument format, fadeout ranges from 0 to 64, and is

+	 * subtracted at intervals from a value starting at 512. In the new

+	 * format, all these values are doubled. Therefore we double when loading

+	 * from the old instrument format - that way we don't have to think about

+	 * it later.

+	 */

+	instrument->fadeout = dumbfile_igetw(f) << 1;

+	instrument->new_note_action = dumbfile_getc(f);

+	instrument->dup_check_type = dumbfile_getc(f);

+	instrument->dup_check_action = DCA_NOTE_CUT; // This might be wrong!

+	/** WARNING - what is the duplicate check action for old-style instruments? */

+

+	/* Skip Tracker Version and Number of Samples. These are only used in

+	 * separate instrument files. Also skip unused byte.

+	 */

+	dumbfile_skip(f, 4);

+

+	dumbfile_getnc(instrument->name, 26, f);

+	instrument->name[26] = 0;

+

+	/* Skip unused bytes following the Instrument Name. */

+	dumbfile_skip(f, 6);

+

+	instrument->pp_separation = 0;

+	instrument->pp_centre = 60;

+	instrument->global_volume = 128;

+	/** WARNING - should global_volume be 64 or something? */

+	instrument->default_pan = 32;

+	/** WARNING - should default_pan be 128, meaning don`t use? */

+	instrument->random_volume = 0;

+	instrument->random_pan = 0;

+

+	for (n = 0; n < 120; n++) {

+		instrument->map_note[n] = dumbfile_getc(f);

+		instrument->map_sample[n] = dumbfile_getc(f);

+	}

+

+	/* Skip "Volume envelope (200 bytes)". */

+	// - need to know better what this is for though.

+	dumbfile_skip(f, 200);

+

+#ifdef INVESTIGATE_OLD_INSTRUMENTS

+	fprintf(stderr, "Inst %02d Env:", n);

+#endif

+

+	for (n = 0; n < 25; n++)

+	{

+		instrument->volume_envelope.node_t[n] = dumbfile_getc(f);

+		instrument->volume_envelope.node_y[n] = dumbfile_getc(f);

+

+#ifdef INVESTIGATE_OLD_INSTRUMENTS

+		fprintf(stderr, " %d,%d",

+				instrument->volume_envelope.node_t[n],

+				instrument->volume_envelope.node_y[n]);

+#endif

+

+		// This loop is unfinished, as we can probably escape from it before

+		// the end if we want to. Hence the otherwise useless dumbfile_skip()

+		// call below.

+	}

+	dumbfile_skip(f, 50 - (n << 1));

+	instrument->volume_envelope.n_nodes = n;

+

+#ifdef INVESTIGATE_OLD_INSTRUMENTS

+	fprintf(stderr, "\n");

+#endif

+

+	if (dumbfile_error(f))

+		return -1;

+

+	{

+		IT_ENVELOPE *envelope = &instrument->volume_envelope;

+		if (envelope->n_nodes <= 0)

+			envelope->flags &= ~IT_ENVELOPE_ON;

+		else {

+			if (envelope->loop_end >= envelope->n_nodes || envelope->loop_start > envelope->loop_end) envelope->flags &= ~IT_ENVELOPE_LOOP_ON;

+			if (envelope->sus_loop_end >= envelope->n_nodes || envelope->sus_loop_start > envelope->sus_loop_end) envelope->flags &= ~IT_ENVELOPE_SUSTAIN_LOOP;

+		}

+	}

+

+	instrument->filter_cutoff = 127;

+	instrument->filter_resonance = 0;

+

+	instrument->pan_envelope.flags = 0;

+	instrument->pitch_envelope.flags = 0;

+

+	return 0;

+}

+

+

+

+static int it_read_instrument(IT_INSTRUMENT *instrument, DUMBFILE *f, int maxlen)

+{

+	int n, len;

+

+	/*if (dumbfile_mgetl(f) != IT_INSTRUMENT_SIGNATURE)

+		return -1;*/

+	// XXX

+

+	if (maxlen) len = dumbfile_pos(f);

+

+	dumbfile_skip(f, 4);

+

+	dumbfile_getnc(instrument->filename, 13, f);

+	instrument->filename[13] = 0;

+

+	instrument->new_note_action = dumbfile_getc(f);

+	instrument->dup_check_type = dumbfile_getc(f);

+	instrument->dup_check_action = dumbfile_getc(f);

+	instrument->fadeout = dumbfile_igetw(f);

+	instrument->pp_separation = dumbfile_getc(f);

+	instrument->pp_centre = dumbfile_getc(f);

+	instrument->global_volume = dumbfile_getc(f);

+	instrument->default_pan = dumbfile_getc(f);

+	instrument->random_volume = dumbfile_getc(f);

+	instrument->random_pan = dumbfile_getc(f);

+

+	/* Skip Tracker Version and Number of Samples. These are only used in

+	 * separate instrument files. Also skip unused byte.

+	 */

+	dumbfile_skip(f, 4);

+

+	dumbfile_getnc(instrument->name, 26, f);

+	instrument->name[26] = 0;

+

+	instrument->filter_cutoff = dumbfile_getc(f);

+	instrument->filter_resonance = dumbfile_getc(f);

+

+	/* Skip MIDI Channel, Program and Bank. */

+	//dumbfile_skip(f, 4);

+	/*instrument->output = dumbfile_getc(f);

+	if ( instrument->output > 16 ) {

+		instrument->output -= 128;

+	} else {

+		instrument->output = 0;

+	}

+	dumbfile_skip(f, 3);*/

+	dumbfile_skip(f, 4);

+

+	for (n = 0; n < 120; n++) {

+		instrument->map_note[n] = dumbfile_getc(f);

+		instrument->map_sample[n] = dumbfile_getc(f);

+	}

+

+	if (dumbfile_error(f))

+		return -1;

+

+	if (it_read_envelope(&instrument->volume_envelope, f)) return -1;

+	if (it_read_envelope(&instrument->pan_envelope, f)) return -1;

+	if (it_read_envelope(&instrument->pitch_envelope, f)) return -1;

+

+	if (maxlen) {

+		len = dumbfile_pos(f) - len;

+		if ( maxlen - len < 124 ) return 0;

+	}

+

+	if ( dumbfile_mgetl(f) == IT_MPTX_SIGNATURE ) {

+		for ( n = 0; n < 120; n++ ) {

+			instrument->map_sample[ n ] += dumbfile_getc( f ) << 8;

+		}

+

+		if (dumbfile_error(f))

+			return -1;

+	}

+

+	/*if ( dumbfile_mgetl(f) == IT_INSM_SIGNATURE ) {

+		long end = dumbfile_igetl(f);

+		end += dumbfile_pos(f);

+		while ( dumbfile_pos(f) < end ) {

+			int chunkid = dumbfile_igetl(f);

+			switch ( chunkid ) {

+				case DUMB_ID('P','L','U','G'):

+					instrument->output = dumbfile_getc(f);

+					break;

+				default:

+					chunkid = chunkid / 0x100 + dumbfile_getc(f) * 0x1000000;

+					break;

+			}

+		}

+

+		if (dumbfile_error(f))

+			return -1;

+	}*/

+

+	return 0;

+}

+

+

+

+static int it_read_sample_header(IT_SAMPLE *sample, unsigned char *convert, long *offset, DUMBFILE *f)

+{

+	/* XXX

+	if (dumbfile_mgetl(f) != IT_SAMPLE_SIGNATURE)

+		return -1;*/

+	int hax = 0;

+	long s = dumbfile_mgetl(f);

+	if (s != IT_SAMPLE_SIGNATURE) {

+		if ( s == ( IT_SAMPLE_SIGNATURE >> 16 ) ) {

+			s <<= 16;

+			s |= dumbfile_mgetw(f);

+			if ( s != IT_SAMPLE_SIGNATURE )

+				return -1;

+			hax = 1;

+		}

+	}

+

+	dumbfile_getnc(sample->filename, 13, f);

+	sample->filename[13] = 0;

+

+	sample->global_volume = dumbfile_getc(f);

+	sample->flags = dumbfile_getc(f);

+	sample->default_volume = dumbfile_getc(f);

+

+	dumbfile_getnc(sample->name, 26, f);

+	sample->name[26] = 0;

+

+	*convert = dumbfile_getc(f);

+	sample->default_pan = dumbfile_getc(f);

+	sample->length = dumbfile_igetl(f);

+	sample->loop_start = dumbfile_igetl(f);

+	sample->loop_end = dumbfile_igetl(f);

+	sample->C5_speed = dumbfile_igetl(f);

+	sample->sus_loop_start = dumbfile_igetl(f);

+	sample->sus_loop_end = dumbfile_igetl(f);

+

+#ifdef STEREO_SAMPLES_COUNT_AS_TWO

+	if (sample->flags & IT_SAMPLE_STEREO) {

+		sample->length >>= 1;

+		sample->loop_start >>= 1;

+		sample->loop_end >>= 1;

+		sample->C5_speed >>= 1;

+		sample->sus_loop_start >>= 1;

+		sample->sus_loop_end >>= 1;

+	}

+#endif

+

+	if (sample->flags & IT_SAMPLE_EXISTS) {

+		if (sample->length <= 0)

+			sample->flags &= ~IT_SAMPLE_EXISTS;

+		else {

+			if ((unsigned int)sample->loop_end > (unsigned int)sample->length)

+				sample->flags &= ~IT_SAMPLE_LOOP;

+			else if ((unsigned int)sample->loop_start >= (unsigned int)sample->loop_end)

+				sample->flags &= ~IT_SAMPLE_LOOP;

+

+			if ((unsigned int)sample->sus_loop_end > (unsigned int)sample->length)

+				sample->flags &= ~IT_SAMPLE_SUS_LOOP;

+			else if ((unsigned int)sample->sus_loop_start >= (unsigned int)sample->sus_loop_end)

+				sample->flags &= ~IT_SAMPLE_SUS_LOOP;

+

+			/* We may be able to truncate the sample to save memory. */

+			if (sample->flags & IT_SAMPLE_LOOP &&

+				*convert != 0xFF) { /* not truncating compressed samples, for now... */

+				if ((sample->flags & IT_SAMPLE_SUS_LOOP) && sample->sus_loop_end >= sample->loop_end)

+					sample->length = sample->sus_loop_end;

+				else

+					sample->length = sample->loop_end;

+			}

+		}

+	}

+

+	*offset = dumbfile_igetl(f);

+

+	sample->vibrato_speed = dumbfile_getc(f);

+	sample->vibrato_depth = dumbfile_getc(f);

+	if ( ! hax ) {

+		sample->vibrato_rate = dumbfile_getc(f);

+		sample->vibrato_waveform = dumbfile_getc(f);

+	} else {

+		sample->vibrato_rate = 0;

+		sample->vibrato_waveform = 0;

+	}

+	sample->finetune = 0;

+	sample->max_resampling_quality = -1;

+

+	return dumbfile_error(f);

+}

+

+long _dumb_it_read_sample_data_adpcm4(IT_SAMPLE *sample, DUMBFILE *f)

+{

+	long n, len, delta;

+	signed char * ptr, * end;

+	signed char compression_table[16];

+	if (dumbfile_getnc(compression_table, 16, f) != 16)

+		return -1;

+	ptr = (signed char *) sample->data;

+	delta = 0;

+

+	end = ptr + sample->length;

+	len = (sample->length + 1) / 2;

+	for (n = 0; n < len; n++) {

+		int b = dumbfile_getc(f);

+		if (b < 0) return -1;

+		delta += compression_table[b & 0x0F];

+		*ptr++ = delta;

+		if (ptr >= end) break;

+		delta += compression_table[b >> 4];

+		*ptr++ = delta;

+	}

+

+	return 0;

+}

+

+

+static long it_read_sample_data(int cmwt, IT_SAMPLE *sample, unsigned char convert, DUMBFILE *f)

+{

+	long n;

+

+	long datasize = sample->length;

+	if (sample->flags & IT_SAMPLE_STEREO) datasize <<= 1;

+

+	sample->data = malloc(datasize * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1));

+	if (!sample->data)

+		return -1;

+

+	if (!(sample->flags & IT_SAMPLE_16BIT) && (convert == 0xFF)) {

+		if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0)

+			return -1;

+	} else if (sample->flags & 8) {

+		/* If the sample is packed, then we must unpack it. */

+

+		/** WARNING - unresolved business here... test with ModPlug? */

+

+		if (sample->flags & IT_SAMPLE_STEREO)

+			//exit(37); // TODO: if this ever happens, maybe sample->length should be doubled below?

+			return -1;

+

+/*

+//#ifndef STEREO_SAMPLES_COUNT_AS_TWO

+		ASSERT(!(sample->flags & IT_SAMPLE_STEREO));

+//#endif

+*/

+		if (sample->flags & IT_SAMPLE_16BIT)

+			decompress16(f, sample->data, datasize, ((cmwt >= 0x215) && (convert & 4)));

+		else

+			decompress8(f, sample->data, datasize, ((cmwt >= 0x215) && (convert & 4)));

+ 	} else if (sample->flags & IT_SAMPLE_16BIT) {

+ 		if (convert & 2)

+			for (n = 0; n < datasize; n++)

+				((short *)sample->data)[n] = dumbfile_mgetw(f);

+ 		else

+			for (n = 0; n < datasize; n++)

+				((short *)sample->data)[n] = dumbfile_igetw(f);

+ 	} else

+		for (n = 0; n < datasize; n++)

+			((signed char *)sample->data)[n] = dumbfile_getc(f);

+

+	if (dumbfile_error(f))

+		return -1;

+

+	if (!(convert & 1)) {

+		/* Convert to signed. */

+		if (sample->flags & IT_SAMPLE_16BIT)

+			for (n = 0; n < datasize; n++)

+				((short *)sample->data)[n] ^= 0x8000;

+		else

+			for (n = 0; n < datasize; n++)

+				((signed char *)sample->data)[n] ^= 0x80;

+	}

+

+	/* NOT SUPPORTED:

+	 *

+	 * convert &  4 - Samples stored as delta values

+	 * convert & 16 - Samples stored as TX-Wave 12-bit values

+	 * convert & 32 - Left/Right/All Stereo prompt

+	 */

+

+	return 0;

+}

+

+

+

+//#define DETECT_DUPLICATE_CHANNELS

+#ifdef DETECT_DUPLICATE_CHANNELS

+#include <stdio.h>

+#endif

+static int it_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer)

+{

+	unsigned char cmask[DUMB_IT_N_CHANNELS];

+	unsigned char cnote[DUMB_IT_N_CHANNELS];

+	unsigned char cinstrument[DUMB_IT_N_CHANNELS];

+	unsigned char cvolpan[DUMB_IT_N_CHANNELS];

+	unsigned char ceffect[DUMB_IT_N_CHANNELS];

+	unsigned char ceffectvalue[DUMB_IT_N_CHANNELS];

+#ifdef DETECT_DUPLICATE_CHANNELS

+	IT_ENTRY *dupentry[DUMB_IT_N_CHANNELS];

+#endif

+

+	int n_entries = 0;

+	int buflen;

+	int bufpos = 0;

+

+	IT_ENTRY *entry;

+

+	unsigned char channel;

+	unsigned char mask;

+

+	memset(cmask, 0, sizeof(cmask));

+	memset(cnote, 0, sizeof(cnote));

+	memset(cinstrument, 0, sizeof(cinstrument));

+	memset(cvolpan, 0, sizeof(cvolpan));

+	memset(ceffect, 0, sizeof(ceffect));

+	memset(ceffectvalue, 0, sizeof(ceffectvalue));

+#ifdef DETECT_DUPLICATE_CHANNELS

+	{

+		int i;

+		for (i = 0; i < DUMB_IT_N_CHANNELS; i++) dupentry[i] = NULL;

+	}

+#endif

+

+	buflen = dumbfile_igetw(f);

+	pattern->n_rows = dumbfile_igetw(f);

+

+	/* Skip four unused bytes. */

+	dumbfile_skip(f, 4);

+

+	if (dumbfile_error(f))

+		return -1;

+

+	/* Read in the pattern data. */

+	dumbfile_getnc(buffer, buflen, f);

+

+	if (dumbfile_error(f))

+		return -1;

+

+	/* Scan the pattern data, and work out how many entries we need room for. */

+	while (bufpos < buflen) {

+		unsigned char b = buffer[bufpos++];

+

+		if (b == 0) {

+			/* End of row */

+			n_entries++;

+			continue;

+		}

+

+		channel = (b - 1) & 63;

+

+		if (b & 128)

+			cmask[channel] = mask = buffer[bufpos++];

+		else

+			mask = cmask[channel];

+

+		{

+			static const unsigned char used[16] = {0, 1, 1, 2, 1, 2, 2, 3, 2, 3, 3, 4, 3, 4, 4, 5};

+			n_entries += (mask != 0);

+			bufpos += used[mask & 15];

+		}

+	}

+

+	pattern->n_entries = n_entries;

+

+	pattern->entry = malloc(n_entries * sizeof(*pattern->entry));

+

+	if (!pattern->entry)

+		return -1;

+

+	bufpos = 0;

+	memset(cmask, 0, sizeof(cmask));

+

+	entry = pattern->entry;

+

+	while (bufpos < buflen) {

+		unsigned char b = buffer[bufpos++];

+

+		if (b == 0) {

+			/* End of row */

+			IT_SET_END_ROW(entry);

+			entry++;

+#ifdef DETECT_DUPLICATE_CHANNELS

+			{

+				int i;

+				for (i = 0; i < DUMB_IT_N_CHANNELS; i++) dupentry[i] = NULL;

+			}

+#endif

+			continue;

+		}

+

+		channel = (b - 1) & 63;

+

+		if (b & 128)

+			cmask[channel] = mask = buffer[bufpos++];

+		else

+			mask = cmask[channel];

+

+		if (mask) {

+			entry->mask = (mask & 15) | (mask >> 4);

+			entry->channel = channel;

+

+			if (mask & IT_ENTRY_NOTE)

+				cnote[channel] = entry->note = buffer[bufpos++];

+			else if (mask & (IT_ENTRY_NOTE << 4))

+				entry->note = cnote[channel];

+

+			if (mask & IT_ENTRY_INSTRUMENT)

+				cinstrument[channel] = entry->instrument = buffer[bufpos++];

+			else if (mask & (IT_ENTRY_INSTRUMENT << 4))

+				entry->instrument = cinstrument[channel];

+

+			if (mask & IT_ENTRY_VOLPAN)

+				cvolpan[channel] = entry->volpan = buffer[bufpos++];

+			else if (mask & (IT_ENTRY_VOLPAN << 4))

+				entry->volpan = cvolpan[channel];

+

+			if (mask & IT_ENTRY_EFFECT) {

+				ceffect[channel] = entry->effect = buffer[bufpos++];

+				ceffectvalue[channel] = entry->effectvalue = buffer[bufpos++];

+			} else {

+				entry->effect = ceffect[channel];

+				entry->effectvalue = ceffectvalue[channel];

+			}

+

+#ifdef DETECT_DUPLICATE_CHANNELS

+			if (dupentry[channel]) {

+				FILE *f = fopen("dupentry.txt", "a");

+				if (!f) abort();

+				fprintf(f, "Two events on channel %d:", channel);

+				fprintf(f, "  Event #1:");

+				if (dupentry[channel]->mask & IT_ENTRY_NOTE      ) fprintf(f, " %03d", dupentry[channel]->note      ); else fprintf(f, " ...");

+				if (dupentry[channel]->mask & IT_ENTRY_INSTRUMENT) fprintf(f, " %03d", dupentry[channel]->instrument); else fprintf(f, " ...");

+				if (dupentry[channel]->mask & IT_ENTRY_VOLPAN    ) fprintf(f, " %03d", dupentry[channel]->volpan    ); else fprintf(f, " ...");

+				if (dupentry[channel]->mask & IT_ENTRY_EFFECT) fprintf(f, " %c%02X\n", 'A' - 1 + dupentry[channel]->effect, dupentry[channel]->effectvalue); else fprintf(f, " ...\n");

+				fprintf(f, "  Event #2:");

+				if (entry->mask & IT_ENTRY_NOTE      ) fprintf(f, " %03d", entry->note      ); else fprintf(f, " ...");

+				if (entry->mask & IT_ENTRY_INSTRUMENT) fprintf(f, " %03d", entry->instrument); else fprintf(f, " ...");

+				if (entry->mask & IT_ENTRY_VOLPAN    ) fprintf(f, " %03d", entry->volpan    ); else fprintf(f, " ...");

+				if (entry->mask & IT_ENTRY_EFFECT) fprintf(f, " %c%02X\n", 'A' - 1 + entry->effect, entry->effectvalue); else fprintf(f, " ...\n");

+				fclose(f);

+			}

+			dupentry[channel] = entry;

+#endif

+

+			entry++;

+		}

+	}

+

+	ASSERT(entry == pattern->entry + n_entries);

+

+	return 0;

+}

+

+

+

+/* Currently we assume the sample data are stored after the sample headers in

+ * module files. This assumption may be unjustified; let me know if you have

+ * trouble.

+ */

+

+#define IT_COMPONENT_SONG_MESSAGE 1

+#define IT_COMPONENT_INSTRUMENT   2

+#define IT_COMPONENT_PATTERN      3

+#define IT_COMPONENT_SAMPLE       4

+

+typedef struct IT_COMPONENT

+{

+	unsigned char type;

+	unsigned short n;

+	long offset;

+	short sampfirst; /* component[sampfirst] = first sample data after this */

+	short sampnext; /* sampnext is used to create linked lists of sample data */

+}

+IT_COMPONENT;

+

+

+

+static int it_component_compare(const void *e1, const void *e2)

+{

+	return ((const IT_COMPONENT *)e1)->offset -

+	       ((const IT_COMPONENT *)e2)->offset;

+}

+

+

+

+static sigdata_t *it_load_sigdata(DUMBFILE *f)

+{

+	DUMB_IT_SIGDATA *sigdata;

+

+	int cwt, cmwt;

+	int special;

+	int message_length, message_offset;

+

+	IT_COMPONENT *component;

+	int n_components = 0;

+

+	unsigned char sample_convert[4096];

+

+	int n;

+

+	unsigned char *buffer;

+

+	if (dumbfile_mgetl(f) != IT_SIGNATURE)

+		return NULL;

+

+	sigdata = malloc(sizeof(*sigdata));

+

+	if (!sigdata)

+		return NULL;

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->sample = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	dumbfile_getnc(sigdata->name, 26, f);

+	sigdata->name[26] = 0;

+

+	/* Skip pattern row highlight info. */

+	dumbfile_skip(f, 2);

+

+	sigdata->n_orders = dumbfile_igetw(f);

+	sigdata->n_instruments = dumbfile_igetw(f);

+	sigdata->n_samples = dumbfile_igetw(f);

+	sigdata->n_patterns = dumbfile_igetw(f);

+

+	cwt = dumbfile_igetw(f);

+	cmwt = dumbfile_igetw(f);

+

+	sigdata->flags = dumbfile_igetw(f);

+	special = dumbfile_igetw(f);

+

+	sigdata->global_volume = dumbfile_getc(f);

+	sigdata->mixing_volume = dumbfile_getc(f);

+	sigdata->speed = dumbfile_getc(f);

+	if (sigdata->speed == 0) sigdata->speed = 6; // Should we? What about tempo?

+	sigdata->tempo = dumbfile_getc(f);

+	sigdata->pan_separation = dumbfile_getc(f); /** WARNING: use this */

+

+	/* Skip Pitch Wheel Depth */

+	dumbfile_skip(f, 1);

+

+	message_length = dumbfile_igetw(f);

+	message_offset = dumbfile_igetl(f);

+

+	/* Skip Reserved. */

+	dumbfile_skip(f, 4);

+

+	dumbfile_getnc(sigdata->channel_pan, DUMB_IT_N_CHANNELS, f);

+	dumbfile_getnc(sigdata->channel_volume, DUMB_IT_N_CHANNELS, f);

+

+	// XXX sample count

+	if (dumbfile_error(f) || sigdata->n_orders <= 0 || sigdata->n_instruments > 256 || sigdata->n_samples > 4000 || sigdata->n_patterns > 256) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	sigdata->order = malloc(sigdata->n_orders);

+	if (!sigdata->order) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	if (sigdata->n_instruments) {

+		sigdata->instrument = malloc(sigdata->n_instruments * sizeof(*sigdata->instrument));

+		if (!sigdata->instrument) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+	}

+

+	if (sigdata->n_samples) {

+		sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));

+		if (!sigdata->sample) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		for (n = 0; n < sigdata->n_samples; n++)

+			sigdata->sample[n].data = NULL;

+	}

+

+	if (sigdata->n_patterns) {

+		sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));

+		if (!sigdata->pattern) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		for (n = 0; n < sigdata->n_patterns; n++)

+			sigdata->pattern[n].entry = NULL;

+	}

+

+	dumbfile_getnc(sigdata->order, sigdata->n_orders, f);

+	sigdata->restart_position = 0;

+

+	component = malloc(769 * sizeof(*component));

+	if (!component) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	if (special & 1) {

+		component[n_components].type = IT_COMPONENT_SONG_MESSAGE;

+		component[n_components].offset = message_offset;

+		component[n_components].sampfirst = -1;

+		n_components++;

+	}

+

+	for (n = 0; n < sigdata->n_instruments; n++) {

+		component[n_components].type = IT_COMPONENT_INSTRUMENT;

+		component[n_components].n = n;

+		component[n_components].offset = dumbfile_igetl(f);

+		component[n_components].sampfirst = -1;

+		n_components++;

+	}

+

+	for (n = 0; n < sigdata->n_samples; n++) {

+		component[n_components].type = IT_COMPONENT_SAMPLE;

+		component[n_components].n = n;

+		component[n_components].offset = dumbfile_igetl(f);

+		component[n_components].sampfirst = -1;

+		n_components++;

+	}

+

+	for (n = 0; n < sigdata->n_patterns; n++) {

+		long offset = dumbfile_igetl(f);

+		if (offset) {

+			component[n_components].type = IT_COMPONENT_PATTERN;

+			component[n_components].n = n;

+			component[n_components].offset = offset;

+			component[n_components].sampfirst = -1;

+			n_components++;

+		} else {

+			/* Empty 64-row pattern */

+			sigdata->pattern[n].n_rows = 64;

+			sigdata->pattern[n].n_entries = 0;

+		}

+	}

+

+	if (dumbfile_error(f)) {

+		free(component);

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	/*

+	if (!(sigdata->flags & 128) != !(special & 8)) {

+		fprintf(stderr, "Flags   Bit 7 (\"Request embedded MIDI configuration\"): %s\n", sigdata->flags & 128 ? "=SET=" : "clear");

+		fprintf(stderr, "Special Bit 3     (\"MIDI configuration embedded\")    : %s\n", special        &   8 ? "=SET=" : "clear");

+		fprintf(stderr, "entheh would like to investigate this IT file.\n");

+		fprintf(stderr, "Please contact him! entheh@users.sf.net\n");

+	}

+	*/

+

+	if (special & 8) {

+		/* MIDI configuration is embedded. */

+		unsigned char mididata[32];

+		int i;

+		sigdata->midi = malloc(sizeof(*sigdata->midi));

+		if (!sigdata->midi) {

+			free(component);

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+			// Should we be happy with this outcome in some situations?

+		}

+		// What are we skipping?

+		i = dumbfile_igetw(f);

+		if (dumbfile_error(f) || dumbfile_skip(f, 8*i)) {

+			free(component);

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		/* Read embedded MIDI configuration */

+		// What are the first 9 commands for?

+		if (dumbfile_skip(f, 32*9)) {

+			free(component);

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		for (i = 0; i < 16; i++) {

+			unsigned char len = 0;

+			int j, leftdigit = -1;

+			if (dumbfile_getnc(mididata, 32, f) < 32) {

+				free(component);

+				_dumb_it_unload_sigdata(sigdata);

+				return NULL;

+			}

+			sigdata->midi->SFmacroz[i] = 0;

+			for (j = 0; j < 32; j++) {

+				if (leftdigit >= 0) {

+					if (mididata[j] == 0) {

+						sigdata->midi->SFmacro[i][len++] = leftdigit;

+						break;

+					} else if (mididata[j] == ' ')

+						sigdata->midi->SFmacro[i][len++] = leftdigit;

+					else if (mididata[j] >= '0' && mididata[j] <= '9')

+						sigdata->midi->SFmacro[i][len++] = (leftdigit << 4) | (mididata[j] - '0');

+					else if (mididata[j] >= 'A' && mididata[j] <= 'F')

+						sigdata->midi->SFmacro[i][len++] = (leftdigit << 4) | (mididata[j] - 'A' + 0xA);

+					leftdigit = -1;

+				} else if (mididata[j] == 0)

+					break;

+				else if (mididata[j] == 'z')

+					sigdata->midi->SFmacroz[i] |= 1 << len++;

+				else if (mididata[j] >= '0' && mididata[j] <= '9')

+					leftdigit = mididata[j] - '0';

+				else if (mididata[j] >= 'A' && mididata[j] <= 'F')

+					leftdigit = mididata[j] - 'A' + 0xA;

+			}

+			sigdata->midi->SFmacrolen[i] = len;

+		}

+		for (i = 0; i < 128; i++) {

+			unsigned char len = 0;

+			int j, leftdigit = -1;

+			dumbfile_getnc(mididata, 32, f);

+			for (j = 0; j < 32; j++) {

+				if (leftdigit >= 0) {

+					if (mididata[j] == 0) {

+						sigdata->midi->Zmacro[i][len++] = leftdigit;

+						break;

+					} else if (mididata[j] == ' ')

+						sigdata->midi->Zmacro[i][len++] = leftdigit;

+					else if (mididata[j] >= '0' && mididata[j] <= '9')

+						sigdata->midi->Zmacro[i][len++] = (leftdigit << 4) | (mididata[j] - '0');

+					else if (mididata[j] >= 'A' && mididata[j] <= 'F')

+						sigdata->midi->Zmacro[i][len++] = (leftdigit << 4) | (mididata[j] - 'A' + 0xA);

+					leftdigit = -1;

+				} else if (mididata[j] == 0)

+					break;

+				else if (mididata[j] >= '0' && mididata[j] <= '9')

+					leftdigit = mididata[j] - '0';

+				else if (mididata[j] >= 'A' && mididata[j] <= 'F')

+					leftdigit = mididata[j] - 'A' + 0xA;

+			}

+			sigdata->midi->Zmacrolen[i] = len;

+		}

+	}

+

+	sigdata->flags &= IT_REAL_FLAGS;

+

+	qsort(component, n_components, sizeof(IT_COMPONENT), &it_component_compare);

+

+	buffer = malloc(65536);

+	if (!buffer) {

+		free(component);

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	for (n = 0; n < n_components; n++) {

+		long offset;

+		int m;

+

+		/* XXX */

+		if ( component[n].offset == 0 ) {

+			switch (component[n].type) {

+				case IT_COMPONENT_INSTRUMENT:

+					memset( &sigdata->instrument[component[n].n], 0, sizeof(IT_INSTRUMENT) );

+					break;

+				case IT_COMPONENT_SAMPLE:

+					memset( &sigdata->sample[component[n].n], 0, sizeof(IT_SAMPLE) );

+					break;

+				case IT_COMPONENT_PATTERN:

+					{

+						IT_PATTERN * p = &sigdata->pattern[component[n].n];

+						p->entry = 0;

+						p->n_rows = 64;

+						p->n_entries = 0;

+					}

+					break;

+			}

+			continue;

+		}

+

+		if (it_seek(f, component[n].offset)) {

+			free(buffer);

+			free(component);

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+

+		switch (component[n].type) {

+

+			case IT_COMPONENT_SONG_MESSAGE:

+				if ( n < n_components ) {

+					message_length = min( message_length, component[n+1].offset - component[n].offset );

+				}

+				sigdata->song_message = malloc(message_length + 1);

+				if (sigdata->song_message) {

+					if (dumbfile_getnc(sigdata->song_message, message_length, f) < message_length) {

+						free(buffer);

+						free(component);

+						_dumb_it_unload_sigdata(sigdata);

+						return NULL;

+					}

+					sigdata->song_message[message_length] = 0;

+				}

+				break;

+

+			case IT_COMPONENT_INSTRUMENT:

+				if (cmwt < 0x200)

+					m = it_read_old_instrument(&sigdata->instrument[component[n].n], f);

+				else

+					m = it_read_instrument(&sigdata->instrument[component[n].n], f, (n + 1 < n_components) ? (component[n+1].offset - component[n].offset) : 0);

+

+				if (m) {

+					free(buffer);

+					free(component);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+				break;

+

+			case IT_COMPONENT_PATTERN:

+				if (it_read_pattern(&sigdata->pattern[component[n].n], f, buffer)) {

+					free(buffer);

+					free(component);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+				break;

+

+			case IT_COMPONENT_SAMPLE:

+				if (it_read_sample_header(&sigdata->sample[component[n].n], &sample_convert[component[n].n], &offset, f)) {

+					free(buffer);

+					free(component);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+

+				if (sigdata->sample[component[n].n].flags & IT_SAMPLE_EXISTS) {

+					short *sample;

+

+					for (m = n + 1; m < n_components; m++)

+						if (component[m].offset > offset)

+							break;

+					m--;

+

+					sample = &component[m].sampfirst;

+

+					while (*sample >= 0 && component[*sample].offset <= offset)

+						sample = &component[*sample].sampnext;

+

+					component[n].sampnext = *sample;

+					*sample = n;

+

+					component[n].offset = offset;

+				}

+		}

+

+		m = component[n].sampfirst;

+

+		while (m >= 0) {

+			if (it_seek(f, component[m].offset)) {

+				free(buffer);

+				free(component);

+				_dumb_it_unload_sigdata(sigdata);

+				return NULL;

+			}

+

+			if (it_read_sample_data(cmwt, &sigdata->sample[component[m].n], sample_convert[component[m].n], f)) {

+				free(buffer);

+				free(component);

+				_dumb_it_unload_sigdata(sigdata);

+				return NULL;

+			}

+

+			m = component[m].sampnext;

+		}

+	}

+

+	free(buffer);

+	free(component);

+

+	_dumb_it_fix_invalid_orders(sigdata);

+

+	return sigdata;

+}

+

+

+

+DUH *dumb_read_it_quick(DUMBFILE *f)

+{

+	sigdata_t *sigdata;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_load_sigdata(f);

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		const char *tag[1][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		return make_duh(-1, 1, (const char *const (*)[2])tag, 1, &descptr, &sigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/itread2.c b/plugins/dumb/dumb-kode54/src/it/itread2.c
new file mode 100644
index 00000000..202b8bb9
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/itread2.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * itread2.c - Function to read an Impulse Tracker    / / \  \

+ *             module from an open file and do an    | <  /   \_

+ *             initial run-through.                  |  \/ /\   /

+ *                                                    \_  /  > /

+ * Split off from itread.c by entheh.                   | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+

+

+

+DUH *dumb_read_it(DUMBFILE *f)

+{

+	DUH *duh = dumb_read_it_quick(f);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/itrender.c b/plugins/dumb/dumb-kode54/src/it/itrender.c
new file mode 100644
index 00000000..5dd8e4ef
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/itrender.c
@@ -0,0 +1,5542 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * itrender.c - Code to render an Impulse Tracker     / / \  \

+ *              module.                              | <  /   \_

+ *                                                   |  \/ /\   /

+ * Written - painstakingly - by entheh.               \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <math.h>

+#include <stdlib.h>

+

+#include "dumb.h"

+#include "internal/dumb.h"

+#include "internal/it.h"

+

+// #define BIT_ARRAY_BULLSHIT

+

+#define END_RAMPING

+#define RAMP_DOWN

+

+static IT_PLAYING *dup_playing(IT_PLAYING *src, IT_CHANNEL *dstchannel, IT_CHANNEL *srcchannel)

+{

+	IT_PLAYING *dst;

+

+	if (!src) return NULL;

+

+	dst = malloc(sizeof(*dst));

+	if (!dst) return NULL;

+

+	dst->flags = src->flags;

+	dst->resampling_quality = src->resampling_quality;

+

+	ASSERT(src->channel);

+	dst->channel = &dstchannel[src->channel - srcchannel];

+	dst->sample = src->sample;

+	dst->instrument = src->instrument;

+	dst->env_instrument = src->env_instrument;

+

+	dst->sampnum = src->sampnum;

+	dst->instnum = src->instnum;

+

+#ifdef END_RAMPING

+	dst->declick_stage = src->declick_stage;

+	dst->declick_volume = src->declick_volume;

+#endif

+

+	dst->float_volume[0] = src->float_volume[0];

+	dst->float_volume[1] = src->float_volume[1];

+

+	dst->ramp_volume[0] = src->ramp_volume[0];

+	dst->ramp_volume[1] = src->ramp_volume[1];

+

+	dst->ramp_delta[0] = src->ramp_delta[0];

+	dst->ramp_delta[1] = src->ramp_delta[1];

+

+	dst->channel_volume = src->channel_volume;

+

+	dst->volume = src->volume;

+	dst->pan = src->pan;

+

+	dst->volume_offset = src->volume_offset;

+	dst->panning_offset = src->panning_offset;

+

+	dst->note = src->note;

+

+	dst->enabled_envelopes = src->enabled_envelopes;

+

+	dst->filter_cutoff = src->filter_cutoff;

+	dst->filter_resonance = src->filter_resonance;

+

+	dst->true_filter_cutoff = src->true_filter_cutoff;

+	dst->true_filter_resonance = src->true_filter_resonance;

+

+	dst->vibrato_speed = src->vibrato_speed;

+	dst->vibrato_depth = src->vibrato_depth;

+	dst->vibrato_n = src->vibrato_n;

+	dst->vibrato_time = src->vibrato_time;

+	dst->vibrato_waveform = src->vibrato_waveform;

+

+	dst->tremolo_speed = src->tremolo_speed;

+	dst->tremolo_depth = src->tremolo_depth;

+	dst->tremolo_time = src->tremolo_time;

+	dst->tremolo_waveform = src->tremolo_waveform;

+

+	dst->panbrello_speed = src->panbrello_speed;

+	dst->panbrello_depth = src->panbrello_depth;

+	dst->panbrello_time = src->panbrello_time;

+	dst->panbrello_waveform = src->panbrello_waveform;

+	dst->panbrello_random = src->panbrello_random;

+

+	dst->sample_vibrato_time = src->sample_vibrato_time;

+	dst->sample_vibrato_waveform = src->sample_vibrato_waveform;

+	dst->sample_vibrato_depth = src->sample_vibrato_depth;

+

+	dst->slide = src->slide;

+	dst->delta = src->delta;

+	dst->finetune = src->finetune;

+

+	dst->volume_envelope = src->volume_envelope;

+	dst->pan_envelope = src->pan_envelope;

+	dst->pitch_envelope = src->pitch_envelope;

+

+	dst->fadeoutcount = src->fadeoutcount;

+

+	dst->filter_state[0] = src->filter_state[0];

+	dst->filter_state[1] = src->filter_state[1];

+

+	dst->resampler = src->resampler;

+	dst->resampler.pickup_data = dst;

+	dst->time_lost = src->time_lost;

+

+	//dst->output = src->output;

+

+	return dst;

+}

+

+

+

+static void dup_channel(IT_CHANNEL *dst, IT_CHANNEL *src)

+{

+	dst->flags = src->flags;

+

+	dst->volume = src->volume;

+	dst->volslide = src->volslide;

+	dst->xm_volslide = src->xm_volslide;

+	dst->panslide = src->panslide;

+

+	dst->pan = src->pan;

+	dst->truepan = src->truepan;

+

+	dst->channelvolume = src->channelvolume;

+	dst->channelvolslide = src->channelvolslide;

+

+	dst->instrument = src->instrument;

+	dst->note = src->note;

+

+	dst->SFmacro = src->SFmacro;

+

+	dst->filter_cutoff = src->filter_cutoff;

+	dst->filter_resonance = src->filter_resonance;

+

+	dst->key_off_count = src->key_off_count;

+	dst->note_cut_count = src->note_cut_count;

+	dst->note_delay_count = src->note_delay_count;

+	dst->note_delay_entry = src->note_delay_entry;

+

+	dst->new_note_action = src->new_note_action;

+

+	dst->arpeggio = src->arpeggio;

+	dst->retrig = src->retrig;

+	dst->xm_retrig = src->xm_retrig;

+	dst->retrig_tick = src->retrig_tick;

+

+	dst->tremor_time = src->tremor_time;

+

+	dst->vibrato_waveform = src->vibrato_waveform;

+	dst->tremolo_waveform = src->tremolo_waveform;

+	dst->panbrello_waveform = src->panbrello_waveform;

+

+	dst->portamento = src->portamento;

+	dst->toneporta = src->toneporta;

+	dst->toneslide = src->toneslide;

+	dst->toneslide_tick = src->toneslide_tick;

+	dst->last_toneslide_tick = src->last_toneslide_tick;

+	dst->ptm_toneslide = src->ptm_toneslide;

+	dst->ptm_last_toneslide = src->ptm_last_toneslide;

+	dst->destnote = src->destnote;

+

+	dst->glissando = src->glissando;

+

+	dst->sample = src->sample;

+	dst->truenote = src->truenote;

+

+	dst->midi_state = src->midi_state;

+

+	dst->lastvolslide = src->lastvolslide;

+	dst->lastDKL = src->lastDKL;

+	dst->lastEF = src->lastEF;

+	dst->lastG = src->lastG;

+	dst->lastHspeed = src->lastHspeed;

+	dst->lastHdepth = src->lastHdepth;

+	dst->lastRspeed = src->lastRspeed;

+	dst->lastRdepth = src->lastRdepth;

+	dst->lastYspeed = src->lastYspeed;

+	dst->lastYdepth = src->lastYdepth;

+	dst->lastI = src->lastI;

+	dst->lastJ = src->lastJ;

+	dst->lastN = src->lastN;

+	dst->lastO = src->lastO;

+	dst->high_offset = src->high_offset;

+	dst->lastP = src->lastP;

+	dst->lastQ = src->lastQ;

+	dst->lastS = src->lastS;

+	dst->pat_loop_row = src->pat_loop_row;

+	dst->pat_loop_count = src->pat_loop_count;

+	dst->pat_loop_end_row = src->pat_loop_end_row;

+	dst->lastW = src->lastW;

+

+	dst->xm_lastE1 = src->xm_lastE1;

+	dst->xm_lastE2 = src->xm_lastE2;

+	dst->xm_lastEA = src->xm_lastEA;

+	dst->xm_lastEB = src->xm_lastEB;

+	dst->xm_lastX1 = src->xm_lastX1;

+	dst->xm_lastX2 = src->xm_lastX2;

+

+	dst->playing = dup_playing(src->playing, dst, src);

+

+

+#ifdef BIT_ARRAY_BULLSHIT

+	dst->played_patjump = bit_array_dup(src->played_patjump);

+	dst->played_patjump_order = src->played_patjump_order;

+#endif

+

+	//dst->output = src->output;

+}

+

+

+

+/* Allocate the new callbacks first, then pass them to this function!

+ * It will free them on failure.

+ */

+static DUMB_IT_SIGRENDERER *dup_sigrenderer(DUMB_IT_SIGRENDERER *src, int n_channels, IT_CALLBACKS *callbacks)

+{

+	DUMB_IT_SIGRENDERER *dst;

+	int i;

+

+	if (!src) {

+		if (callbacks) free(callbacks);

+		return NULL;

+	}

+

+	dst = malloc(sizeof(*dst));

+	if (!dst) {

+		if (callbacks) free(callbacks);

+		return NULL;

+	}

+

+	dst->sigdata = src->sigdata;

+

+	dst->n_channels = n_channels;

+

+	dst->resampling_quality = src->resampling_quality;

+

+	dst->globalvolume = src->globalvolume;

+	dst->globalvolslide = src->globalvolslide;

+

+	dst->tempo = src->tempo;

+	dst->temposlide = src->temposlide;

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i++)

+		dup_channel(&dst->channel[i], &src->channel[i]);

+

+	for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++)

+		dst->playing[i] = dup_playing(src->playing[i], dst->channel, src->channel);

+

+	dst->tick = src->tick;

+	dst->speed = src->speed;

+	dst->rowcount = src->rowcount;

+

+	dst->order = src->order;

+	dst->row = src->row;

+	dst->processorder = src->processorder;

+	dst->processrow = src->processrow;

+	dst->breakrow = src->breakrow;

+

+	dst->restart_position = src->restart_position;

+

+	dst->n_rows = src->n_rows;

+

+	dst->entry_start = src->entry_start;

+	dst->entry = src->entry;

+	dst->entry_end = src->entry_end;

+

+	dst->time_left = src->time_left;

+	dst->sub_time_left = src->sub_time_left;

+

+	dst->click_remover = NULL;

+

+	dst->callbacks = callbacks;

+

+#ifdef BIT_ARRAY_BULLSHIT

+	dst->played = bit_array_dup(src->played);

+#endif

+

+	dst->gvz_time = src->gvz_time;

+	dst->gvz_sub_time = src->gvz_sub_time;

+

+	//dst->max_output = src->max_output;

+

+	return dst;

+}

+

+

+

+static const IT_MIDI default_midi = {

+	/* unsigned char SFmacro[16][16]; */

+	{

+		{0xF0, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}

+	},

+	/* unsigned char SFmacrolen[16]; */

+	{4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},

+	/* unsigned short SFmacroz[16]; */

+	/* Bitfield; bit 0 set = z in first position */

+	{

+		0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,

+		0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000

+	},

+	/* unsigned char Zmacro[128][16]; */

+	{

+		{0xF0, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0xF0, 0xF0, 0x01, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

+		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}

+	},

+	/* unsigned char Zmacrolen[128]; */

+	{

+		4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

+	}

+};

+

+

+

+static void it_reset_filter_state(IT_FILTER_STATE *state)

+{

+	state->currsample = 0;

+	state->prevsample = 0;

+}

+

+

+

+#if 1

+#define LOG10 2.30258509299

+

+/* IMPORTANT: This function expects one extra sample in 'src' so it can apply

+ * click removal. It reads size samples, starting from src[0], and writes its

+ * output starting at dst[pos]. The pos parameter is required for getting

+ * click removal right.

+ */

+

+static void it_filter(DUMB_CLICK_REMOVER *cr, IT_FILTER_STATE *state, sample_t *dst, long pos, sample_t *src, long size, int step, int sampfreq, int cutoff, int resonance)

+{

+	sample_t currsample = state->currsample;

+	sample_t prevsample = state->prevsample;

+

+	float a, b, c;

+

+	long datasize;

+

+	{

+		float inv_angle = (float)(sampfreq * pow(0.5, 0.25 + cutoff*(1.0/(24<<IT_ENVELOPE_SHIFT))) * (1.0/(2*3.14159265358979323846*110.0)));

+		float loss = (float)exp(resonance*(-LOG10*1.2/128.0));

+		float d, e;

+#if 0

+		loss *= 2; // This is the mistake most players seem to make!

+#endif

+

+#if 1

+		d = (1.0f - loss) / inv_angle;

+		if (d > 2.0f) d = 2.0f;

+		d = (loss - d) * inv_angle;

+		e = inv_angle * inv_angle;

+		a = 1.0f / (1.0f + d + e);

+		c = -e * a;

+		b = 1.0f - a - c;

+#else

+		a = 1.0f / (inv_angle*inv_angle + inv_angle*loss + loss);

+		c = -(inv_angle*inv_angle) * a;

+		b = 1.0f - a - c;

+#endif

+	}

+

+	dst += pos * step;

+	datasize = size * step;

+

+#define INT_FILTERS

+#ifdef INT_FILTERS

+#define MULSCA(a, b) ((int)((LONG_LONG)((a) << 4) * (b) >> 32))

+#define SCALEB 12

+	{

+		int ai = (int)(a * (1 << (16+SCALEB)));

+		int bi = (int)(b * (1 << (16+SCALEB)));

+		int ci = (int)(c * (1 << (16+SCALEB)));

+		int i;

+

+		if (cr) {

+			sample_t startstep = MULSCA(src[0], ai) + MULSCA(currsample, bi) + MULSCA(prevsample, ci);

+			dumb_record_click(cr, pos, startstep);

+		}

+

+		for (i = 0; i < datasize; i += step) {

+			{

+				sample_t newsample = MULSCA(src[i], ai) + MULSCA(currsample, bi) + MULSCA(prevsample, ci);

+				prevsample = currsample;

+				currsample = newsample;

+			}

+			dst[i] += currsample;

+		}

+

+		if (cr) {

+			sample_t endstep = MULSCA(src[datasize], ai) + MULSCA(currsample, bi) + MULSCA(prevsample, ci);

+			dumb_record_click(cr, pos + size, -endstep);

+		}

+	}

+#else

+#error This version is broken - it does not use step, and state should contain floats for it

+	if (cr) {

+		float startstep = src[0]*a + currsample*b + prevsample*c;

+		dumb_record_click(cr, pos, (sample_t)startstep);

+	}

+

+	{

+		int i = size % 3;

+		while (i > 0) {

+			{

+				float newsample = *src++*a + currsample*b + prevsample*c;

+				prevsample = currsample;

+				currsample = newsample;

+			}

+			*dst++ += (sample_t)currsample;

+			i--;

+		}

+		i = size / 3;

+		while (i > 0) {

+			float newsample;

+			/* Gotta love unrolled loops! */

+			*dst++ += (sample_t)(newsample = *src++*a + currsample*b + prevsample*c);

+			*dst++ += (sample_t)(prevsample = *src++*a + newsample*b + currsample*c);

+			*dst++ += (sample_t)(currsample = *src++*a + prevsample*b + newsample*c);

+			i--;

+		}

+	}

+

+	if (cr) {

+		float endstep = src[datasize]*a + currsample*b + prevsample*c;

+		dumb_record_click(cr, pos + size, -(sample_t)endstep);

+	}

+#endif

+

+	state->currsample = currsample;

+	state->prevsample = prevsample;

+}

+#undef LOG10

+#endif

+

+

+

+static const signed char it_sine[256] = {

+	  0,  2,  3,  5,  6,  8,  9, 11, 12, 14, 16, 17, 19, 20, 22, 23,

+	 24, 26, 27, 29, 30, 32, 33, 34, 36, 37, 38, 39, 41, 42, 43, 44,

+	 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59,

+	 59, 60, 60, 61, 61, 62, 62, 62, 63, 63, 63, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 63, 63, 63, 62, 62, 62, 61, 61, 60, 60,

+	 59, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46,

+	 45, 44, 43, 42, 41, 39, 38, 37, 36, 34, 33, 32, 30, 29, 27, 26,

+	 24, 23, 22, 20, 19, 17, 16, 14, 12, 11,  9,  8,  6,  5,  3,  2,

+	  0, -2, -3, -5, -6, -8, -9,-11,-12,-14,-16,-17,-19,-20,-22,-23,

+	-24,-26,-27,-29,-30,-32,-33,-34,-36,-37,-38,-39,-41,-42,-43,-44,

+	-45,-46,-47,-48,-49,-50,-51,-52,-53,-54,-55,-56,-56,-57,-58,-59,

+	-59,-60,-60,-61,-61,-62,-62,-62,-63,-63,-63,-64,-64,-64,-64,-64,

+	-64,-64,-64,-64,-64,-64,-63,-63,-63,-62,-62,-62,-61,-61,-60,-60,

+	-59,-59,-58,-57,-56,-56,-55,-54,-53,-52,-51,-50,-49,-48,-47,-46,

+	-45,-44,-43,-42,-41,-39,-38,-37,-36,-34,-33,-32,-30,-29,-27,-26,

+	-24,-23,-22,-20,-19,-17,-16,-14,-12,-11, -9, -8, -6, -5, -3, -2

+};

+

+

+

+#if 1

+/** WARNING: use these! */

+/** JULIEN: Plus for XM compatibility it could be interesting to rename

+ * it_sawtooth[] to it_rampdown[], and add an it_rampup[].

+ * Also, still for XM compat', twood be good if it was possible to tell the

+ * the player not to retrig' the waveform on a new instrument.

+ * Both of these are only for completness though, as I don't think it would

+ * be very noticeable ;)

+ */

+/** ENTHEH: IT also has the 'don't retrig' thingy :) */

+static const signed char it_sawtooth[256] = {

+	 64, 63, 63, 62, 62, 61, 61, 60, 60, 59, 59, 58, 58, 57, 57, 56,

+	 56, 55, 55, 54, 54, 53, 53, 52, 52, 51, 51, 50, 50, 49, 49, 48,

+	 48, 47, 47, 46, 46, 45, 45, 44, 44, 43, 43, 42, 42, 41, 41, 40,

+	 40, 39, 39, 38, 38, 37, 37, 36, 36, 35, 35, 34, 34, 33, 33, 32,

+	 32, 31, 31, 30, 30, 29, 29, 28, 28, 27, 27, 26, 26, 25, 25, 24,

+	 24, 23, 23, 22, 22, 21, 21, 20, 20, 19, 19, 18, 18, 17, 17, 16,

+	 16, 15, 15, 14, 14, 13, 13, 12, 12, 11, 11, 10, 10,  9,  9,  8,

+	  8,  7,  7,  6,  6,  5,  5,  4,  4,  3,  3,  2,  2,  1,  1,  0,

+	  0, -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -6, -6, -7, -7, -8,

+	 -8, -9, -9,-10,-10,-11,-11,-12,-12,-13,-13,-14,-14,-15,-15,-16,

+	-16,-17,-17,-18,-18,-19,-19,-20,-20,-21,-21,-22,-22,-23,-23,-24,

+	-24,-25,-25,-26,-26,-27,-27,-28,-28,-29,-29,-30,-30,-31,-31,-32,

+	-32,-33,-33,-34,-34,-35,-35,-36,-36,-37,-37,-38,-38,-39,-39,-40,

+	-40,-41,-41,-42,-42,-43,-43,-44,-44,-45,-45,-46,-46,-47,-47,-48,

+	-48,-49,-49,-50,-50,-51,-51,-52,-52,-53,-53,-54,-54,-55,-55,-56,

+	-56,-57,-57,-58,-58,-59,-59,-60,-60,-61,-61,-62,-62,-63,-63,-64

+};

+

+static const signed char it_squarewave[256] = {

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

+	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

+	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

+	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

+	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

+	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

+	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,

+	  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0

+};

+

+static const signed char it_xm_ramp[256] = {

+	  0, -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -6, -6, -7, -7, -8,

+	 -8, -9, -9,-10,-10,-11,-11,-12,-12,-13,-13,-14,-14,-15,-15,-16,

+	-16,-17,-17,-18,-18,-19,-19,-20,-20,-21,-21,-22,-22,-23,-23,-24,

+	-24,-25,-25,-26,-26,-27,-27,-28,-28,-29,-29,-30,-30,-31,-31,-32,

+	-32,-33,-33,-34,-34,-35,-35,-36,-36,-37,-37,-38,-38,-39,-39,-40,

+	-40,-41,-41,-42,-42,-43,-43,-44,-44,-45,-45,-46,-46,-47,-47,-48,

+	-48,-49,-49,-50,-50,-51,-51,-52,-52,-53,-53,-54,-54,-55,-55,-56,

+	-56,-57,-57,-58,-58,-59,-59,-60,-60,-61,-61,-62,-62,-63,-63,-64,

+	 64, 63, 63, 62, 62, 61, 61, 60, 60, 59, 59, 58, 58, 57, 57, 56,

+	 56, 55, 55, 54, 54, 53, 53, 52, 52, 51, 51, 50, 50, 49, 49, 48,

+	 48, 47, 47, 46, 46, 45, 45, 44, 44, 43, 43, 42, 42, 41, 41, 40,

+	 40, 39, 39, 38, 38, 37, 37, 36, 36, 35, 35, 34, 34, 33, 33, 32,

+	 32, 31, 31, 30, 30, 29, 29, 28, 28, 27, 27, 26, 26, 25, 25, 24,

+	 24, 23, 23, 22, 22, 21, 21, 20, 20, 19, 19, 18, 18, 17, 17, 16,

+	 16, 15, 15, 14, 14, 13, 13, 12, 12, 11, 11, 10, 10,  9,  9,  8,

+	  8,  7,  7,  6,  6,  5,  5,  4,  4,  3,  3,  2,  2,  1,  1,  0

+};

+

+static const signed char it_xm_squarewave[256] = {

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

+	-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,

+	-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,

+	-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,

+	-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,

+	-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,

+	-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,

+	-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,

+	-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64

+};

+

+#endif

+

+

+

+static void reset_tick_counts(DUMB_IT_SIGRENDERER *sigrenderer)

+{

+	int i;

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+		IT_CHANNEL *channel = &sigrenderer->channel[i];

+		channel->key_off_count = 0;

+		channel->note_cut_count = 0;

+		channel->note_delay_count = 0;

+	}

+}

+

+

+

+static void reset_channel_effects(IT_CHANNEL *channel)

+{

+	channel->volslide = 0;

+	channel->xm_volslide = 0;

+	channel->panslide = 0;

+	channel->channelvolslide = 0;

+	channel->arpeggio = 0;

+	channel->retrig = 0;

+	if (channel->xm_retrig) {

+		channel->xm_retrig = 0;

+		channel->retrig_tick = 0;

+	}

+	channel->tremor_time &= 127;

+	channel->portamento = 0;

+	channel->toneporta = 0;

+	if (channel->ptm_toneslide) {

+		channel->ptm_last_toneslide = channel->ptm_toneslide;

+		channel->last_toneslide_tick = channel->toneslide_tick;

+	} else

+		channel->ptm_last_toneslide = 0;

+	channel->ptm_toneslide = 0;

+	channel->toneslide_tick = 0;

+	if (channel->playing) {

+		channel->playing->vibrato_n = 0;

+		channel->playing->tremolo_speed = 0;

+		channel->playing->tremolo_depth = 0;

+		channel->playing->panbrello_speed = 0;

+	}

+}

+

+static void reset_effects(DUMB_IT_SIGRENDERER *sigrenderer)

+{

+	int i;

+

+	sigrenderer->globalvolslide = 0;

+	sigrenderer->temposlide = 0;

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+		reset_channel_effects(&sigrenderer->channel[i]);

+	}

+}

+

+

+

+static void update_tremor(IT_CHANNEL *channel)

+{

+	if ((channel->tremor_time & 128) && channel->playing) {

+		if (channel->tremor_time == 128)

+			channel->tremor_time = (channel->lastI >> 4) | 192;

+		else if (channel->tremor_time == 192)

+			channel->tremor_time = (channel->lastI & 15) | 128;

+		else

+			channel->tremor_time--;

+	}

+}

+

+

+

+static void it_pickup_loop(DUMB_RESAMPLER *resampler, void *data)

+{

+	resampler->pos -= resampler->end - resampler->start;

+	((IT_PLAYING *)data)->time_lost += resampler->end - resampler->start;

+}

+

+

+

+static void it_pickup_pingpong_loop(DUMB_RESAMPLER *resampler, void *data)

+{

+	if (resampler->dir < 0) {

+		resampler->pos = (resampler->start << 1) - 1 - resampler->pos;

+		resampler->subpos ^= 65535;

+		resampler->dir = 1;

+		((IT_PLAYING *)data)->time_lost += (resampler->end - resampler->start) << 1;

+	} else {

+		resampler->pos = (resampler->end << 1) - 1 - resampler->pos;

+		resampler->subpos ^= 65535;

+		resampler->dir = -1;

+	}

+}

+

+

+

+static void it_pickup_stop_at_end(DUMB_RESAMPLER *resampler, void *data)

+{

+	(void)data;

+

+	if (resampler->dir < 0) {

+		resampler->pos = (resampler->start << 1) - 1 - resampler->pos;

+		resampler->subpos ^= 65535;

+		/* By rights, time_lost would be updated here. However, there is no

+		 * need at this point; it will not be used.

+		 *

+		 * ((IT_PLAYING *)data)->time_lost += (resampler->src_end - resampler->src_start) << 1;

+		 */

+		resampler->dir = 1;

+	} else

+		resampler->dir = 0;

+}

+

+

+

+static void it_playing_update_resamplers(IT_PLAYING *playing)

+{

+	if ((playing->sample->flags & IT_SAMPLE_SUS_LOOP) && !(playing->flags & IT_PLAYING_SUSTAINOFF)) {

+		playing->resampler.start = playing->sample->sus_loop_start;

+		playing->resampler.end = playing->sample->sus_loop_end;

+		if (playing->resampler.start == playing->resampler.end)

+			playing->resampler.pickup = &it_pickup_stop_at_end;

+		else if (playing->sample->flags & IT_SAMPLE_PINGPONG_SUS_LOOP)

+			playing->resampler.pickup = &it_pickup_pingpong_loop;

+		else

+			playing->resampler.pickup = &it_pickup_loop;

+	} else if (playing->sample->flags & IT_SAMPLE_LOOP) {

+		playing->resampler.start = playing->sample->loop_start;

+		playing->resampler.end = playing->sample->loop_end;

+		if (playing->resampler.start == playing->resampler.end)

+			playing->resampler.pickup = &it_pickup_stop_at_end;

+		else if (playing->sample->flags & IT_SAMPLE_PINGPONG_LOOP)

+			playing->resampler.pickup = &it_pickup_pingpong_loop;

+		else

+			playing->resampler.pickup = &it_pickup_loop;

+	} else {

+		if (playing->sample->flags & IT_SAMPLE_SUS_LOOP)

+			playing->resampler.start = playing->sample->sus_loop_start;

+		else

+			playing->resampler.start = 0;

+		playing->resampler.end = playing->sample->length;

+		playing->resampler.pickup = &it_pickup_stop_at_end;

+	}

+	ASSERT(playing->resampler.pickup_data == playing);

+}

+

+

+

+/* This should be called whenever the sample or sample position changes. */

+static void it_playing_reset_resamplers(IT_PLAYING *playing, long pos)

+{

+	int bits = playing->sample->flags & IT_SAMPLE_16BIT ? 16 : 8;

+	int quality = playing->resampling_quality;

+	int channels = playing->sample->flags & IT_SAMPLE_STEREO ? 2 : 1;

+	if (playing->sample->max_resampling_quality >= 0 && quality > playing->sample->max_resampling_quality)

+		quality = playing->sample->max_resampling_quality;

+	dumb_reset_resampler_n(bits, &playing->resampler, playing->sample->data, channels, pos, 0, 0, quality);

+	playing->resampler.pickup_data = playing;

+	playing->time_lost = 0;

+	playing->flags &= ~IT_PLAYING_DEAD;

+	it_playing_update_resamplers(playing);

+}

+

+static void it_retrigger_note(DUMB_IT_SIGRENDERER *sigrenderer, IT_CHANNEL *channel);

+

+/* Should we only be retriggering short samples on XM? */

+

+static void update_retrig(DUMB_IT_SIGRENDERER *sigrenderer, IT_CHANNEL *channel)

+{

+	if (channel->xm_retrig) {

+		channel->retrig_tick--;

+		if (channel->retrig_tick <= 0) {

+			if (channel->playing) {

+				it_playing_reset_resamplers(channel->playing, 0);

+#ifdef END_RAMPING

+				channel->playing->declick_stage = 0;

+				channel->playing->declick_volume = 1.f / 256.f;

+#endif

+			} else if (sigrenderer->sigdata->flags & IT_WAS_AN_XM) it_retrigger_note(sigrenderer, channel);

+			channel->retrig_tick = channel->xm_retrig;

+		}

+	} else if (channel->retrig & 0x0F) {

+		channel->retrig_tick--;

+		if (channel->retrig_tick <= 0) {

+			if (channel->retrig < 0x10) {

+			} else if (channel->retrig < 0x20) {

+				channel->volume--;

+				if (channel->volume > 64) channel->volume = 0;

+			} else if (channel->retrig < 0x30) {

+				channel->volume -= 2;

+				if (channel->volume > 64) channel->volume = 0;

+			} else if (channel->retrig < 0x40) {

+				channel->volume -= 4;

+				if (channel->volume > 64) channel->volume = 0;

+			} else if (channel->retrig < 0x50) {

+				channel->volume -= 8;

+				if (channel->volume > 64) channel->volume = 0;

+			} else if (channel->retrig < 0x60) {

+				channel->volume -= 16;

+				if (channel->volume > 64) channel->volume = 0;

+			} else if (channel->retrig < 0x70) {

+				channel->volume <<= 1;

+				channel->volume /= 3;

+			} else if (channel->retrig < 0x80) {

+				channel->volume >>= 1;

+			} else if (channel->retrig < 0x90) {

+			} else if (channel->retrig < 0xA0) {

+				channel->volume++;

+				if (channel->volume > 64) channel->volume = 64;

+			} else if (channel->retrig < 0xB0) {

+				channel->volume += 2;

+				if (channel->volume > 64) channel->volume = 64;

+			} else if (channel->retrig < 0xC0) {

+				channel->volume += 4;

+				if (channel->volume > 64) channel->volume = 64;

+			} else if (channel->retrig < 0xD0) {

+				channel->volume += 8;

+				if (channel->volume > 64) channel->volume = 64;

+			} else if (channel->retrig < 0xE0) {

+				channel->volume += 16;

+				if (channel->volume > 64) channel->volume = 64;

+			} else if (channel->retrig < 0xF0) {

+				channel->volume *= 3;

+				channel->volume >>= 1;

+				if (channel->volume > 64) channel->volume = 64;

+			} else {

+				channel->volume <<= 1;

+				if (channel->volume > 64) channel->volume = 64;

+			}

+			if (channel->playing) {

+				it_playing_reset_resamplers(channel->playing, 0);

+#ifdef END_RAMPING

+				channel->playing->declick_stage = 0;

+				channel->playing->declick_volume = 1.f / 256.f;

+#endif

+			} else if (sigrenderer->sigdata->flags & IT_WAS_AN_XM) it_retrigger_note(sigrenderer, channel);

+			channel->retrig_tick = channel->retrig & 0x0F;

+		}

+	}

+}

+

+

+

+static void update_smooth_effects(DUMB_IT_SIGRENDERER *sigrenderer)

+{

+	int i;

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+		IT_CHANNEL *channel = &sigrenderer->channel[i];

+		IT_PLAYING *playing = channel->playing;

+

+		if (playing) {

+			playing->vibrato_time += playing->vibrato_n *

+			                         (playing->vibrato_speed << 2);

+			playing->tremolo_time += playing->tremolo_speed << 2;

+			playing->panbrello_time += playing->panbrello_speed;

+			if (playing->panbrello_waveform == 3)

+				playing->panbrello_random = (rand() % 129) - 64;

+		}

+	}

+}

+

+

+

+static void update_effects(DUMB_IT_SIGRENDERER *sigrenderer)

+{

+	int i;

+

+	if (sigrenderer->globalvolslide) {

+		sigrenderer->globalvolume += sigrenderer->globalvolslide;

+		if (sigrenderer->globalvolume > 128) {

+			if (sigrenderer->globalvolslide >= 0)

+				sigrenderer->globalvolume = 128;

+			else

+				sigrenderer->globalvolume = 0;

+		}

+	}

+

+	if (sigrenderer->temposlide) {

+		sigrenderer->tempo += sigrenderer->temposlide;

+		if (sigrenderer->tempo < 32) {

+			if (sigrenderer->temposlide >= 0)

+				sigrenderer->tempo = 255;

+			else

+				sigrenderer->tempo = 32;

+		}

+	}

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+		IT_CHANNEL *channel = &sigrenderer->channel[i];

+		IT_PLAYING *playing = channel->playing;

+

+		if (channel->xm_volslide) {

+			channel->volume += channel->xm_volslide;

+			if (channel->volume > 64) {

+				if (channel->xm_volslide >= 0)

+					channel->volume = 64;

+				else

+					channel->volume = 0;

+			}

+		}

+

+		if (channel->volslide) {

+			channel->volume += channel->volslide;

+			if (channel->volume > 64) {

+				if (channel->volslide >= 0)

+					channel->volume = 64;

+				else

+					channel->volume = 0;

+			}

+		}

+

+		if (channel->panslide) {

+			if (sigrenderer->sigdata->flags & IT_WAS_AN_XM) {

+				if (IT_IS_SURROUND(channel->pan))

+				{

+					channel->pan = 32;

+					channel->truepan = 32 + 128 * 64;

+				}

+				if (channel->panslide == -128)

+					channel->truepan = 32;

+				else

+					channel->truepan = MID(32, channel->truepan + channel->panslide*64, 32+255*64);

+			} else {

+				if (IT_IS_SURROUND(channel->pan))

+				{

+					channel->pan = 32;

+				}

+				channel->pan += channel->panslide;

+				if (channel->pan > 64) {

+					if (channel->panslide >= 0)

+						channel->pan = 64;

+					else

+						channel->pan = 0;

+				}

+				channel->truepan = channel->pan << IT_ENVELOPE_SHIFT;

+			}

+		}

+

+		if (channel->channelvolslide) {

+			channel->channelvolume += channel->channelvolslide;

+			if (channel->channelvolume > 64) {

+				if (channel->channelvolslide >= 0)

+					channel->channelvolume = 64;

+				else

+					channel->channelvolume = 0;

+			}

+			if (channel->playing)

+				channel->playing->channel_volume = channel->channelvolume;

+		}

+

+		update_tremor(channel);

+

+		channel->arpeggio = (channel->arpeggio << 4) | (channel->arpeggio >> 8);

+		channel->arpeggio &= 0xFFF;

+

+		update_retrig(sigrenderer, channel);

+

+		if (playing) {

+			playing->slide += channel->portamento;

+

+			if (channel->ptm_toneslide) {

+				if (--channel->toneslide_tick == 0) {

+					channel->toneslide_tick = channel->ptm_toneslide;

+					playing->note += channel->toneslide;

+					if (playing->note >= 120) {

+						if (channel->toneslide < 0) playing->note = 0;

+						else playing->note = 119;

+					}

+					channel->note = channel->truenote = playing->note;

+					if (channel->toneslide_retrig) {

+						it_playing_reset_resamplers(playing, 0);

+#ifdef END_RAMPING

+						playing->declick_stage = 0;

+						playing->declick_volume = 1.f / 256.f;

+#endif

+					}

+				}

+			}

+

+			if (sigrenderer->sigdata->flags & IT_LINEAR_SLIDES) {

+				if (channel->toneporta && channel->destnote < 120) {

+					int currpitch = ((playing->note - 60) << 8) + playing->slide;

+					int destpitch = (channel->destnote - 60) << 8;

+					if (currpitch > destpitch) {

+						currpitch -= channel->toneporta;

+						if (currpitch < destpitch) {

+							currpitch = destpitch;

+							channel->destnote = IT_NOTE_OFF;

+						}

+					} else if (currpitch < destpitch) {

+						currpitch += channel->toneporta;

+						if (currpitch > destpitch) {

+							currpitch = destpitch;

+							channel->destnote = IT_NOTE_OFF;

+						}

+					}

+					playing->slide = currpitch - ((playing->note - 60) << 8);

+				}

+			} else {

+				if (channel->toneporta && channel->destnote < 120) {

+					float amiga_multiplier = playing->sample->C5_speed * (1.0f / AMIGA_DIVISOR);

+

+					float deltanote = (float)pow(DUMB_SEMITONE_BASE, 60 - playing->note);

+					/* deltanote is 1.0 for C-5, 0.5 for C-6, etc. */

+

+					float deltaslid = deltanote - playing->slide * amiga_multiplier;

+

+					float destdelta = (float)pow(DUMB_SEMITONE_BASE, 60 - channel->destnote);

+					if (deltaslid < destdelta) {

+						playing->slide -= channel->toneporta;

+						deltaslid = deltanote - playing->slide * amiga_multiplier;

+						if (deltaslid > destdelta) {

+							playing->note = channel->destnote;

+							playing->slide = 0;

+							channel->destnote = IT_NOTE_OFF;

+						}

+					} else {

+						playing->slide += channel->toneporta;

+						deltaslid = deltanote - playing->slide * amiga_multiplier;

+						if (deltaslid < destdelta) {

+							playing->note = channel->destnote;

+							playing->slide = 0;

+							channel->destnote = IT_NOTE_OFF;

+						}

+					}

+				}

+			}

+		}

+	}

+

+	update_smooth_effects(sigrenderer);

+}

+

+

+static void it_note_off(IT_PLAYING *playing);

+

+// This function should be renamed; it doesn't do the 'Update Pattern Variables' operation ittech.txt describes

+/* Returns 1 if a pattern loop is happening. */

+static int update_pattern_variables(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry)

+{

+	IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel];

+

+	if (entry->mask & IT_ENTRY_EFFECT) {

+		switch (entry->effect) {

+			case IT_JUMP_TO_ORDER:

+				/* XXX jump and break in same row */

+				if ( ( ( sigrenderer->processrow | 0xC00 ) == 0xFFFE ) &&

+					! ( sigrenderer->processrow & 0x800 ) ) {

+					sigrenderer->processrow = 0xFFFE & ~0xC00;

+				} else {

+					sigrenderer->breakrow = 0;

+					sigrenderer->processrow = 0xFFFE & ~0x400;

+				}

+				sigrenderer->processorder = entry->effectvalue - 1;

+				break;

+

+			case IT_S:

+				{

+					unsigned char effectvalue = entry->effectvalue;

+					if (effectvalue == 0)

+						effectvalue = channel->lastS;

+					channel->lastS = effectvalue;

+					switch (effectvalue >> 4) {

+						case IT_S_PATTERN_LOOP:

+							{

+								unsigned char v = effectvalue & 15;

+								if (v == 0) {

+#ifdef BIT_ARRAY_BULLSHIT

+									if (!channel->played_patjump)

+										channel->played_patjump = bit_array_create(256);

+									else {

+										//if (channel->played_patjump_order != sigrenderer->order)

+											bit_array_reset(channel->played_patjump);

+									}

+									channel->played_patjump_order = sigrenderer->order;

+#endif

+									channel->pat_loop_row = sigrenderer->processrow;

+								} else {

+									if (channel->pat_loop_count == 0) {

+#ifdef BIT_ARRAY_BULLSHIT

+										/* wft, uninitialized and no start marker yet... */

+										if (channel->played_patjump_order == 0xFFFE) {

+											int n;

+											bit_array_destroy(channel->played_patjump);

+											channel->played_patjump = bit_array_create(256);

+											for (n = 0; n < 256; n++)

+												bit_array_clear(sigrenderer->played, sigrenderer->order * 256 + n);

+											channel->played_patjump_order = sigrenderer->order;

+										} else if (channel->played_patjump_order == sigrenderer->order) {

+											bit_array_set(channel->played_patjump, sigrenderer->row);

+											bit_array_mask(sigrenderer->played, channel->played_patjump, channel->played_patjump_order * 256);

+											bit_array_reset(channel->played_patjump);

+										}

+#endif

+										channel->pat_loop_count = v;

+										sigrenderer->breakrow = channel->pat_loop_row;

+										if ((sigrenderer->sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD)) == IT_WAS_AN_XM) {

+											/* For XM files, if a loop occurs by itself, keep breakrow set for when the pattern ends - fun bug in FT2! */

+											if ((sigrenderer->processrow|0xC00) < 0xFFFE) {

+												/* Infinite pattern loops are possible, so we check whether the pattern loop we're hitting now is earlier than the last one we hit. */

+												if (sigrenderer->processrow < channel->pat_loop_end_row)

+													sigrenderer->processorder = 0xFFFE; /* suspect infinite loop, so trigger loop callback */

+												else

+													sigrenderer->processorder = 0xFFFF; /* don't trigger loop callback */

+												channel->pat_loop_end_row = sigrenderer->processrow;

+												sigrenderer->processrow = 0xFFFF; /* special case: don't reset breakrow or pat_loop_end_row */

+											}

+										} else {

+											/* IT files do this regardless of other flow control effects seen here. */

+											sigrenderer->processorder = 0xFFFF; /* special case: don't trigger loop callback */

+											sigrenderer->processrow = 0xFFFE;

+										}

+										return 1;

+									} else if (--channel->pat_loop_count) {

+#ifdef BIT_ARRAY_BULLSHIT

+										if (channel->played_patjump_order == sigrenderer->order) {

+											bit_array_set(channel->played_patjump, sigrenderer->row);

+											bit_array_mask(sigrenderer->played, channel->played_patjump, channel->played_patjump_order * 256);

+											bit_array_reset(channel->played_patjump);

+										}

+#endif

+										sigrenderer->breakrow = channel->pat_loop_row;

+										if ((sigrenderer->sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD)) == IT_WAS_AN_XM) {

+											/* For XM files, if a loop occurs by itself, keep breakrow set for when the pattern ends - fun bug in FT2! */

+											if ((sigrenderer->processrow|0xC00) < 0xFFFE) {

+												/* Infinite pattern loops are possible, so we check whether the pattern loop we're hitting now is earlier than the last one we hit. */

+												if (sigrenderer->processrow < channel->pat_loop_end_row)

+													sigrenderer->processorder = 0xFFFE; /* suspect infinite loop, so trigger loop callback */

+												else

+													sigrenderer->processorder = 0xFFFF; /* don't trigger loop callback */

+												channel->pat_loop_end_row = sigrenderer->processrow;

+												sigrenderer->processrow = 0xFFFF; /* special case: don't reset breakrow or pat_loop_end_row */

+											}

+										} else {

+											/* IT files do this regardless of other flow control effects seen here. */

+											sigrenderer->processorder = 0xFFFF; /* special case: don't trigger loop callback */

+											sigrenderer->processrow = 0xFFFE;

+										}

+										return 1;

+									} else if ((sigrenderer->sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD)) == IT_WAS_AN_XM) {

+										channel->pat_loop_end_row = 0;

+										// TODO

+										/* Findings:

+										- If a pattern loop completes successfully, and then the pattern terminates, then the next pattern will start on the row corresponding to the E60.

+										- If a pattern loop doesn't do any loops, and then the pattern terminates, then the next pattern will start on the first row.

+										- If a break appears to the left of the pattern loop, it jumps into the relevant position in the next pattern, and that's it.

+										- If a break appears to the right of the pattern loop, it jumps to the start of the next pattern, and that's it.

+										- If we jump, then effect a loop using an old E60, and then the pattern ends, the next pattern starts on the row corresponding to the E60.

+										- Theory: breakrow is not cleared when it's a pattern loop effect!

+										*/

+										//if (sigrenderer->processrow < 0xFFFE) // I have no idea if this is correct or not - FT2 is so weird :(

+										//	sigrenderer->breakrow = channel->pat_loop_row; /* emulate bug in FT2 */

+									} else

+										channel->pat_loop_row = sigrenderer->processrow + 1;

+#ifdef BIT_ARRAY_BULLSHIT

+									/*channel->played_patjump_order |= 0x8000;*/

+									if (channel->played_patjump_order == sigrenderer->order) {

+										bit_array_destroy(channel->played_patjump);

+										channel->played_patjump = 0;

+										channel->played_patjump_order = 0xFFFE;

+									}

+									bit_array_clear(sigrenderer->played, sigrenderer->order * 256 + sigrenderer->row);

+#endif

+								}

+							}

+							break;

+						case IT_S_PATTERN_DELAY:

+							sigrenderer->rowcount = 1 + (effectvalue & 15);

+							break;

+					}

+				}

+		}

+	}

+

+	return 0;

+}

+

+

+

+/* This function guarantees that channel->sample will always be valid if it

+ * is nonzero. In other words, to check if it is valid, simply check if it is

+ * nonzero.

+ */

+static void instrument_to_sample(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel)

+{

+	if (sigdata->flags & IT_USE_INSTRUMENTS) {

+		if (channel->instrument >= 1 && channel->instrument <= sigdata->n_instruments) {

+			if (channel->note < 120) {

+				channel->sample = sigdata->instrument[channel->instrument-1].map_sample[channel->note];

+				channel->truenote = sigdata->instrument[channel->instrument-1].map_note[channel->note];

+			} else

+				channel->sample = 0;

+		} else

+			channel->sample = 0;

+	} else {

+		channel->sample = channel->instrument;

+		channel->truenote = channel->note;

+	}

+	if (!(channel->sample >= 1 && channel->sample <= sigdata->n_samples && (sigdata->sample[channel->sample-1].flags & IT_SAMPLE_EXISTS) && sigdata->sample[channel->sample-1].C5_speed))

+		channel->sample = 0;

+}

+

+

+

+static void fix_sample_looping(IT_PLAYING *playing)

+{

+	if ((playing->sample->flags & (IT_SAMPLE_LOOP | IT_SAMPLE_SUS_LOOP)) ==

+	                              (IT_SAMPLE_LOOP | IT_SAMPLE_SUS_LOOP)) {

+		if (playing->resampler.dir < 0) {

+			playing->resampler.pos = (playing->sample->sus_loop_end << 1) - 1 - playing->resampler.pos;

+			playing->resampler.subpos ^= 65535;

+			playing->resampler.dir = 1;

+		}

+

+		playing->resampler.pos += playing->time_lost;

+		// XXX what

+		playing->time_lost = 0;

+	}

+}

+

+

+

+static void it_compatible_gxx_retrigger(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel)

+{

+	int flags = 0;

+	if (channel->sample) {

+		if (sigdata->flags & IT_USE_INSTRUMENTS) {

+			if (channel->playing->env_instrument == &sigdata->instrument[channel->instrument-1]) {

+				if (channel->playing->env_instrument->volume_envelope.flags & IT_ENVELOPE_CARRY)

+					flags |= 1;

+				if (channel->playing->env_instrument->pan_envelope.flags & IT_ENVELOPE_CARRY)

+					flags |= 2;

+				if (channel->playing->env_instrument->pitch_envelope.flags & IT_ENVELOPE_CARRY)

+					flags |= 4;

+			}

+		}

+	}

+	if (!(flags & 1)) {

+		channel->playing->volume_envelope.next_node = 0;

+		channel->playing->volume_envelope.tick = 0;

+	}

+	if (!(flags & 2)) {

+		channel->playing->pan_envelope.next_node = 0;

+		channel->playing->pan_envelope.tick = 0;

+	}

+	if (!(flags & 4)) {

+		channel->playing->pitch_envelope.next_node = 0;

+		channel->playing->pitch_envelope.tick = 0;

+	}

+	channel->playing->fadeoutcount = 1024;

+	// Should we remove IT_PLAYING_BACKGROUND? Test with sample with sustain loop...

+	channel->playing->flags &= ~(IT_PLAYING_BACKGROUND | IT_PLAYING_SUSTAINOFF | IT_PLAYING_FADING | IT_PLAYING_DEAD);

+	it_playing_update_resamplers(channel->playing);

+

+	if (!flags && channel->sample)

+		if (sigdata->flags & IT_USE_INSTRUMENTS)

+			channel->playing->env_instrument = &sigdata->instrument[channel->instrument-1];

+}

+

+

+

+static void it_note_off(IT_PLAYING *playing)

+{

+	if (playing) {

+		playing->enabled_envelopes |= IT_ENV_VOLUME;

+		playing->flags |= IT_PLAYING_BACKGROUND | IT_PLAYING_SUSTAINOFF;

+		fix_sample_looping(playing);

+		it_playing_update_resamplers(playing);

+		if (playing->instrument)

+			if ((playing->instrument->volume_envelope.flags & (IT_ENVELOPE_ON | IT_ENVELOPE_LOOP_ON)) != IT_ENVELOPE_ON)

+				playing->flags |= IT_PLAYING_FADING;

+	}

+}

+

+

+

+static void xm_note_off(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel)

+{

+	if (channel->playing) {

+		if (channel->instrument > sigdata->n_instruments ||

+			!(sigdata->instrument[channel->instrument-1].volume_envelope.flags & IT_ENVELOPE_ON))

+			//if (!(entry->mask & IT_ENTRY_INSTRUMENT))

+			// dunno what that was there for ...

+				channel->volume = 0;

+		channel->playing->flags |= IT_PLAYING_SUSTAINOFF | IT_PLAYING_FADING;

+		it_playing_update_resamplers(channel->playing);

+	}

+}

+

+

+

+static void it_retrigger_note(DUMB_IT_SIGRENDERER *sigrenderer, IT_CHANNEL *channel)

+{

+	IT_PLAYING_ENVELOPE volume_envelope;

+	IT_PLAYING_ENVELOPE pan_envelope;

+	IT_PLAYING_ENVELOPE pitch_envelope;

+

+	DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata;

+	unsigned char nna;

+	int i, flags = 0;

+

+	if (channel->playing) {

+#ifdef INVALID_NOTES_CAUSE_NOTE_CUT

+		if (channel->note == IT_NOTE_OFF)

+			nna = NNA_NOTE_OFF;

+		else if (channel->note >= 120 || !channel->playing->instrument || (channel->playing->flags & IT_PLAYING_DEAD))

+			nna = NNA_NOTE_CUT;

+		else if (channel->new_note_action != 0xFF)

+		{

+			nna = channel->new_note_action;

+		}

+		else

+			nna = channel->playing->instrument->new_note_action;

+#else

+		if (channel->note == IT_NOTE_CUT)

+			nna = NNA_NOTE_CUT;

+		if (channel->note >= 120)

+			nna = NNA_NOTE_OFF;

+		else if (!channel->playing->instrument || (channel->playing->flags & IT_PLAYING_DEAD))

+			nna = NNA_NOTE_CUT;

+		else if (channel->new_note_action != 0xFF)

+		{

+			nna = channel->new_note_action;

+		}

+		else

+			nna = channel->playing->instrument->new_note_action;

+#endif

+

+		if ((sigdata->flags & IT_USE_INSTRUMENTS) && (channel->playing->enabled_envelopes) && channel->playing->instnum == channel->instrument) {

+			IT_PLAYING * playing = channel->playing;

+			IT_INSTRUMENT * inst = &sigdata->instrument[channel->instrument-1];

+			if ((playing->enabled_envelopes & IT_ENV_VOLUME) && (inst->volume_envelope.flags & IT_ENVELOPE_CARRY)) {

+				flags |= 1;

+				volume_envelope = playing->volume_envelope;

+			}

+			if ((playing->enabled_envelopes & IT_ENV_PANNING) && (inst->pan_envelope.flags & IT_ENVELOPE_CARRY)) {

+				flags |= 2;

+				pan_envelope = playing->pan_envelope;

+			}

+			if ((playing->enabled_envelopes & IT_ENV_PITCH) && (inst->pitch_envelope.flags & IT_ENVELOPE_CARRY)) {

+				flags |= 4;

+				pitch_envelope = playing->pitch_envelope;

+			}

+		}

+

+		switch (nna) {

+			case NNA_NOTE_CUT:

+#ifdef RAMP_DOWN

+				channel->playing->declick_stage = 2;

+#else

+				free(channel->playing);

+				channel->playing = NULL;

+#endif

+				break;

+			case NNA_NOTE_OFF:

+				it_note_off(channel->playing);

+				break;

+			case NNA_NOTE_FADE:

+				channel->playing->flags |= IT_PLAYING_BACKGROUND | IT_PLAYING_FADING;

+				break;

+		}

+	}

+

+	channel->new_note_action = 0xFF;

+

+	if (channel->sample == 0 || channel->note >= 120)

+		return;

+

+	channel->destnote = IT_NOTE_OFF;

+

+	if (channel->playing) {

+		for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+			if (!sigrenderer->playing[i]) {

+				sigrenderer->playing[i] = channel->playing;

+				channel->playing = NULL;

+				break;

+			}

+		}

+

+		if (sigrenderer->sigdata->flags & IT_USE_INSTRUMENTS)

+		{

+			for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+				IT_PLAYING * playing = sigrenderer->playing[i];

+				if (playing && playing->channel == channel && playing->instrument->dup_check_type) {

+					int match = 0;

+					switch (playing->instrument->dup_check_type)

+					{

+					case DCT_NOTE:

+						match = (channel->truenote == playing->note);

+					case DCT_SAMPLE:

+						match = match && (channel->sample == playing->sampnum);

+					case DCT_INSTRUMENT:

+						match = match && (channel->instrument == playing->instnum);

+						break;

+					}

+

+					if (match)

+					{

+						switch (playing->instrument->dup_check_action)

+						{

+						case DCA_NOTE_CUT:

+#ifdef RAMP_DOWN

+							playing->declick_stage = 2;

+#else

+							free(playing);

+							sigrenderer->playing[i] = NULL;

+#endif

+							if (channel->playing == playing) channel->playing = NULL;

+							break;

+						case DCA_NOTE_OFF:

+							if (!(playing->flags & IT_PLAYING_SUSTAINOFF))

+								it_note_off(playing);

+							break;

+						case DCA_NOTE_FADE:

+							playing->flags |= IT_PLAYING_BACKGROUND | IT_PLAYING_FADING;

+							break;

+						}

+					}

+				}

+			}

+		}

+

+/** WARNING - come up with some more heuristics for replacing old notes */

+#if 0

+		if (channel->playing) {

+			for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+				if (sigrenderer->playing[i]->flags & IT_PLAYING_BACKGROUND) {

+					write_seqtime();

+					sequence_c(SEQUENCE_STOP_SIGNAL);

+					sequence_c(i);

+					channel->VChannel = &module->VChannel[i];

+					break;

+				}

+			}

+		}

+#endif

+	}

+

+	if (channel->playing)

+		free(channel->playing);

+

+	channel->playing = malloc(sizeof(*channel->playing));

+

+	if (!channel->playing)

+		return;

+

+	if (!flags && sigdata->flags & IT_USE_INSTRUMENTS) {

+		for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+			IT_PLAYING * playing = sigrenderer->playing[i];

+			if (playing && (playing->enabled_envelopes) && playing->instnum == channel->instrument) {

+				IT_INSTRUMENT * inst = &sigdata->instrument[channel->instrument-1];

+				if ((playing->enabled_envelopes & IT_ENV_VOLUME) && (inst->volume_envelope.flags & IT_ENVELOPE_CARRY)) {

+					flags |= 1;

+					volume_envelope = playing->volume_envelope;

+				}

+				if ((playing->enabled_envelopes & IT_ENV_PANNING) && (inst->pan_envelope.flags & IT_ENVELOPE_CARRY)) {

+					flags |= 2;

+					pan_envelope = playing->pan_envelope;

+				}

+				if ((playing->enabled_envelopes & IT_ENV_PITCH) && (inst->pitch_envelope.flags & IT_ENVELOPE_CARRY)) {

+					flags |= 4;

+					pitch_envelope = playing->pitch_envelope;

+				}

+				break;

+			}

+		}

+	}				

+

+	channel->playing->flags = 0;

+	channel->playing->resampling_quality = sigrenderer->resampling_quality;

+	channel->playing->channel = channel;

+	channel->playing->sample = &sigdata->sample[channel->sample-1];

+	if (sigdata->flags & IT_USE_INSTRUMENTS)

+		channel->playing->instrument = &sigdata->instrument[channel->instrument-1];

+	else

+		channel->playing->instrument = NULL;

+	channel->playing->env_instrument = channel->playing->instrument;

+	channel->playing->sampnum = channel->sample;

+	channel->playing->instnum = channel->instrument;

+#ifdef END_RAMPING

+	channel->playing->declick_stage = 0;

+	channel->playing->declick_volume = 1.f / 256.f;

+#endif

+	channel->playing->channel_volume = channel->channelvolume;

+	channel->playing->ramp_volume[0] = 31337.0; /* special */

+	channel->playing->note = channel->truenote;

+	channel->playing->enabled_envelopes = 0;

+	channel->playing->volume_offset = 0;

+	channel->playing->panning_offset = 0;

+	//channel->playing->output = channel->output;

+	if (sigdata->flags & IT_USE_INSTRUMENTS) {

+		IT_PLAYING * playing = channel->playing;

+		IT_INSTRUMENT * instrument = playing->instrument;

+		if (instrument->volume_envelope.flags & IT_ENVELOPE_ON) playing->enabled_envelopes |= IT_ENV_VOLUME;

+		if (instrument->pan_envelope.flags & IT_ENVELOPE_ON) playing->enabled_envelopes |= IT_ENV_PANNING;

+		if (instrument->pitch_envelope.flags & IT_ENVELOPE_ON) playing->enabled_envelopes |= IT_ENV_PITCH;

+		if (instrument->random_volume) playing->volume_offset = (rand() % (instrument->random_volume * 2 + 1)) - instrument->random_volume;

+		if (instrument->random_pan) playing->panning_offset = (rand() % (instrument->random_pan * 2 + 1)) - instrument->random_pan;

+		//if (instrument->output) playing->output = instrument->output;

+	}

+	channel->playing->filter_cutoff = 127;

+	channel->playing->filter_resonance = 0;

+	channel->playing->true_filter_cutoff = 127 << 8;

+	channel->playing->true_filter_resonance = 0;

+	channel->playing->vibrato_speed = 0;

+	channel->playing->vibrato_depth = 0;

+	channel->playing->vibrato_n = 0;

+	channel->playing->vibrato_time = 0;

+	channel->playing->vibrato_waveform = channel->vibrato_waveform;

+	channel->playing->tremolo_speed = 0;

+	channel->playing->tremolo_depth = 0;

+	channel->playing->tremolo_time = 0;

+	channel->playing->tremolo_waveform = channel->tremolo_waveform;

+	channel->playing->panbrello_speed = 0;

+	channel->playing->panbrello_depth = 0;

+	channel->playing->panbrello_time = 0;

+	channel->playing->panbrello_waveform = channel->panbrello_waveform;

+	channel->playing->panbrello_random = 0;

+	channel->playing->sample_vibrato_time = 0;

+	channel->playing->sample_vibrato_waveform = channel->playing->sample->vibrato_waveform;

+	channel->playing->sample_vibrato_depth = 0;

+	channel->playing->slide = 0;

+	channel->playing->finetune = channel->playing->sample->finetune;

+

+	if (flags & 1) {

+		channel->playing->volume_envelope = volume_envelope;

+	} else {

+		channel->playing->volume_envelope.next_node = 0;

+		channel->playing->volume_envelope.tick = 0;

+	}

+	if (flags & 2) {

+		channel->playing->pan_envelope = pan_envelope;

+	} else {

+		channel->playing->pan_envelope.next_node = 0;

+		channel->playing->pan_envelope.tick = 0;

+	}

+	if (flags & 4) {

+		channel->playing->pitch_envelope = pitch_envelope;

+	} else {

+		channel->playing->pitch_envelope.next_node = 0;

+		channel->playing->pitch_envelope.tick = 0;

+	}

+	channel->playing->fadeoutcount = 1024;

+	it_reset_filter_state(&channel->playing->filter_state[0]);

+	it_reset_filter_state(&channel->playing->filter_state[1]);

+	it_playing_reset_resamplers(channel->playing, 0);

+

+	/** WARNING - is everything initialised? */

+}

+

+

+

+static void get_default_volpan(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel)

+{

+	if (channel->sample == 0)

+		return;

+

+	channel->volume = sigdata->sample[channel->sample-1].default_volume;

+

+	if (sigdata->flags & IT_WAS_AN_XM) {

+		if (!(sigdata->flags & IT_WAS_A_MOD))

+			channel->truepan = 32 + sigdata->sample[channel->sample-1].default_pan*64;

+		return;

+	}

+

+	{

+		int pan = sigdata->sample[channel->sample-1].default_pan;

+		if (pan >= 128 && pan <= 192) {

+			channel->pan = pan - 128;

+			return;

+		}

+	}

+

+	if (sigdata->flags & IT_USE_INSTRUMENTS) {

+		IT_INSTRUMENT *instrument = &sigdata->instrument[channel->instrument-1];

+		if (instrument->default_pan <= 64)

+			channel->pan = instrument->default_pan;

+		if (instrument->filter_cutoff >= 128)

+			channel->filter_cutoff = instrument->filter_cutoff - 128;

+		if (instrument->filter_resonance >= 128)

+			channel->filter_resonance = instrument->filter_resonance - 128;

+	}

+}

+

+

+

+static void get_true_pan(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel)

+{

+	channel->truepan = channel->pan << IT_ENVELOPE_SHIFT;

+

+	if (channel->sample && !IT_IS_SURROUND_SHIFTED(channel->truepan) && (sigdata->flags & IT_USE_INSTRUMENTS)) {

+		IT_INSTRUMENT *instrument = &sigdata->instrument[channel->instrument-1];

+		int truepan = channel->truepan;

+		truepan += (channel->note - instrument->pp_centre) * instrument->pp_separation << (IT_ENVELOPE_SHIFT - 3);

+		channel->truepan = (unsigned short)MID(0, truepan, 64 << IT_ENVELOPE_SHIFT);

+	}

+}

+

+

+

+static void post_process_it_volpan(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry)

+{

+	IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel];

+

+	if (entry->mask & IT_ENTRY_VOLPAN) {

+		if (entry->volpan <= 84) {

+			/* Volume */

+			/* Fine volume slide up */

+			/* Fine volume slide down */

+		} else if (entry->volpan <= 94) {

+			/* Volume slide up */

+			unsigned char v = entry->volpan - 85;

+			if (v == 0)

+				v = channel->lastvolslide;

+			channel->lastvolslide = v;

+			/* = effect Dx0 where x == entry->volpan - 85 */

+			channel->volslide = v;

+		} else if (entry->volpan <= 104) {

+			/* Volume slide down */

+			unsigned char v = entry->volpan - 95;

+			if (v == 0)

+				v = channel->lastvolslide;

+			channel->lastvolslide = v;

+			/* = effect D0x where x == entry->volpan - 95 */

+			channel->volslide = -v;

+		} else if (entry->volpan <= 114) {

+			/* Portamento down */

+			unsigned char v = (entry->volpan - 105) << 2;

+			if (v == 0)

+				v = channel->lastEF;

+			channel->lastEF = v;

+			channel->portamento -= v << 4;

+		} else if (entry->volpan <= 124) {

+			/* Portamento up */

+			unsigned char v = (entry->volpan - 115) << 2;

+			if (v == 0)

+				v = channel->lastEF;

+			channel->lastEF = v;

+			channel->portamento += v << 4;

+		} else if (entry->volpan <= 202) {

+			/* Pan */

+			/* Tone Portamento */

+		} else if (entry->volpan <= 212) {

+			/* Vibrato */

+			/* This is unaffected by IT_OLD_EFFECTS. However, if v == 0, then any doubling of depth that happened before (with Hxy in the effect column) will be preserved. */

+			unsigned char v = entry->volpan - 203;

+			if (v == 0)

+				v = channel->lastHdepth;

+			else {

+				v <<= 2;

+				channel->lastHdepth = v;

+			}

+			if (channel->playing) {

+				channel->playing->vibrato_speed = channel->lastHspeed;

+				channel->playing->vibrato_depth = v;

+				channel->playing->vibrato_n++;

+			}

+		}

+	}

+}

+

+

+

+static void it_send_midi(DUMB_IT_SIGRENDERER *sigrenderer, IT_CHANNEL *channel, unsigned char midi_byte)

+{

+	if (sigrenderer->callbacks->midi)

+		if ((*sigrenderer->callbacks->midi)(sigrenderer->callbacks->midi_data, channel - sigrenderer->channel, midi_byte))

+			return;

+

+	switch (channel->midi_state) {

+		case 4: /* Ready to receive resonance parameter */

+			if (midi_byte < 0x80) channel->filter_resonance = midi_byte;

+			channel->midi_state = 0;

+			break;

+		case 3: /* Ready to receive cutoff parameter */

+			if (midi_byte < 0x80) channel->filter_cutoff = midi_byte;

+			channel->midi_state = 0;

+			break;

+		case 2: /* Ready for byte specifying which parameter will follow */

+			if (midi_byte == 0) /* Cutoff */

+				channel->midi_state = 3;

+			else if (midi_byte == 1) /* Resonance */

+				channel->midi_state = 4;

+			else

+				channel->midi_state = 0;

+			break;

+		default: /* Counting initial F0 bytes */

+			switch (midi_byte) {

+				case 0xF0:

+					channel->midi_state++;

+					break;

+				case 0xFA:

+				case 0xFC:

+				case 0xFF:

+					/* Reset filter parameters for all channels */

+					{

+						int i;

+						for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+							sigrenderer->channel[i].filter_cutoff = 127;

+							sigrenderer->channel[i].filter_resonance = 0;

+							//// should we be resetting channel[i].playing->filter_* here?

+						}

+					}

+					/* Fall through */

+				default:

+					channel->midi_state = 0;

+					break;

+			}

+	}

+}

+

+

+

+static void xm_envelope_calculate_value(IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe)

+{

+	if (pe->next_node <= 0)

+		pe->value = envelope->node_y[0] << IT_ENVELOPE_SHIFT;

+	else if (pe->next_node >= envelope->n_nodes)

+		pe->value = envelope->node_y[envelope->n_nodes-1] << IT_ENVELOPE_SHIFT;

+	else {

+		int ys = envelope->node_y[pe->next_node-1] << IT_ENVELOPE_SHIFT;

+		int ts = envelope->node_t[pe->next_node-1];

+		int te = envelope->node_t[pe->next_node];

+

+		if (ts == te)

+			pe->value = ys;

+		else {

+			int ye = envelope->node_y[pe->next_node] << IT_ENVELOPE_SHIFT;

+			int t = pe->tick;

+

+			pe->value = ys + (ye - ys) * (t - ts) / (te - ts);

+		}

+	}

+}

+

+

+

+extern const char xm_convert_vibrato[];

+

+/* Returns 1 if a callback caused termination of playback. */

+static int process_effects(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry, int ignore_cxx)

+{

+	DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata;

+

+	IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel];

+

+	if (entry->mask & IT_ENTRY_EFFECT) {

+		switch (entry->effect) {

+/*

+Notes about effects (as compared to other module formats)

+

+C               This is now in *HEX*. (Used to be in decimal in ST3)

+E/F/G/H/U       You need to check whether the song uses Amiga/Linear slides.

+H/U             Vibrato in Impulse Tracker is two times finer than in

+                any other tracker and is updated EVERY tick.

+                If "Old Effects" is *ON*, then the vibrato is played in the

+                normal manner (every non-row tick and normal depth)

+E/F/G           These commands ALL share the same memory.

+Oxx             Offsets to samples are to the 'xx00th' SAMPLE. (ie. for

+                16 bit samples, the offset is xx00h*2)

+                Oxx past the sample end will be ignored, unless "Old Effects"

+                is ON, in which case the Oxx will play from the end of the

+                sample.

+Yxy             This uses a table 4 times larger (hence 4 times slower) than

+                vibrato or tremelo. If the waveform is set to random, then

+                the 'speed' part of the command is interpreted as a delay.

+*/

+			case IT_SET_SPEED:

+				if (entry->effectvalue)

+				{

+					/*if (entry->effectvalue == 255)

+						if (sigrenderer->callbacks->xm_speed_zero && (*sigrenderer->callbacks->xm_speed_zero)(sigrenderer->callbacks->xm_speed_zero_data))

+							return 1;*/

+					sigrenderer->tick = sigrenderer->speed = entry->effectvalue;

+				}

+				else if ((sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD)) == IT_WAS_AN_XM) {

+#ifdef BIT_ARRAY_BULLSHIT

+					bit_array_set(sigrenderer->played, sigrenderer->order * 256 + sigrenderer->row);

+#endif

+					sigrenderer->speed = 0;

+					if (sigrenderer->callbacks->xm_speed_zero && (*sigrenderer->callbacks->xm_speed_zero)(sigrenderer->callbacks->xm_speed_zero_data))

+						return 1;

+				}

+				break;

+

+			case IT_BREAK_TO_ROW:

+				if (ignore_cxx) break;

+				sigrenderer->breakrow = entry->effectvalue;

+				/* XXX jump and break on the same row */

+				if ( ( ( sigrenderer->processrow | 0xC00 ) == 0xFFFE ) &&

+					! ( sigrenderer->processrow & 0x400 ) ) {

+					sigrenderer->processrow = 0xFFFE & ~0xC00;

+				} else {

+					sigrenderer->processorder = sigrenderer->order;

+					sigrenderer->processrow = 0xFFFE & ~0x800;

+				}

+				break;

+

+			case IT_VOLSLIDE_VIBRATO:

+				if (channel->playing) {

+					channel->playing->vibrato_speed = channel->lastHspeed;

+					channel->playing->vibrato_depth = channel->lastHdepth;

+					channel->playing->vibrato_n++;

+				}

+				/* Fall through and process volume slide. */

+			case IT_VOLUME_SLIDE:

+			case IT_VOLSLIDE_TONEPORTA:

+				/* The tone portamento component is handled elsewhere. */

+				{

+					unsigned char v = entry->effectvalue;

+					if (!(sigdata->flags & IT_WAS_A_MOD)) {

+						if (v == 0)

+							v = channel->lastDKL;

+						channel->lastDKL = v;

+					}

+					if ((v & 0x0F) == 0) { /* Dx0 */

+						channel->volslide = v >> 4;

+						if (channel->volslide == 15 && !(sigdata->flags & IT_WAS_AN_XM)) {

+							channel->volume += 15;

+							if (channel->volume > 64) channel->volume = 64;

+						}

+					} else if ((v & 0xF0) == 0) { /* D0x */

+						channel->volslide = -v;

+						if (channel->volslide == -15 && !(sigdata->flags & IT_WAS_AN_XM)) {

+							channel->volume -= 15;

+							if (channel->volume > 64) channel->volume = 0;

+						}

+					} else if ((v & 0x0F) == 0x0F) { /* DxF */

+						channel->volume += v >> 4;

+						if (channel->volume > 64) channel->volume = 64;

+					} else if ((v & 0xF0) == 0xF0) { /* DFx */

+						channel->volume -= v & 15;

+						if (channel->volume > 64) channel->volume = 0;

+					}

+				}

+				break;

+			case IT_XM_FINE_VOLSLIDE_DOWN:

+				{

+					unsigned char v = entry->effectvalue;

+					if (v == 0)

+						v = channel->xm_lastEB;

+					channel->xm_lastEB = v;

+					channel->volume -= v;

+					if (channel->volume > 64) channel->volume = 0;

+				}

+				break;

+			case IT_XM_FINE_VOLSLIDE_UP:

+				{

+					unsigned char v = entry->effectvalue;

+					if (v == 0)

+						v = channel->xm_lastEA;

+					channel->xm_lastEA = v;

+					channel->volume += v;

+					if (channel->volume > 64) channel->volume = 64;

+				}

+				break;

+			case IT_PORTAMENTO_DOWN:

+				{

+					unsigned char v = entry->effectvalue;

+					if (sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_669)) {

+						if (!(sigdata->flags & IT_WAS_A_MOD)) {

+							if (v == 0xF0)

+								v |= channel->xm_lastE2;

+							else if (v >= 0xF0)

+								channel->xm_lastE2 = v & 15;

+							else if (v == 0xE0)

+								v |= channel->xm_lastX2;

+							else

+								channel->xm_lastX2 = v & 15;

+						}

+					} else {

+						if (v == 0)

+							v = channel->lastEF;

+						channel->lastEF = v;

+					}

+					if (channel->playing) {

+						if ((v & 0xF0) == 0xF0)

+							channel->playing->slide -= (v & 15) << 4;

+						else if ((v & 0xF0) == 0xE0)

+							channel->playing->slide -= (v & 15) << 2;

+						else if (sigdata->flags & IT_WAS_A_669)

+							channel->portamento -= v << 3;

+						else

+							channel->portamento -= v << 4;

+					}

+				}

+				break;

+			case IT_PORTAMENTO_UP:

+				{

+					unsigned char v = entry->effectvalue;

+					if (sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_669)) {

+						if (!(sigdata->flags & IT_WAS_A_MOD)) {

+							if (v == 0xF0)

+								v |= channel->xm_lastE1;

+							else if (v >= 0xF0)

+								channel->xm_lastE1 = v & 15;

+							else if (v == 0xE0)

+								v |= channel->xm_lastX1;

+							else

+								channel->xm_lastX1 = v & 15;

+						}

+					} else {

+						if (v == 0)

+							v = channel->lastEF;

+						channel->lastEF = v;

+					}

+					if (channel->playing) {

+						if ((v & 0xF0) == 0xF0)

+							channel->playing->slide += (v & 15) << 4;

+						else if ((v & 0xF0) == 0xE0)

+							channel->playing->slide += (v & 15) << 2;

+						else if (sigdata->flags & IT_WAS_A_669)

+							channel->portamento += v << 3;

+						else

+							channel->portamento += v << 4;

+					}

+				}

+				break;

+			case IT_XM_PORTAMENTO_DOWN:

+				{

+					unsigned char v = entry->effectvalue;

+					if (!(sigdata->flags & IT_WAS_A_MOD)) {

+						if (v == 0)

+							v = channel->lastJ;

+						channel->lastJ = v;

+					}

+					if (channel->playing)

+						channel->portamento -= v << 4;

+				}

+				break;

+			case IT_XM_PORTAMENTO_UP:

+				{

+					unsigned char v = entry->effectvalue;

+					if (!(sigdata->flags & IT_WAS_A_MOD)) {

+						if (v == 0)

+							v = channel->lastEF;

+						channel->lastEF = v;

+					}

+					if (channel->playing)

+						channel->portamento += v << 4;

+				}

+				break;

+			case IT_XM_KEY_OFF:

+				channel->key_off_count = entry->effectvalue;

+				if (!channel->key_off_count) xm_note_off(sigdata, channel);

+				break;

+			case IT_VIBRATO:

+				{

+					if (entry->effectvalue || !(sigdata->flags & IT_WAS_A_669)) {

+						unsigned char speed = entry->effectvalue >> 4;

+						unsigned char depth = entry->effectvalue & 15;

+						if (speed == 0)

+							speed = channel->lastHspeed;

+						channel->lastHspeed = speed;

+						if (depth == 0)

+							depth = channel->lastHdepth;

+						else {

+							if (sigdata->flags & IT_OLD_EFFECTS)

+								depth <<= 3;

+							else

+								depth <<= 2;

+							channel->lastHdepth = depth;

+						}

+						if (channel->playing) {

+							channel->playing->vibrato_speed = speed;

+							channel->playing->vibrato_depth = depth;

+							channel->playing->vibrato_n++;

+						}

+					}

+				}

+				break;

+			case IT_TREMOR:

+				{

+					unsigned char v = entry->effectvalue;

+					if (v == 0)

+						v = channel->lastI;

+					else if (!(sigdata->flags & IT_OLD_EFFECTS)) {

+						if (v & 0xF0) v -= 0x10;

+						if (v & 0x0F) v -= 0x01;

+					}

+					channel->lastI = v;

+					channel->tremor_time |= 128;

+				}

+				update_tremor(channel);

+				break;

+			case IT_ARPEGGIO:

+				{

+					unsigned char v = entry->effectvalue;

+					/* XM files have no memory for arpeggio (000 = no effect)

+					 * and we use lastJ for portamento down instead.

+					 */

+					if (!(sigdata->flags & IT_WAS_AN_XM)) {

+						if (v == 0)

+							v = channel->lastJ;

+						channel->lastJ = v;

+					}

+					channel->arpeggio = v;

+				}

+				break;

+			case IT_SET_CHANNEL_VOLUME:

+				if (sigdata->flags & IT_WAS_AN_XM)

+					channel->volume = MIN(entry->effectvalue, 64);

+				else if (entry->effectvalue <= 64)

+					channel->channelvolume = entry->effectvalue;

+#ifdef VOLUME_OUT_OF_RANGE_SETS_MAXIMUM

+				else

+					channel->channelvolume = 64;

+#endif

+				if (channel->playing)

+					channel->playing->channel_volume = channel->channelvolume;

+				break;

+			case IT_CHANNEL_VOLUME_SLIDE:

+				{

+					unsigned char v = entry->effectvalue;

+					if (v == 0)

+						v = channel->lastN;

+					channel->lastN = v;

+					if ((v & 0x0F) == 0) { /* Nx0 */

+						channel->channelvolslide = v >> 4;

+					} else if ((v & 0xF0) == 0) { /* N0x */

+						channel->channelvolslide = -v;

+					} else {

+						if ((v & 0x0F) == 0x0F) { /* NxF */

+							channel->channelvolume += v >> 4;

+							if (channel->channelvolume > 64) channel->channelvolume = 64;

+						} else if ((v & 0xF0) == 0xF0) { /* NFx */

+							channel->channelvolume -= v & 15;

+							if (channel->channelvolume > 64) channel->channelvolume = 0;

+						} else

+							break;

+						if (channel->playing)

+							channel->playing->channel_volume = channel->channelvolume;

+					}

+				}

+				break;

+			case IT_SET_SAMPLE_OFFSET:

+				{

+					unsigned char v = entry->effectvalue;

+					/*if (sigdata->flags & IT_WAS_A_MOD) {

+						if (v == 0) break;

+					} else*/ {

+						if (v == 0)

+							v = channel->lastO;

+						channel->lastO = v;

+					}

+					/* Note: we set the offset even if tone portamento is

+					 * specified. Impulse Tracker does the same.

+					 */

+					if (entry->mask & IT_ENTRY_NOTE) {

+						if (channel->playing) {

+							int offset = ((int)channel->high_offset << 16) | ((int)v << 8);

+							IT_PLAYING *playing = channel->playing;

+							IT_SAMPLE *sample = playing->sample;

+							int end;

+							if ((sample->flags & IT_SAMPLE_SUS_LOOP) && !(playing->flags & IT_PLAYING_SUSTAINOFF))

+								end = sample->sus_loop_end;

+							else if (sample->flags & IT_SAMPLE_LOOP)

+								end = sample->loop_end;

+							else

+								end = sample->length;

+							if ((sigdata->flags & IT_WAS_A_PTM) && (sample->flags & IT_SAMPLE_16BIT))

+								offset >>= 1;

+							if (offset < end) {

+								it_playing_reset_resamplers(playing, offset);

+#ifdef END_RAMPING

+								playing->declick_stage = 0;

+								playing->declick_volume = 1.f / 256.f;

+#endif

+							} else if (sigdata->flags & IT_OLD_EFFECTS) {

+								it_playing_reset_resamplers(playing, end);

+#ifdef END_RAMPING

+								playing->declick_stage = 0;

+								playing->declick_volume = 1.f / 256.f;

+#endif

+							}

+						}

+					}

+				}

+				break;

+			case IT_PANNING_SLIDE:

+				/** JULIEN: guess what? the docs are wrong! (how unusual ;)

+				 * Pxy seems to memorize its previous value... and there

+				 * might be other mistakes like that... (sigh!)

+				 */

+				/** ENTHEH: umm... but... the docs say that Pxy memorises its

+				 * value... don't they? :o

+				 */

+				{

+					unsigned char v = entry->effectvalue;

+					int p = channel->truepan;

+					if (sigdata->flags & IT_WAS_AN_XM)

+					{

+						if (IT_IS_SURROUND(channel->pan))

+						{

+							channel->pan = 32;

+							p = 32 + 128 * 64;

+						}

+						p >>= 6;

+					}

+					else {

+						if (IT_IS_SURROUND(channel->pan)) p = 32 << 8;

+						p = (p + 128) >> 8;

+						channel->pan = p;

+					}

+					if (v == 0)

+						v = channel->lastP;

+					channel->lastP = v;

+					if ((v & 0x0F) == 0) { /* Px0 */

+						channel->panslide = -(v >> 4);

+					} else if ((v & 0xF0) == 0) { /* P0x */

+						channel->panslide = v;

+					} else if ((v & 0x0F) == 0x0F) { /* PxF */

+						p -= v >> 4;

+					} else if ((v & 0xF0) == 0xF0) { /* PFx */

+						p += v & 15;

+					}

+					if (sigdata->flags & IT_WAS_AN_XM)

+						channel->truepan = 32 + MID(0, p, 255) * 64;

+					else {

+						if (p < 0) p = 0;

+						else if (p > 64) p = 64;

+						channel->pan = p;

+						channel->truepan = p << 8;

+					}

+				}

+				break;

+			case IT_RETRIGGER_NOTE:

+				{

+					unsigned char v = entry->effectvalue;

+					if (sigdata->flags & IT_WAS_AN_XM) {

+						if ((v & 0x0F) == 0) v |= channel->lastQ & 0x0F;

+						if ((v & 0xF0) == 0) v |= channel->lastQ & 0xF0;

+					} else {

+						if (v == 0)

+							v = channel->lastQ;

+					}

+					channel->lastQ = v;

+					if ((v & 0x0F) == 0) v |= 0x01;

+					channel->retrig = v;

+					if (entry->mask & IT_ENTRY_NOTE) {

+						channel->retrig_tick = v & 0x0F;

+						/* Emulate a bug */

+						if (sigdata->flags & IT_WAS_AN_XM)

+							update_retrig(sigrenderer, channel);

+					} else

+						update_retrig(sigrenderer, channel);

+				}

+				break;

+			case IT_XM_RETRIGGER_NOTE:

+				channel->retrig_tick = channel->xm_retrig = entry->effectvalue;

+				if (entry->effectvalue == 0)

+					if (channel->playing) {

+						it_playing_reset_resamplers(channel->playing, 0);

+#ifdef END_RAMPING

+						channel->playing->declick_stage = 0;

+						channel->playing->declick_volume = 1.f / 256.f;

+#endif

+					}

+				break;

+			case IT_TREMOLO:

+				{

+					unsigned char speed = entry->effectvalue >> 4;

+					unsigned char depth = entry->effectvalue & 15;

+					if (speed == 0)

+						speed = channel->lastRspeed;

+					channel->lastRspeed = speed;

+					if (depth == 0)

+						depth = channel->lastRdepth;

+					channel->lastRdepth = depth;

+					if (channel->playing) {

+						channel->playing->tremolo_speed = speed;

+						channel->playing->tremolo_depth = depth;

+					}

+				}

+				break;

+			case IT_S:

+				{

+					/* channel->lastS was set in update_pattern_variables(). */

+					unsigned char effectvalue = channel->lastS;

+					switch (effectvalue >> 4) {

+						//case IT_S_SET_FILTER:

+							/* Waveforms for commands S3x, S4x and S5x:

+							 *   0: Sine wave

+							 *   1: Ramp down

+							 *   2: Square wave

+							 *   3: Random wave

+							 */

+						case IT_S_SET_GLISSANDO_CONTROL:

+							channel->glissando = effectvalue & 15;

+							break;

+

+						case IT_S_FINETUNE:

+							if (channel->playing) {

+								channel->playing->finetune = ((int)(effectvalue & 15) - 8) << 5;

+							}

+							break;

+

+						case IT_S_SET_VIBRATO_WAVEFORM:

+							{

+								int waveform = effectvalue & 3;

+								if (sigdata->flags & IT_WAS_AN_XM) waveform = xm_convert_vibrato[waveform];

+								channel->vibrato_waveform = waveform;

+								if (channel->playing) {

+									channel->playing->vibrato_waveform = waveform;

+									if (!(effectvalue & 4))

+										channel->playing->vibrato_time = 0;

+								}

+							}

+							break;

+						case IT_S_SET_TREMOLO_WAVEFORM:

+							{

+								int waveform = effectvalue & 3;

+								if (sigdata->flags & IT_WAS_AN_XM) waveform = xm_convert_vibrato[waveform];

+								channel->tremolo_waveform = waveform;

+								if (channel->playing) {

+									channel->playing->tremolo_waveform = waveform;

+									if (!(effectvalue & 4))

+										channel->playing->tremolo_time = 0;

+								}

+							}

+							break;

+						case IT_S_SET_PANBRELLO_WAVEFORM:

+							channel->panbrello_waveform = effectvalue & 3;

+							if (channel->playing) {

+								channel->playing->panbrello_waveform = effectvalue & 3;

+								if (!(effectvalue & 4))

+									channel->playing->panbrello_time = 0;

+							}

+							break;

+

+						case IT_S_FINE_PATTERN_DELAY:

+							sigrenderer->tick += effectvalue & 15;

+							break;

+#if 1

+						case IT_S7:

+							{

+								if (sigrenderer->sigdata->flags & IT_USE_INSTRUMENTS)

+								{

+									int i;

+									switch (effectvalue & 15)

+									{

+									case 0: /* cut background notes */

+										for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++)

+										{

+											IT_PLAYING * playing = sigrenderer->playing[i];

+											if (playing && channel == playing->channel)

+											{

+#ifdef RAMP_DOWN

+												playing->declick_stage = 2;

+#else

+												free(playing);

+												sigrenderer->playing[i] = NULL;

+#endif

+												if (channel->playing == playing) channel->playing = NULL;

+											}

+										}

+										break;

+									case 1: /* release background notes */

+										for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++)

+										{

+											IT_PLAYING * playing = sigrenderer->playing[i];

+											if (playing && channel == playing->channel && !(playing->flags & IT_PLAYING_SUSTAINOFF))

+											{

+												it_note_off(playing);

+											}

+										}

+										break;

+									case 2: /* fade background notes */

+										for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++)

+										{

+											IT_PLAYING * playing = sigrenderer->playing[i];

+											if (playing && channel == playing->channel)

+											{

+												//playing->flags &= IT_PLAYING_SUSTAINOFF;

+												playing->flags |= IT_PLAYING_FADING;

+											}

+										}

+										break;

+									case 3:

+										channel->new_note_action = NNA_NOTE_CUT;

+										break;

+									case 4:

+										channel->new_note_action = NNA_NOTE_CONTINUE;

+										break;

+									case 5:

+										channel->new_note_action = NNA_NOTE_OFF;

+										break;

+									case 6:

+										channel->new_note_action = NNA_NOTE_FADE;

+										break;

+

+									case 7:

+										if (channel->playing)

+											channel->playing->enabled_envelopes &= ~IT_ENV_VOLUME;

+										break;

+									case 8:

+										if (channel->playing)

+											channel->playing->enabled_envelopes |= IT_ENV_VOLUME;

+										break;

+

+									case 9:

+										if (channel->playing)

+											channel->playing->enabled_envelopes &= ~IT_ENV_PANNING;

+										break;

+									case 10:

+										if (channel->playing)

+											channel->playing->enabled_envelopes |= IT_ENV_PANNING;

+										break;

+

+									case 11:

+										if (channel->playing)

+											channel->playing->enabled_envelopes &= ~IT_ENV_PITCH;

+										break;

+									case 12:

+										if (channel->playing)

+											channel->playing->enabled_envelopes |= IT_ENV_PITCH;

+										break;

+									}

+								}

+							}

+							break;

+#endif

+						case IT_S_SET_PAN:

+							//ASSERT(!(sigdata->flags & IT_WAS_AN_XM));

+							channel->pan =

+								((effectvalue & 15) << 2) |

+								((effectvalue & 15) >> 2);

+							channel->truepan = channel->pan << IT_ENVELOPE_SHIFT;

+

+							if (channel->playing)

+								channel->playing->panbrello_depth = 0;

+							break;

+						case IT_S_SET_SURROUND_SOUND:

+							if ((effectvalue & 15) == 1) {

+								channel->pan = IT_SURROUND;

+								channel->truepan = channel->pan << IT_ENVELOPE_SHIFT;

+							}

+							if (channel->playing)

+								channel->playing->panbrello_depth = 0;

+							break;

+						case IT_S_SET_HIGH_OFFSET:

+							channel->high_offset = effectvalue & 15;

+							break;

+						//case IT_S_PATTERN_LOOP:

+						case IT_S_DELAYED_NOTE_CUT:

+							channel->note_cut_count = effectvalue & 15;

+							if (!channel->note_cut_count) {

+								if (sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_PTM))

+									channel->volume = 0;

+								else

+									channel->note_cut_count = 1;

+							}

+							break;

+						case IT_S_SET_MIDI_MACRO:

+							channel->SFmacro = effectvalue & 15;

+							break;

+					}

+				}

+				break;

+			case IT_SET_SONG_TEMPO:

+				{

+					unsigned char v = entry->effectvalue;

+					if (v == 0)

+						v = channel->lastW;

+					channel->lastW = v;

+					if (v < 0x10)

+						sigrenderer->temposlide = -v;

+					else if (v < 0x20)

+						sigrenderer->temposlide = v & 15;

+					else

+						sigrenderer->tempo = v;

+				}

+				break;

+			case IT_FINE_VIBRATO:

+				{

+					unsigned char speed = entry->effectvalue >> 4;

+					unsigned char depth = entry->effectvalue & 15;

+					if (speed == 0)

+						speed = channel->lastHspeed;

+					channel->lastHspeed = speed;

+					if (depth == 0)

+						depth = channel->lastHdepth;

+					else {

+						if (sigdata->flags & IT_OLD_EFFECTS)

+							depth <<= 1;

+						channel->lastHdepth = depth;

+					}

+					if (channel->playing) {

+						channel->playing->vibrato_speed = speed;

+						channel->playing->vibrato_depth = depth;

+						channel->playing->vibrato_n++;

+					}

+				}

+				break;

+			case IT_SET_GLOBAL_VOLUME:

+				if (entry->effectvalue <= 128)

+					sigrenderer->globalvolume = entry->effectvalue;

+#ifdef VOLUME_OUT_OF_RANGE_SETS_MAXIMUM

+				else

+					sigrenderer->globalvolume = 128;

+#endif

+				break;

+			case IT_GLOBAL_VOLUME_SLIDE:

+				{

+					unsigned char v = entry->effectvalue;

+					if (v == 0)

+						v = channel->lastW;

+					channel->lastW = v;

+					if ((v & 0x0F) == 0) { /* Wx0 */

+						sigrenderer->globalvolslide =

+							(sigdata->flags & IT_WAS_AN_XM) ? (v >> 4)*2 : (v >> 4);

+					} else if ((v & 0xF0) == 0) { /* W0x */

+						sigrenderer->globalvolslide =

+							(sigdata->flags & IT_WAS_AN_XM) ? (-v)*2 : (-v);

+					} else if ((v & 0x0F) == 0x0F) { /* WxF */

+						sigrenderer->globalvolume += v >> 4;

+						if (sigrenderer->globalvolume > 128) sigrenderer->globalvolume = 128;

+					} else if ((v & 0xF0) == 0xF0) { /* WFx */

+						sigrenderer->globalvolume -= v & 15;

+						if (sigrenderer->globalvolume > 128) sigrenderer->globalvolume = 0;

+					}

+				}

+				break;

+			case IT_SET_PANNING:

+				if (sigdata->flags & IT_WAS_AN_XM) {

+					if (sigdata->flags & IT_WAS_A_MOD)

+						channel->truepan = entry->effectvalue*128;

+					else

+						channel->truepan = 32 + entry->effectvalue*64;

+				} else {

+					if (sigdata->flags & IT_WAS_AN_S3M)

+						channel->pan = (entry->effectvalue + 1) >> 1;

+					else

+						channel->pan = (entry->effectvalue + 2) >> 2;

+					channel->truepan = channel->pan << IT_ENVELOPE_SHIFT;

+				}

+				if (channel->playing)

+					channel->playing->panbrello_depth = 0;

+				break;

+			case IT_PANBRELLO:

+				{

+					unsigned char speed = entry->effectvalue >> 4;

+					unsigned char depth = entry->effectvalue & 15;

+					if (speed == 0)

+						speed = channel->lastYspeed;

+					channel->lastYspeed = speed;

+					if (depth == 0)

+						depth = channel->lastYdepth;

+					channel->lastYdepth = depth;

+					if (channel->playing) {

+						channel->playing->panbrello_speed = speed;

+						channel->playing->panbrello_depth = depth;

+					}

+				}

+				break;

+			case IT_MIDI_MACRO:

+				{

+					const IT_MIDI *midi = sigdata->midi ? sigdata->midi : &default_midi;

+					if (entry->effectvalue >= 0x80) {

+						int n = midi->Zmacrolen[entry->effectvalue-0x80];

+						int i;

+						for (i = 0; i < n; i++)

+							it_send_midi(sigrenderer, channel, midi->Zmacro[entry->effectvalue-0x80][i]);

+					} else {

+						int n = midi->SFmacrolen[channel->SFmacro];

+						int i, j;

+						for (i = 0, j = 1; i < n; i++, j <<= 1)

+							it_send_midi(sigrenderer, channel,

+								(unsigned char)(midi->SFmacroz[channel->SFmacro] & j ?

+									entry->effectvalue : midi->SFmacro[channel->SFmacro][i]));

+					}

+				}

+				break;

+			case IT_XM_SET_ENVELOPE_POSITION:

+				if (channel->playing && channel->playing->env_instrument) {

+					IT_ENVELOPE *envelope = &channel->playing->env_instrument->volume_envelope;

+					if (envelope->flags & IT_ENVELOPE_ON) {

+						IT_PLAYING_ENVELOPE *pe = &channel->playing->volume_envelope;

+						pe->tick = entry->effectvalue;

+						if (pe->tick >= envelope->node_t[envelope->n_nodes-1])

+							pe->tick = envelope->node_t[envelope->n_nodes-1];

+						pe->next_node = 0;

+						while (pe->tick > envelope->node_t[pe->next_node]) pe->next_node++;

+						xm_envelope_calculate_value(envelope, pe);

+					}

+				}

+				break;

+

+			/* uggly plain portamento for now */

+			case IT_PTM_NOTE_SLIDE_DOWN:

+			case IT_PTM_NOTE_SLIDE_DOWN_RETRIG:

+				{

+					channel->toneslide_retrig = (entry->effect == IT_PTM_NOTE_SLIDE_DOWN_RETRIG);

+

+					if (channel->ptm_last_toneslide) {

+						channel->toneslide_tick = channel->last_toneslide_tick;

+

+						if (--channel->toneslide_tick == 0) {

+							channel->truenote += channel->toneslide;

+							if (channel->truenote >= 120) {

+								if (channel->toneslide < 0) channel->truenote = 0;

+								else channel->truenote = 119;

+							}

+							channel->note += channel->toneslide;

+							if (channel->note >= 120) {

+								if (channel->toneslide < 0) channel->note = 0;

+								else channel->note = 119;

+							}

+

+							if (channel->playing) {

+								if (channel->sample) channel->playing->note = channel->truenote;

+								else channel->playing->note = channel->note;

+								it_playing_reset_resamplers(channel->playing, 0);

+#ifdef END_RAMPING

+								channel->playing->declick_stage = 0;

+								channel->playing->declick_volume = 1.f / 256.f;

+#endif

+							}

+						}

+					}

+

+					channel->ptm_last_toneslide = 0;

+

+					channel->toneslide = -(entry->effectvalue & 15);

+					channel->ptm_toneslide = (entry->effectvalue & 0xF0) >> 4;

+					channel->toneslide_tick += channel->ptm_toneslide;

+				}

+				break;

+			case IT_PTM_NOTE_SLIDE_UP:

+			case IT_PTM_NOTE_SLIDE_UP_RETRIG:

+				{

+					channel->toneslide_retrig = (entry->effect == IT_PTM_NOTE_SLIDE_UP_RETRIG);

+

+					if (channel->ptm_last_toneslide) {

+						channel->toneslide_tick = channel->last_toneslide_tick;

+

+						if (--channel->toneslide_tick == 0) {

+							channel->truenote += channel->toneslide;

+							if (channel->truenote >= 120) {

+								if (channel->toneslide < 0) channel->truenote = 0;

+								else channel->truenote = 119;

+							}

+							channel->note += channel->toneslide;

+							if (channel->note >= 120) {

+								if (channel->toneslide < 0) channel->note = 0;

+								else channel->note = 119;

+							}

+

+							if (channel->playing) {

+								if (channel->sample) channel->playing->note = channel->truenote;

+								else channel->playing->note = channel->note;

+								it_playing_reset_resamplers(channel->playing, 0);

+#ifdef END_RAMPING

+								channel->playing->declick_stage = 0;

+								channel->playing->declick_volume = 1.f / 256.f;

+#endif

+							}

+						}

+					}

+

+					channel->ptm_last_toneslide = 0;

+

+					channel->toneslide = -(entry->effectvalue & 15);

+					channel->ptm_toneslide = (entry->effectvalue & 0xF0) >> 4;

+					channel->toneslide_tick += channel->ptm_toneslide;

+				}

+				break;

+		}

+	}

+

+	if (!(sigdata->flags & IT_WAS_AN_XM))

+		post_process_it_volpan(sigrenderer, entry);

+

+	return 0;

+}

+

+

+

+static int process_it_note_data(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry)

+{

+	DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata;

+	IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel];

+

+	// When tone portamento and instrument are specified:

+	// If Gxx is off:

+	//   - same sample, do nothing but portamento

+	//   - diff sample, retrigger all but keep current note+slide + do porta

+	//   - if instrument is invalid, nothing; if sample is invalid, cut

+	// If Gxx is on:

+	//   - same sample or new sample invalid, retrigger envelopes and initialise note value for portamento to 'seek' to

+	//   - diff sample/inst, start using new envelopes

+	// When tone portamento is specified alone, sample won't change.

+	// TODO: consider what happens with instrument alone after all this...

+

+	if (entry->mask & (IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT)) {

+		if (entry->mask & IT_ENTRY_INSTRUMENT)

+			channel->instrument = entry->instrument;

+		instrument_to_sample(sigdata, channel);

+		if (channel->note < 120) {

+			if ((sigdata->flags & IT_USE_INSTRUMENTS) && channel->sample == 0)

+				it_retrigger_note(sigrenderer, channel); /* Stop the note */ /*return 1;*/

+			if (entry->mask & IT_ENTRY_INSTRUMENT)

+				get_default_volpan(sigdata, channel);

+		} else

+			it_retrigger_note(sigrenderer, channel); /* Stop the note */

+	}

+

+	/** WARNING: This is not ideal, since channel->playing might not get allocated owing to lack of memory... */

+	if (((entry->mask & IT_ENTRY_VOLPAN) && entry->volpan >= 193 && entry->volpan <= 202) ||

+	    ((entry->mask & IT_ENTRY_EFFECT) && (entry->effect == IT_TONE_PORTAMENTO || entry->effect == IT_VOLSLIDE_TONEPORTA)))

+	{

+		if (channel->playing && (entry->mask & IT_ENTRY_INSTRUMENT)) {

+			if (sigdata->flags & IT_COMPATIBLE_GXX)

+				it_compatible_gxx_retrigger(sigdata, channel);

+			else if ((!(sigdata->flags & IT_USE_INSTRUMENTS) ||

+				(channel->instrument >= 1 && channel->instrument <= sigdata->n_instruments)) &&

+				channel->sample != channel->playing->sampnum)

+			{

+				unsigned char note = channel->playing->note;

+				int slide = channel->playing->slide;

+				it_retrigger_note(sigrenderer, channel);

+				if (channel->playing) {

+					channel->playing->note = note;

+					channel->playing->slide = slide;

+					// Should we be preserving sample_vibrato_time? depth?

+				}

+			}

+		}

+

+		if ((entry->mask & IT_ENTRY_VOLPAN) && entry->volpan >= 193 && entry->volpan <= 202) {

+			/* Tone Portamento in the volume column */

+			static const unsigned char slidetable[] = {0, 1, 4, 8, 16, 32, 64, 96, 128, 255};

+			unsigned char v = slidetable[entry->volpan - 193];

+			if (sigdata->flags & IT_COMPATIBLE_GXX) {

+				if (v == 0)

+					v = channel->lastG;

+				channel->lastG = v;

+			} else {

+				if (v == 0)

+					v = channel->lastEF;

+				channel->lastEF = v;

+			}

+			if ((entry->mask & IT_ENTRY_NOTE) || ((sigdata->flags & IT_COMPATIBLE_GXX) && (entry->mask & IT_ENTRY_INSTRUMENT))) {

+				if (channel->note < 120) {

+					if (channel->sample)

+						channel->destnote = channel->truenote;

+					else

+						channel->destnote = channel->note;

+				}

+			}

+			channel->toneporta = v << 4;

+		} else {

+			/* Tone Portamento in the effect column */

+			unsigned char v;

+			if (entry->effect == IT_TONE_PORTAMENTO)

+				v = entry->effectvalue;

+			else

+				v = 0;

+			if (sigdata->flags & IT_COMPATIBLE_GXX) {

+				if (v == 0)

+					v = channel->lastG;

+				channel->lastG = v;

+			} else {

+				if (v == 0 && !(sigdata->flags & IT_WAS_A_669))

+					v = channel->lastEF;

+				channel->lastEF = v;

+			}

+			if ((entry->mask & IT_ENTRY_NOTE) || ((sigdata->flags & IT_COMPATIBLE_GXX) && (entry->mask & IT_ENTRY_INSTRUMENT))) {

+				if (channel->note < 120) {

+					if (channel->sample)

+						channel->destnote = channel->truenote;

+					else

+						channel->destnote = channel->note;

+				}

+			}

+			channel->toneporta = v << 4;

+		}

+		if (channel->playing) goto skip_start_note;

+	}

+

+	if ((entry->mask & IT_ENTRY_NOTE) ||

+		((entry->mask & IT_ENTRY_INSTRUMENT) && (!channel->playing || entry->instrument != channel->playing->instnum)))

+	{

+		if (channel->note < 120) {

+			get_true_pan(sigdata, channel);

+			if ((entry->mask & IT_ENTRY_NOTE) || !(sigdata->flags & (IT_WAS_AN_S3M|IT_WAS_A_PTM)))

+				it_retrigger_note(sigrenderer, channel);

+		}

+	}

+

+	skip_start_note:

+

+	if (entry->mask & IT_ENTRY_VOLPAN) {

+		if (entry->volpan <= 64) {

+			/* Volume */

+			channel->volume = entry->volpan;

+		} else if (entry->volpan <= 74) {

+			/* Fine volume slide up */

+			unsigned char v = entry->volpan - 65;

+			if (v == 0)

+				v = channel->lastvolslide;

+			channel->lastvolslide = v;

+			/* = effect DxF where x == entry->volpan - 65 */

+			channel->volume += v;

+			if (channel->volume > 64) channel->volume = 64;

+		} else if (entry->volpan <= 84) {

+			/* Fine volume slide down */

+			unsigned char v = entry->volpan - 75;

+			if (v == 0)

+				v = channel->lastvolslide;

+			channel->lastvolslide = v;

+			/* = effect DFx where x == entry->volpan - 75 */

+			channel->volume -= v;

+			if (channel->volume > 64) channel->volume = 0;

+		} else if (entry->volpan < 128) {

+			/* Volume slide up */

+			/* Volume slide down */

+			/* Portamento down */

+			/* Portamento up */

+		} else if (entry->volpan <= 192) {

+			/* Pan */

+			channel->pan = entry->volpan - 128;

+			channel->truepan = channel->pan << IT_ENVELOPE_SHIFT;

+		}

+		/* else */

+		/* Tone Portamento */

+		/* Vibrato */

+	}

+	return 0;

+}

+

+

+

+static void retrigger_xm_envelopes(IT_PLAYING *playing)

+{

+	playing->volume_envelope.next_node = 0;

+	playing->volume_envelope.tick = -1;

+	playing->pan_envelope.next_node = 0;

+	playing->pan_envelope.tick = -1;

+	playing->fadeoutcount = 1024;

+}

+

+

+

+static void process_xm_note_data(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry)

+{

+	DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata;

+	IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel];

+	IT_PLAYING playing;

+

+	playing.sample = 0;

+

+	if (entry->mask & IT_ENTRY_INSTRUMENT) {

+		int oldsample = channel->sample;

+		int oldvolume = channel->volume;

+		channel->instrument = entry->instrument;

+		instrument_to_sample(sigdata, channel);

+		if (channel->playing &&

+			!((entry->mask & IT_ENTRY_NOTE) && entry->note >= 120) &&

+			!((entry->mask & IT_ENTRY_EFFECT) && entry->effect == IT_XM_KEY_OFF && entry->effectvalue == 0)) {

+			playing = *channel->playing;

+			if (!(sigdata->flags & IT_WAS_A_MOD)) {

+				/* Retrigger vol/pan envelopes if enabled, and cancel fadeout.

+				 * Also reset vol/pan to that of _original_ instrument.

+				 */

+				channel->playing->flags &= ~(IT_PLAYING_SUSTAINOFF | IT_PLAYING_FADING);

+				it_playing_update_resamplers(channel->playing);

+

+				channel->volume = channel->playing->sample->default_volume;

+				channel->truepan = 32 + channel->playing->sample->default_pan*64;

+

+				retrigger_xm_envelopes(channel->playing);

+			} else {

+				/* Switch if sample changed */

+				if (oldsample != channel->sample) {

+#ifdef RAMP_DOWN

+					int i;

+					for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+						if (!sigrenderer->playing[i]) {

+							channel->playing->declick_stage = 2;

+							sigrenderer->playing[i] = channel->playing;

+							channel->playing = NULL;

+							break;

+						}

+					}

+

+					if (!channel->sample) {

+						if (channel->playing)

+						{

+							free(channel->playing);

+							channel->playing = NULL;

+						}

+					} else {

+						if (!channel->playing) {

+							channel->playing = malloc(sizeof(*channel->playing));

+							if (!channel->playing) return;

+						}

+						*channel->playing = playing;

+						playing.sample = (IT_SAMPLE *)-1;

+						channel->playing->declick_stage = 0;

+						channel->playing->declick_volume = 1.f / 256.f;

+#else

+					if (!channel->sample) {

+						free(channel->playing);

+						channel->playing = NULL;

+					} else {

+#endif

+						channel->playing->sampnum = channel->sample;

+						channel->playing->sample = &sigdata->sample[channel->sample-1];

+						it_playing_reset_resamplers(channel->playing, 0);

+					}

+				}

+				get_default_volpan(sigdata, channel);

+			}

+#ifdef END_RAMPING

+			if (channel->volume && !oldvolume) {

+				channel->playing->declick_stage = 0;

+				channel->playing->declick_volume = 1.f / 256.f;

+			}

+#endif

+		}

+	}

+

+	if (!((entry->mask & IT_ENTRY_EFFECT) && entry->effect == IT_XM_KEY_OFF && entry->effectvalue == 0) &&

+		(entry->mask & IT_ENTRY_NOTE))

+	{

+		if (!(entry->mask & IT_ENTRY_INSTRUMENT))

+			instrument_to_sample(sigdata, channel);

+

+		if (channel->note >= 120)

+			xm_note_off(sigdata, channel);

+		else if (channel->sample == 0) {

+			/** If we get here, one of the following is the case:

+			 ** 1. The instrument has never been specified on this channel.

+			 ** 2. The specified instrument is invalid.

+			 ** 3. The instrument has no sample mapped to the selected note.

+			 ** What should happen?

+			 **

+			 ** Experimentation shows that any existing note stops and cannot

+			 ** be brought back. A subsequent instrument change fixes that.

+			 **/

+			if (channel->playing) {

+#ifdef RAMP_DOWN

+				int i;

+				if (playing.sample) *channel->playing = playing;

+				for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+					if (!sigrenderer->playing[i]) {

+						channel->playing->declick_stage = 2;

+						sigrenderer->playing[i] = channel->playing;

+						channel->playing = NULL;

+						break;

+					}

+				}

+				if (channel->playing) {

+					free(channel->playing);

+					channel->playing = NULL;

+				}

+#else

+				free(channel->playing);

+				channel->playing = NULL;

+#endif

+			}

+			return;

+		} else if (channel->playing && (entry->mask & IT_ENTRY_VOLPAN) && ((entry->volpan>>4) == 0xF)) {

+			/* Don't retrigger note; portamento in the volume column. */

+		} else if (channel->playing &&

+		           (entry->mask & IT_ENTRY_EFFECT) &&

+		           (entry->effect == IT_TONE_PORTAMENTO ||

+		            entry->effect == IT_VOLSLIDE_TONEPORTA)) {

+			/* Don't retrigger note; portamento in the effects column. */

+		} else {

+			channel->destnote = IT_NOTE_OFF;

+

+			if (!channel->playing) {

+				channel->playing = malloc(sizeof(*channel->playing));

+				if (!channel->playing)

+					return;

+				// Adding the following seems to do the trick for the case where a piece starts with an instrument alone and then some notes alone.

+				retrigger_xm_envelopes(channel->playing);

+			}

+#ifdef RAMP_DOWN

+			else if (playing.sample != (IT_SAMPLE *)-1) {

+				/* volume rampy stuff! move note to NNA */

+				int i;

+				IT_PLAYING * ptemp = malloc(sizeof(*channel->playing));

+				if (!ptemp) return;

+				if (playing.sample) *ptemp = playing;

+				else *ptemp = *channel->playing;

+				for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+					if (!sigrenderer->playing[i]) {

+						ptemp->declick_stage = 2;

+						ptemp->flags |= IT_PLAYING_SUSTAINOFF | IT_PLAYING_FADING;

+						sigrenderer->playing[i] = ptemp;

+						ptemp = NULL;

+						break;

+					}

+				}

+				if (ptemp) free(ptemp);

+			}

+#endif

+

+			channel->playing->flags = 0;

+			channel->playing->resampling_quality = sigrenderer->resampling_quality;

+			channel->playing->channel = channel;

+			channel->playing->sample = &sigdata->sample[channel->sample-1];

+			if (sigdata->flags & IT_USE_INSTRUMENTS)

+				channel->playing->instrument = &sigdata->instrument[channel->instrument-1];

+			else

+				channel->playing->instrument = NULL;

+			channel->playing->env_instrument = channel->playing->instrument;

+			channel->playing->sampnum = channel->sample;

+			channel->playing->instnum = channel->instrument;

+#ifdef END_RAMPING

+			channel->playing->declick_stage = 0;

+			channel->playing->declick_volume = 1.f / 256.f;

+#endif

+			channel->playing->channel_volume = channel->channelvolume;

+			channel->playing->ramp_volume[0] = 31337.0; /* special */

+			channel->playing->note = channel->truenote;

+			channel->playing->enabled_envelopes = 0;

+			channel->playing->volume_offset = 0;

+			channel->playing->panning_offset = 0;

+			//channel->playing->output = channel->output;

+			if (sigdata->flags & IT_USE_INSTRUMENTS) {

+				IT_PLAYING * playing = channel->playing;

+				IT_INSTRUMENT * instrument = playing->instrument;

+				if (instrument->volume_envelope.flags & IT_ENVELOPE_ON) playing->enabled_envelopes |= IT_ENV_VOLUME;

+				if (instrument->pan_envelope.flags & IT_ENVELOPE_ON) playing->enabled_envelopes |= IT_ENV_PANNING;

+				//if (instrument->output) playing->output = instrument->output;

+			}

+			channel->playing->filter_cutoff = 127;

+			channel->playing->filter_resonance = 0;

+			channel->playing->true_filter_cutoff = 127 << 8;

+			channel->playing->true_filter_resonance = 0;

+			channel->playing->vibrato_speed = 0;

+			channel->playing->vibrato_depth = 0;

+			channel->playing->vibrato_n = 0;

+			channel->playing->vibrato_time = 0;

+			channel->playing->vibrato_waveform = 0;

+			channel->playing->tremolo_speed = 0;

+			channel->playing->tremolo_depth = 0;

+			channel->playing->tremolo_time = 0;

+			channel->playing->tremolo_waveform = 0;

+			channel->playing->panbrello_speed = 0;

+			channel->playing->panbrello_depth = 0;

+			channel->playing->panbrello_time = 0;

+			channel->playing->panbrello_waveform = 0;

+			channel->playing->panbrello_random = 0;

+			channel->playing->sample_vibrato_time = 0;

+			channel->playing->sample_vibrato_waveform = channel->playing->sample->vibrato_waveform;

+			channel->playing->sample_vibrato_depth = 0;

+			channel->playing->slide = 0;

+			channel->playing->finetune = channel->playing->sample->finetune;

+			it_reset_filter_state(&channel->playing->filter_state[0]); // Are these

+			it_reset_filter_state(&channel->playing->filter_state[1]); // necessary?

+			it_playing_reset_resamplers(channel->playing, 0);

+

+			/** WARNING - is everything initialised? */

+		}

+	}

+

+	if (!((entry->mask & IT_ENTRY_EFFECT) && entry->effect == IT_XM_KEY_OFF && entry->effectvalue == 0) &&

+		!((entry->mask & IT_ENTRY_NOTE) && entry->note >= 120) &&

+		(entry->mask & (IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT)) == (IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT))

+	{

+		if (channel->playing) retrigger_xm_envelopes(channel->playing);

+		get_default_volpan(sigdata, channel);

+	}

+

+	if ((entry->mask & IT_ENTRY_VOLPAN) && ((entry->volpan>>4) == 0xF)) {

+		/* Tone Portamento */

+		unsigned char v = (entry->volpan & 15) << 4;

+		if (v == 0)

+			v = channel->lastG;

+		channel->lastG = v;

+		if (entry->mask & IT_ENTRY_NOTE)

+			if (channel->sample && channel->note < 120)

+				channel->destnote = channel->truenote;

+		channel->toneporta = v << 4;

+	} else if ((entry->mask & IT_ENTRY_EFFECT) &&

+	           (entry->effect == IT_TONE_PORTAMENTO ||

+	            entry->effect == IT_VOLSLIDE_TONEPORTA)) {

+		unsigned char v;

+		if (entry->effect == IT_TONE_PORTAMENTO)

+			v = entry->effectvalue;

+		else

+			v = 0;

+		if (v == 0)

+			v = channel->lastG;

+		channel->lastG = v;

+		if (entry->mask & IT_ENTRY_NOTE)

+			if (channel->sample && channel->note < 120)

+				channel->destnote = channel->truenote;

+		channel->toneporta = v << 4;

+	}

+

+	if (entry->mask & IT_ENTRY_VOLPAN) {

+		int effect = entry->volpan >> 4;

+		int value  = entry->volpan & 15;

+		switch (effect) {

+			case 0x6: /* Volume slide down */

+				channel->xm_volslide = -value;

+				break;

+			case 0x7: /* Volume slide up */

+				channel->xm_volslide = value;

+				break;

+			case 0x8: /* Fine volume slide down */

+				channel->volume -= value;

+				if (channel->volume > 64) channel->volume = 0;

+				break;

+			case 0x9: /* Fine volume slide up */

+				channel->volume += value;

+				if (channel->volume > 64) channel->volume = 64;

+				break;

+			case 0xA: /* Set vibrato speed */

+				if (value)

+					channel->lastHspeed = value;

+				if (channel->playing)

+					channel->playing->vibrato_speed = channel->lastHspeed;

+				break;

+			case 0xB: /* Vibrato */

+				if (value)

+					channel->lastHdepth = value << 2; /** WARNING: correct ? */

+				if (channel->playing) {

+					channel->playing->vibrato_depth = channel->lastHdepth;

+					channel->playing->vibrato_speed = channel->lastHspeed;

+					channel->playing->vibrato_n++;

+				}

+				break;

+			case 0xC: /* Set panning */

+				channel->truepan = 32 + value*(17*64);

+				break;

+			case 0xD: /* Pan slide left */

+				/* -128 is a special case for emulating a 'feature' in FT2.

+				 * As soon as effects are processed, it goes hard left.

+				 */

+				channel->panslide = value ? -value : -128;

+				break;

+			case 0xE: /* Pan slide Right */

+				channel->panslide = value;

+				break;

+			case 0xF: /* Tone porta */

+				break;

+			default:  /* Volume */

+				channel->volume = entry->volpan - 0x10;

+				break;

+		}

+	}

+}

+

+

+

+/* This function assumes !IT_IS_END_ROW(entry). */

+static int process_note_data(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry, int ignore_cxx)

+{

+	DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata;

+

+	if (sigdata->flags & IT_WAS_AN_XM)

+		process_xm_note_data(sigrenderer, entry);

+	else

+		if (process_it_note_data(sigrenderer, entry)) return 0;

+

+	return process_effects(sigrenderer, entry, ignore_cxx);

+}

+

+

+

+static int process_entry(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry, int ignore_cxx)

+{

+	IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel];

+

+	if (entry->mask & IT_ENTRY_NOTE)

+		channel->note = entry->note;

+

+	if ((entry->mask & (IT_ENTRY_NOTE|IT_ENTRY_EFFECT)) && (sigrenderer->sigdata->flags & IT_WAS_A_669)) {

+		reset_channel_effects(channel);

+		// XXX unknown

+		if (channel->playing) channel->playing->finetune = 0;

+	}

+

+	if ((entry->mask & IT_ENTRY_EFFECT) && entry->effect == IT_S) {

+		/* channel->lastS was set in update_pattern_variables(). */

+		unsigned char effectvalue = channel->lastS;

+		if (effectvalue >> 4 == IT_S_NOTE_DELAY) {

+			channel->note_delay_count = effectvalue & 15;

+			if (channel->note_delay_count == 0)

+				channel->note_delay_count = 1;

+			channel->note_delay_entry = entry;

+			return 0;

+		}

+	}

+

+	return process_note_data(sigrenderer, entry, ignore_cxx);

+}

+

+

+

+static void update_tick_counts(DUMB_IT_SIGRENDERER *sigrenderer)

+{

+	int i;

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+		IT_CHANNEL *channel = &sigrenderer->channel[i];

+

+		if (channel->key_off_count) {

+			channel->key_off_count--;

+			if (channel->key_off_count == 0)

+				xm_note_off(sigrenderer->sigdata, channel);

+		} else if (channel->note_cut_count) {

+			channel->note_cut_count--;

+			if (channel->note_cut_count == 0) {

+				if (sigrenderer->sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_PTM))

+					channel->volume = 0;

+				else if (channel->playing) {

+#ifdef RAMP_DOWN

+					int i;

+					for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+						if (!sigrenderer->playing[i]) {

+							channel->playing->declick_stage = 2;

+							sigrenderer->playing[i] = channel->playing;

+							channel->playing = NULL;

+							break;

+						}

+					}

+					if (channel->playing) {

+						free(channel->playing);

+						channel->playing = NULL;

+					}

+#else

+					free(channel->playing);

+					channel->playing = NULL;

+#endif

+				}

+			}

+		} else if (channel->note_delay_count) {

+			channel->note_delay_count--;

+			if (channel->note_delay_count == 0)

+				process_note_data(sigrenderer, channel->note_delay_entry, 0);

+					/* Don't bother checking the return value; if the note

+					 * was delayed, there can't have been a speed=0.

+					 */

+		}

+	}

+}

+

+

+

+static int envelope_get_y(IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe)

+{

+#if 1

+	(void)envelope; //TODO: remove the parameter

+	return pe->value;

+#else

+	int ys, ye;

+	int ts, te;

+	int t;

+

+	if (pe->next_node <= 0)

+		return envelope->node_y[0] << IT_ENVELOPE_SHIFT;

+

+	if (pe->next_node >= envelope->n_nodes)

+		return envelope->node_y[envelope->n_nodes-1] << IT_ENVELOPE_SHIFT;

+

+	ys = envelope->node_y[pe->next_node-1] << IT_ENVELOPE_SHIFT;

+	ts = envelope->node_t[pe->next_node-1];

+	te = envelope->node_t[pe->next_node];

+

+	if (ts == te)

+		return ys;

+

+	ye = envelope->node_y[pe->next_node] << IT_ENVELOPE_SHIFT;

+

+	t = pe->tick;

+

+	return ys + (ye - ys) * (t - ts) / (te - ts);

+#endif

+}

+

+

+

+#if 0

+static int it_envelope_end(IT_PLAYING *playing, IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe)

+{

+	if (pe->next_node >= envelope->n_nodes)

+		return 1;

+

+	if (pe->tick < envelope->node_t[pe->next_node]) return 0;

+

+	if ((envelope->flags & IT_ENVELOPE_LOOP_ON) &&

+	    envelope->loop_end >= pe->next_node &&

+	    envelope->node_t[envelope->loop_end] <= pe->tick) return 0;

+

+	if ((envelope->flags & IT_ENVELOPE_SUSTAIN_LOOP) &&

+	    !(playing->flags & IT_PLAYING_SUSTAINOFF) &&

+	    envelope->sus_loop_end >= pe->next_node &&

+	    envelope->node_t[envelope->sus_loop_end] <= pe->tick) return 0;

+

+	if (envelope->node_t[envelope->n_nodes-1] <= pe->tick) return 1;

+

+	return 0;

+}

+#endif

+

+

+

+/* Returns 1 when fading should be initiated for a volume envelope. */

+static int update_it_envelope(IT_PLAYING *playing, IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe, int flags)

+{

+	if (!(playing->enabled_envelopes & flags))

+		return 0;

+

+	ASSERT(envelope->n_nodes > 0);

+

+	if (pe->next_node <= 0)

+		pe->value = envelope->node_y[0] << IT_ENVELOPE_SHIFT;

+	else if (pe->next_node >= envelope->n_nodes) {

+		pe->value = envelope->node_y[envelope->n_nodes-1] << IT_ENVELOPE_SHIFT;

+		return 1;

+	} else {

+		int ys = envelope->node_y[pe->next_node-1] << IT_ENVELOPE_SHIFT;

+		int ts = envelope->node_t[pe->next_node-1];

+		int te = envelope->node_t[pe->next_node];

+

+		if (ts == te)

+			pe->value = ys;

+		else {

+			int ye = envelope->node_y[pe->next_node] << IT_ENVELOPE_SHIFT;

+			int t = pe->tick;

+

+			pe->value = ys + (ye - ys) * (t - ts) / (te - ts);

+		}

+	}

+

+	pe->tick++;

+	while (pe->tick >= envelope->node_t[pe->next_node]) {

+		pe->next_node++;

+		if ((envelope->flags & IT_ENVELOPE_SUSTAIN_LOOP) && !(playing->flags & IT_PLAYING_SUSTAINOFF)) {

+			if (pe->next_node > envelope->sus_loop_end) {

+				pe->next_node = envelope->sus_loop_start;

+				ASSERT(pe->next_node < envelope->n_nodes);

+				pe->tick = envelope->node_t[envelope->sus_loop_start];

+				return 0;

+			}

+		} else if (envelope->flags & IT_ENVELOPE_LOOP_ON) {

+			if (pe->next_node > envelope->loop_end) {

+				pe->next_node = envelope->loop_start;

+				ASSERT(pe->next_node < envelope->n_nodes);

+				pe->tick = envelope->node_t[envelope->loop_start];

+				return 0;

+			}

+		}

+		if (pe->next_node >= envelope->n_nodes)

+			return 0;

+	}

+	return 0;

+}

+

+

+

+static void update_it_envelopes(IT_PLAYING *playing)

+{

+	IT_ENVELOPE *envelope = &playing->env_instrument->volume_envelope;

+	IT_PLAYING_ENVELOPE *pe = &playing->volume_envelope;

+

+	if (update_it_envelope(playing, envelope, pe, IT_ENV_VOLUME)) {

+		playing->flags |= IT_PLAYING_FADING;

+		if (pe->value == 0)

+			playing->flags |= IT_PLAYING_DEAD;

+	}

+

+	update_it_envelope(playing, &playing->env_instrument->pan_envelope, &playing->pan_envelope, IT_ENV_PANNING);

+	update_it_envelope(playing, &playing->env_instrument->pitch_envelope, &playing->pitch_envelope, IT_ENV_PITCH);

+}

+

+

+

+static int xm_envelope_is_sustaining(IT_PLAYING *playing, IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe)

+{

+	if ((envelope->flags & IT_ENVELOPE_SUSTAIN_LOOP) && !(playing->flags & IT_PLAYING_SUSTAINOFF))

+		if (envelope->sus_loop_start < envelope->n_nodes)

+			if (pe->tick == envelope->node_t[envelope->sus_loop_start])

+				return 1;

+	return 0;

+}

+

+

+

+static void update_xm_envelope(IT_PLAYING *playing, IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe)

+{

+	if (!(envelope->flags & IT_ENVELOPE_ON))

+		return;

+

+	if (xm_envelope_is_sustaining(playing, envelope, pe))

+		return;

+

+	if (pe->tick >= envelope->node_t[envelope->n_nodes-1])

+		return;

+

+	pe->tick++;

+

+	/* pe->next_node must be kept up to date for envelope_get_y(). */

+	while (pe->tick > envelope->node_t[pe->next_node])

+		pe->next_node++;

+

+	if ((envelope->flags & IT_ENVELOPE_LOOP_ON) && envelope->loop_end < envelope->n_nodes) {

+		if (pe->tick == envelope->node_t[envelope->loop_end]) {

+			pe->next_node = MID(0, envelope->loop_start, envelope->n_nodes - 1);

+			pe->tick = envelope->node_t[pe->next_node];

+		}

+	}

+

+	xm_envelope_calculate_value(envelope, pe);

+}

+

+

+

+static void update_xm_envelopes(IT_PLAYING *playing)

+{

+	update_xm_envelope(playing, &playing->env_instrument->volume_envelope, &playing->volume_envelope);

+	update_xm_envelope(playing, &playing->env_instrument->pan_envelope, &playing->pan_envelope);

+}

+

+

+

+static void update_fadeout(DUMB_IT_SIGDATA *sigdata, IT_PLAYING *playing)

+{

+	if (playing->flags & IT_PLAYING_FADING) {

+		playing->fadeoutcount -= playing->env_instrument->fadeout;

+		if (playing->fadeoutcount <= 0) {

+			playing->fadeoutcount = 0;

+			if (!(sigdata->flags & IT_WAS_AN_XM))

+				playing->flags |= IT_PLAYING_DEAD;

+		}

+	}

+}

+

+static int apply_pan_envelope(IT_PLAYING *playing);

+static float calculate_volume(DUMB_IT_SIGRENDERER *sigrenderer, IT_PLAYING *playing, float volume);

+

+static void playing_volume_setup(DUMB_IT_SIGRENDERER * sigrenderer, IT_PLAYING * playing, float invt2g)

+{

+	DUMB_IT_SIGDATA * sigdata = sigrenderer->sigdata;

+	int pan;

+	float volume, vol, span;

+

+	if ((sigrenderer->n_channels == 2) && (sigdata->flags & IT_STEREO)) {

+		pan = apply_pan_envelope(playing);

+		if ((sigdata->flags & IT_WAS_AN_S3M) && IT_IS_SURROUND_SHIFTED(pan)) {

+			volume = -1.0f * (float)(pan) * (1.0f / (64.0f * 256.0f));

+		} else {

+			volume = 1.0f;

+		}

+		span = (pan - (32<<8)) * sigdata->pan_separation * (1.0f / ((32<<8) * 128));

+		vol = volume;

+		if (!IT_IS_SURROUND_SHIFTED(pan)) vol *= 1.0f - span;

+		playing->float_volume[0] = vol;

+		vol = -vol;

+		if (!IT_IS_SURROUND_SHIFTED(pan)) vol += 2.0f * volume;

+		playing->float_volume[1] = vol;

+	} else {

+		if ((sigdata->flags & IT_STEREO) && (playing->sample->flags & IT_SAMPLE_STEREO)) {

+			pan = apply_pan_envelope(playing);

+			span = (pan - (32<<8)) * sigdata->pan_separation * (1.0f / ((32<<8) * 128));

+			vol = 0.5f;

+			if (!IT_IS_SURROUND_SHIFTED(pan)) vol *= 1.0f - span;

+			playing->float_volume[0] = vol;

+			if (!IT_IS_SURROUND_SHIFTED(pan)) vol = 2.0f - vol;

+			playing->float_volume[1] = vol;

+		} else {

+			playing->float_volume[0] = 1.0f;

+			playing->float_volume[1] = 1.0f;

+		}

+	}

+

+	vol = calculate_volume(sigrenderer, playing, 1.0f);

+	playing->float_volume[0] *= vol;

+	playing->float_volume[1] *= vol;

+

+	if (!sigrenderer->ramp_style || playing->ramp_volume[0] == 31337.0) {

+		playing->ramp_volume[0] = playing->float_volume[0];

+		playing->ramp_volume[1] = playing->float_volume[1];

+		playing->ramp_delta[0] = 0;

+		playing->ramp_delta[1] = 0;

+	} else {

+		playing->ramp_delta[0] = invt2g * (playing->float_volume[0] - playing->ramp_volume[0]);

+		playing->ramp_delta[1] = invt2g * (playing->float_volume[1] - playing->ramp_volume[1]);

+	}

+}

+

+static void process_playing(DUMB_IT_SIGRENDERER *sigrenderer, IT_PLAYING *playing, float invt2g)

+{

+	DUMB_IT_SIGDATA * sigdata = sigrenderer->sigdata;

+

+	if (playing->instrument) {

+		if (sigdata->flags & IT_WAS_AN_XM)

+			update_xm_envelopes(playing);

+		else

+			update_it_envelopes(playing);

+		update_fadeout(sigdata, playing);

+	}

+

+	playing_volume_setup(sigrenderer, playing, invt2g);

+

+	if (sigdata->flags & IT_WAS_AN_XM) {

+		/* 'depth' is used to store the tick number for XM files. */

+		if (playing->sample_vibrato_depth < playing->sample->vibrato_rate)

+			playing->sample_vibrato_depth++;

+	} else {

+		playing->sample_vibrato_depth += playing->sample->vibrato_rate;

+		if (playing->sample_vibrato_depth > playing->sample->vibrato_depth << 8)

+			playing->sample_vibrato_depth = playing->sample->vibrato_depth << 8;

+	}

+

+	playing->sample_vibrato_time += playing->sample->vibrato_speed;

+}

+

+//static float log2(float x) {return (float)log(x)/(float)log(2.0f);}

+#ifndef __linux__

+static inline float log2(float x) {return (float)log(x)/(float)log(2.0f);}

+#endif

+

+static int delta_to_note(float delta, int base)

+{

+	float note;

+	note = log2(delta * 65536.f / (float)base)*12.0f+60.5f;

+	if (note > 119) note = 119;

+	else if (note < 0) note = 0;

+	return (int)note;

+}

+

+// Period table for Protracker octaves 0-5:

+static const unsigned short ProTrackerPeriodTable[6*12] =

+{

+	1712,1616,1524,1440,1356,1280,1208,1140,1076,1016,960,907,

+	856,808,762,720,678,640,604,570,538,508,480,453,

+	428,404,381,360,339,320,302,285,269,254,240,226,

+	214,202,190,180,170,160,151,143,135,127,120,113,

+	107,101,95,90,85,80,75,71,67,63,60,56,

+	53,50,47,45,42,40,37,35,33,31,30,28

+};

+

+

+static const unsigned short ProTrackerTunedPeriods[16*12] = 

+{

+	1712,1616,1524,1440,1356,1280,1208,1140,1076,1016,960,907,

+	1700,1604,1514,1430,1348,1274,1202,1134,1070,1010,954,900,

+	1688,1592,1504,1418,1340,1264,1194,1126,1064,1004,948,894,

+	1676,1582,1492,1408,1330,1256,1184,1118,1056,996,940,888,

+	1664,1570,1482,1398,1320,1246,1176,1110,1048,990,934,882,

+	1652,1558,1472,1388,1310,1238,1168,1102,1040,982,926,874,

+	1640,1548,1460,1378,1302,1228,1160,1094,1032,974,920,868,

+	1628,1536,1450,1368,1292,1220,1150,1086,1026,968,914,862,

+	1814,1712,1616,1524,1440,1356,1280,1208,1140,1076,1016,960,

+	1800,1700,1604,1514,1430,1350,1272,1202,1134,1070,1010,954,

+	1788,1688,1592,1504,1418,1340,1264,1194,1126,1064,1004,948,

+	1774,1676,1582,1492,1408,1330,1256,1184,1118,1056,996,940,

+	1762,1664,1570,1482,1398,1320,1246,1176,1110,1048,988,934,

+	1750,1652,1558,1472,1388,1310,1238,1168,1102,1040,982,926,

+	1736,1640,1548,1460,1378,1302,1228,1160,1094,1032,974,920,

+	1724,1628,1536,1450,1368,1292,1220,1150,1086,1026,968,914 

+};

+

+static void process_all_playing(DUMB_IT_SIGRENDERER *sigrenderer)

+{

+	DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata;

+	int i;

+

+	float invt2g = 1.0f / ((float)TICK_TIME_DIVIDEND / (float)sigrenderer->tempo);

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+		IT_CHANNEL *channel = &sigrenderer->channel[i];

+		IT_PLAYING *playing = channel->playing;

+

+		if (playing) {

+			int vibrato_shift;

+			switch (playing->vibrato_waveform)

+			{

+			default:

+				vibrato_shift = it_sine[playing->vibrato_time];

+				break;

+			case 1:

+				vibrato_shift = it_sawtooth[playing->vibrato_time];

+				break;

+			case 2:

+				vibrato_shift = it_squarewave[playing->vibrato_time];

+				break;

+			case 3:

+				vibrato_shift = (rand() % 129) - 64;

+				break;

+			case 4:

+				vibrato_shift = it_xm_squarewave[playing->vibrato_time];

+				break;

+			case 5:

+				vibrato_shift = it_xm_ramp[playing->vibrato_time];

+				break;

+			case 6:

+				vibrato_shift = it_xm_ramp[255-playing->vibrato_time];

+				break;

+			}

+			vibrato_shift *= playing->vibrato_n;

+			vibrato_shift *= playing->vibrato_depth;

+			vibrato_shift >>= 4;

+

+			if (sigdata->flags & IT_OLD_EFFECTS)

+				vibrato_shift = -vibrato_shift;

+

+			playing->volume = channel->volume;

+			playing->pan = channel->truepan;

+

+			if (playing->volume_offset) {

+				playing->volume += (playing->volume_offset * playing->volume) >> 7;

+				if (playing->volume > 64) {

+					if (playing->volume_offset < 0) playing->volume = 0;

+					else playing->volume = 64;

+				}

+			}

+

+			if (playing->panning_offset && !IT_IS_SURROUND_SHIFTED(playing->pan)) {

+				playing->pan += playing->panning_offset << IT_ENVELOPE_SHIFT;

+				if (playing->pan > 64 << IT_ENVELOPE_SHIFT) {

+					if (playing->panning_offset < 0) playing->pan = 0;

+					else playing->pan = 64 << IT_ENVELOPE_SHIFT;

+				}

+			}

+

+			if (sigdata->flags & IT_LINEAR_SLIDES) {

+				int currpitch = ((playing->note - 60) << 8) + playing->slide

+				                                            + vibrato_shift

+															+ playing->finetune;

+

+				/* We add a feature here, which is that of keeping the pitch

+				 * within range. Otherwise it crashes. Trust me. It happened.

+				 * The limit 32768 gives almost 11 octaves either way.

+				 */

+				if (currpitch < -32768)

+					currpitch = -32768;

+				else if (currpitch > 32767)

+					currpitch = 32767;

+

+				playing->delta = (float)pow(DUMB_PITCH_BASE, currpitch);

+				playing->delta *= playing->sample->C5_speed * (1.f / 65536.0f);

+			} else {

+				int slide = playing->slide + vibrato_shift;

+

+				playing->delta = (float)pow(DUMB_PITCH_BASE, ((60 - playing->note) << 8) - playing->finetune );

+				/* playing->delta is 1.0 for C-5, 0.5 for C-6, etc. */

+

+				playing->delta *= 1.0f / playing->sample->C5_speed;

+

+				playing->delta -= slide / AMIGA_DIVISOR;

+

+				if (playing->delta < (1.0f / 65536.0f) / 32768.0f) {

+					// Should XM notes die if Amiga slides go out of range?

+					playing->flags |= IT_PLAYING_DEAD;

+					playing->delta = 1. / 32768.;

+					continue;

+				}

+

+				playing->delta = (1.0f / 65536.0f) / playing->delta;

+			}

+

+			if (playing->channel->glissando && playing->channel->toneporta && playing->channel->destnote < 120) {

+				playing->delta = (float)pow(DUMB_SEMITONE_BASE, delta_to_note(playing->delta, playing->sample->C5_speed) - 60)

+					* playing->sample->C5_speed * (1.f / 65536.f);

+			}

+

+			/*

+			if ( channel->arpeggio ) { // another FT2 bug...

+				if ((sigdata->flags & (IT_LINEAR_SLIDES|IT_WAS_AN_XM|IT_WAS_A_MOD)) == (IT_WAS_AN_XM|IT_LINEAR_SLIDES) &&

+					playing->flags & IT_PLAYING_SUSTAINOFF)

+				{

+					if ( channel->arpeggio > 0xFF )

+						playing->delta = playing->sample->C5_speed * (1.f / 65536.f);

+				}

+				else*/ playing->delta *= (float)pow(DUMB_SEMITONE_BASE, channel->arpeggio >> 8);/*

+			}*/

+

+			playing->filter_cutoff = channel->filter_cutoff;

+			playing->filter_resonance = channel->filter_resonance;

+		}

+	}

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+		if (sigrenderer->channel[i].playing) {

+			process_playing(sigrenderer, sigrenderer->channel[i].playing, invt2g);

+			if (!(sigdata->flags & IT_WAS_AN_XM)) {

+				//if ((sigrenderer->channel[i].playing->flags & (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) == (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) {

+				// This change was made so Gxx would work correctly when a note faded out or whatever. Let's hope nothing else was broken by it.

+				if (sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD) {

+					free(sigrenderer->channel[i].playing);

+					sigrenderer->channel[i].playing = NULL;

+				}

+			}

+		}

+	}

+

+	for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+		if (sigrenderer->playing[i]) {

+			process_playing(sigrenderer, sigrenderer->playing[i], invt2g);

+			if (sigrenderer->playing[i]->flags & IT_PLAYING_DEAD) {

+				free(sigrenderer->playing[i]);

+				sigrenderer->playing[i] = NULL;

+			}

+		}

+	}

+}

+

+

+

+static int process_tick(DUMB_IT_SIGRENDERER *sigrenderer)

+{

+	DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata;

+

+	// Set note vol/freq to vol/freq set for each channel

+

+	if (sigrenderer->speed && --sigrenderer->tick == 0) {

+		reset_tick_counts(sigrenderer);

+		sigrenderer->tick = sigrenderer->speed;

+		sigrenderer->rowcount--;

+		if (sigrenderer->rowcount == 0) {

+			sigrenderer->rowcount = 1;

+

+#ifdef BIT_ARRAY_BULLSHIT

+			if (sigrenderer->n_rows)

+			{

+#if 1

+				/*

+				if (bit_array_test(sigrenderer->played, sigrenderer->order * 256 + sigrenderer->row))

+				{

+					if (sigrenderer->callbacks->loop) {

+						if ((*sigrenderer->callbacks->loop)(sigrenderer->callbacks->loop_data))

+							return 1;

+						bit_array_reset(sigrenderer->played);

+						if (sigrenderer->speed == 0)

+							goto speed0; /* I love goto *

+					}

+				}

+				*/

+#endif

+				bit_array_set(sigrenderer->played, sigrenderer->order * 256 + sigrenderer->row);

+				{

+					int n;

+					for (n = 0; n < DUMB_IT_N_CHANNELS; n++)

+					{

+						IT_CHANNEL * channel = &sigrenderer->channel[n];

+						if (channel->played_patjump)

+						{

+							if (channel->played_patjump_order == sigrenderer->order)

+							{

+								bit_array_set(channel->played_patjump, sigrenderer->row);

+							}

+							/*

+							else if ((channel->played_patjump_order & 0x7FFF) == sigrenderer->order)

+							{

+								channel->played_patjump_order |= 0x4000;

+							}

+							else if ((channel->played_patjump_order & 0x3FFF) == sigrenderer->order)

+							{

+								if ((sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD)) == IT_WAS_AN_XM)

+								{

+									/* joy, was XM, pattern loop bug triggered break to row in same order 

+									bit_array_mask(sigrenderer->played, channel->played_patjump, sigrenderer->order * 256);

+								}

+								bit_array_destroy(channel->played_patjump);

+								channel->played_patjump = 0;

+								channel->played_patjump_order = 0xFFFE;

+							}

+							*/

+							else

+							{

+								bit_array_destroy(channel->played_patjump);

+								channel->played_patjump = 0;

+								channel->played_patjump_order = 0xFFFE;

+							}

+						}

+					}

+				}

+			}

+#endif

+

+			sigrenderer->processrow++;

+

+			if (sigrenderer->processrow >= sigrenderer->n_rows) {

+				IT_PATTERN *pattern;

+				int n;

+				int processorder = sigrenderer->processorder;

+

+				if ((sigrenderer->processrow|0xC00) == 0xFFFE + 1) { /* It was incremented above! */

+					sigrenderer->processrow = sigrenderer->breakrow;

+					sigrenderer->breakrow = 0;

+					for (n = 0; n < DUMB_IT_N_CHANNELS; n++) sigrenderer->channel[n].pat_loop_end_row = 0;

+				} else

+					sigrenderer->processrow = sigrenderer->breakrow;

+

+				if (sigrenderer->processorder == 0xFFFF)

+					sigrenderer->processorder = sigrenderer->order - 1;

+

+				for (;;) {

+					sigrenderer->processorder++;

+

+					if (sigrenderer->processorder >= sigdata->n_orders) {

+						sigrenderer->processorder = sigrenderer->restart_position;

+						if (sigrenderer->processorder >= sigdata->n_orders) {

+							/* Restarting beyond end. We'll loop for now. */

+							sigrenderer->processorder = -1;

+							continue;

+						}

+					}

+

+					n = sigdata->order[sigrenderer->processorder];

+

+					if (n < sigdata->n_patterns)

+						break;

+

+#ifdef INVALID_ORDERS_END_SONG

+					if (n != IT_ORDER_SKIP)

+#else

+					if (n == IT_ORDER_END)

+#endif

+					{

+						sigrenderer->processorder = sigrenderer->restart_position - 1;

+					}

+				}

+

+				pattern = &sigdata->pattern[n];

+

+				n = sigrenderer->n_rows;

+				sigrenderer->n_rows = pattern->n_rows;

+

+				if (sigrenderer->processrow >= sigrenderer->n_rows)

+					sigrenderer->processrow = 0;

+

+/** WARNING - everything pertaining to a new pattern initialised? */

+

+				sigrenderer->entry = sigrenderer->entry_start = pattern->entry;

+				sigrenderer->entry_end = sigrenderer->entry + pattern->n_entries;

+

+				/* If n_rows was 0, we're only just starting. Don't do anything weird here. */

+				/* added: process row check, for break to row spooniness */

+				if (n && (processorder == 0xFFFF ? sigrenderer->order > sigrenderer->processorder : sigrenderer->order >= sigrenderer->processorder)

+#ifdef BIT_ARRAY_BULLSHIT

+					&& bit_array_test(sigrenderer->played, sigrenderer->processorder * 256 + sigrenderer->processrow)

+#endif

+					) {

+					if (sigrenderer->callbacks->loop) {

+						if ((*sigrenderer->callbacks->loop)(sigrenderer->callbacks->loop_data))

+							return 1;

+#ifdef BIT_ARRAY_BULLSHIT

+						bit_array_reset(sigrenderer->played);

+#endif

+						if (sigrenderer->speed == 0)

+							goto speed0; /* I love goto */

+					}

+				}

+				sigrenderer->order = sigrenderer->processorder;

+

+				n = sigrenderer->processrow;

+				while (n) {

+					while (sigrenderer->entry < sigrenderer->entry_end) {

+						if (IT_IS_END_ROW(sigrenderer->entry)) {

+							sigrenderer->entry++;

+							break;

+						}

+						sigrenderer->entry++;

+					}

+					n--;

+				}

+				sigrenderer->row = sigrenderer->processrow;

+			} else {

+				if (sigrenderer->entry) {

+					while (sigrenderer->entry < sigrenderer->entry_end) {

+						if (IT_IS_END_ROW(sigrenderer->entry)) {

+							sigrenderer->entry++;

+							break;

+						}

+						sigrenderer->entry++;

+					}

+					sigrenderer->row++;

+				} else {

+#ifdef BIT_ARRAY_BULLSHIT

+					bit_array_clear(sigrenderer->played, sigrenderer->order * 256);

+#endif

+					sigrenderer->entry = sigrenderer->entry_start;

+					sigrenderer->row = 0;

+				}

+			}

+

+			if (!(sigdata->flags & IT_WAS_A_669))

+				reset_effects(sigrenderer);

+

+			{

+				IT_ENTRY *entry = sigrenderer->entry;

+				int ignore_cxx = 0;

+

+				while (entry < sigrenderer->entry_end && !IT_IS_END_ROW(entry))

+					ignore_cxx |= update_pattern_variables(sigrenderer, entry++);

+

+				entry = sigrenderer->entry;

+

+				while (entry < sigrenderer->entry_end && !IT_IS_END_ROW(entry))

+					if (process_entry(sigrenderer, entry++, sigdata->flags & IT_WAS_AN_XM ? 0 : ignore_cxx))

+						return 1;

+			}

+

+			if (!(sigdata->flags & IT_OLD_EFFECTS))

+				update_smooth_effects(sigrenderer);

+		} else {

+			{

+				IT_ENTRY *entry = sigrenderer->entry;

+

+				while (entry < sigrenderer->entry_end && !IT_IS_END_ROW(entry)) {

+					if (entry->mask & IT_ENTRY_EFFECT && entry->effect != IT_SET_SAMPLE_OFFSET)

+						process_effects(sigrenderer, entry, 0);

+							/* Don't bother checking the return value; if there

+							 * was a pattern delay, there can't be a speed=0.

+							 */

+					entry++;

+				}

+			}

+

+			update_effects(sigrenderer);

+		}

+	} else {

+		speed0:

+		update_effects(sigrenderer);

+		update_tick_counts(sigrenderer);

+	}

+

+	if (sigrenderer->globalvolume == 0) {

+		if (sigrenderer->callbacks->global_volume_zero) {

+			LONG_LONG t = sigrenderer->gvz_sub_time + ((LONG_LONG)TICK_TIME_DIVIDEND << 16) / sigrenderer->tempo;

+			sigrenderer->gvz_time += (int)(t >> 16);

+			sigrenderer->gvz_sub_time = (int)t & 65535;

+			if (sigrenderer->gvz_time >= 65536 * 12) {

+				if ((*sigrenderer->callbacks->global_volume_zero)(sigrenderer->callbacks->global_volume_zero_data))

+					return 1;

+			}

+		}

+	} else {

+		if (sigrenderer->callbacks->global_volume_zero) {

+			sigrenderer->gvz_time = 0;

+			sigrenderer->gvz_sub_time = 0;

+		}

+	}

+

+	process_all_playing(sigrenderer);

+

+	{

+		LONG_LONG t = sigrenderer->sub_time_left + ((LONG_LONG)TICK_TIME_DIVIDEND << 16) / sigrenderer->tempo;

+		sigrenderer->time_left += (int)(t >> 16);

+		sigrenderer->sub_time_left = (int)t & 65535;

+	}

+

+	return 0;

+}

+

+

+

+int dumb_it_max_to_mix = 64;

+

+static const int aiMODVol[] =

+{

+	0,

+		16, 24, 32, 48, 64, 80, 96, 112,

+		128, 144, 160, 176, 192, 208, 224, 240,

+		256, 272, 288, 304, 320, 336, 352, 368,

+		384, 400, 416, 432, 448, 464, 480, 496,

+		529, 545, 561, 577, 593, 609, 625, 641,

+		657, 673, 689, 705, 721, 737, 753, 769,

+		785, 801, 817, 833, 849, 865, 881, 897,

+		913, 929, 945, 961, 977, 993, 1009, 1024

+};

+

+static const int aiPTMVolScaled[] =

+{

+	0,

+		31, 54, 73, 96, 111, 130, 153, 172,

+		191, 206, 222, 237, 252, 275, 298, 317,

+		336, 351, 370, 386, 401, 416, 428, 443,

+		454, 466, 477, 489, 512, 531, 553, 573,

+		592, 611, 626, 645, 660, 679, 695, 710,

+		725, 740, 756, 767, 782, 798, 809, 820,

+		836, 847, 859, 870, 881, 897, 908, 916,

+		927, 939, 950, 962, 969, 983, 1005, 1024

+};

+

+static float calculate_volume(DUMB_IT_SIGRENDERER *sigrenderer, IT_PLAYING *playing, float volume)

+{

+	if (volume != 0) {

+		int vol;

+

+		if (playing->channel->flags & IT_CHANNEL_MUTED)

+			return 0;

+

+		if ((playing->channel->tremor_time & 192) == 128)

+			return 0;

+

+		switch (playing->tremolo_waveform)

+		{

+		default:

+			vol = it_sine[playing->tremolo_time];

+			break;

+		case 1:

+			vol = it_sawtooth[playing->tremolo_time];

+			break;

+		case 2:

+			vol = it_squarewave[playing->tremolo_time];

+			break;

+		case 3:

+			vol = (rand() % 129) - 64;

+			break;

+		case 4:

+			vol = it_xm_squarewave[playing->vibrato_time];

+			break;

+		case 5:

+			vol = it_xm_ramp[playing->vibrato_time];

+			break;

+		case 6:

+			vol = it_xm_ramp[255-playing->vibrato_time];

+			break;

+		}

+		vol *= playing->tremolo_depth;

+

+		vol = (playing->volume << 5) + vol;

+

+		if (vol <= 0)

+			return 0;

+

+		if (vol > 64 << 5)

+			vol = 64 << 5;

+

+		if ( sigrenderer->sigdata->flags & IT_WAS_A_PTM )

+		{

+			int v = aiPTMVolScaled[ vol >> 5 ];

+			if ( vol < 64 << 5 )

+			{

+				int f = vol & ( ( 1 << 5 ) - 1 );

+				int f2 = ( 1 << 5 ) - f;

+				int v2 = aiPTMVolScaled[ ( vol >> 5 ) + 1 ];

+				v = ( v * f2 + v2 * f ) >> 5;

+			}

+			vol = v << 1;

+		}

+

+		volume *= vol; /* 64 << 5 */

+		volume *= playing->sample->global_volume; /* 64 */

+		volume *= playing->channel_volume; /* 64 */

+		volume *= sigrenderer->globalvolume; /* 128 */

+		volume *= sigrenderer->sigdata->mixing_volume; /* 128 */

+		volume *= 1.0f / ((64 << 5) * 64.0f * 64.0f * 128.0f * 128.0f);

+

+		if (volume && playing->instrument) {

+			if (playing->enabled_envelopes & IT_ENV_VOLUME) {

+				volume *= envelope_get_y(&playing->env_instrument->volume_envelope, &playing->volume_envelope);

+				volume *= 1.0f / (64 << IT_ENVELOPE_SHIFT);

+			}

+			volume *= playing->instrument->global_volume; /* 128 */

+			volume *= playing->fadeoutcount; /* 1024 */

+			volume *= 1.0f / (128.0f * 1024.0f);

+		}

+	}

+

+	return volume;

+}

+

+

+

+static int apply_pan_envelope(IT_PLAYING *playing)

+{

+	if (playing->pan <= 64 << IT_ENVELOPE_SHIFT) {

+		int pan;

+		if (playing->panbrello_depth) {

+			switch (playing->panbrello_waveform) {

+			default:

+				pan = it_sine[playing->panbrello_time];

+				break;

+			case 1:

+				pan = it_sawtooth[playing->panbrello_time];

+				break;

+			case 2:

+				pan = it_squarewave[playing->panbrello_time];

+				break;

+			case 3:

+				pan = playing->panbrello_random;

+				break;

+			}

+			pan *= playing->panbrello_depth << 3;

+

+			pan += playing->pan;

+			if (pan < 0) pan = 0;

+			else if (pan > 64 << IT_ENVELOPE_SHIFT) pan = 64 << IT_ENVELOPE_SHIFT;

+		} else {

+			pan = playing->pan;

+		}

+

+		if (playing->env_instrument && (playing->enabled_envelopes & IT_ENV_PANNING)) {

+			int p = envelope_get_y(&playing->env_instrument->pan_envelope, &playing->pan_envelope);

+			if (pan > 32 << IT_ENVELOPE_SHIFT)

+				p *= (64 << IT_ENVELOPE_SHIFT) - pan;

+			else

+				p *= pan;

+			pan += p >> (5 + IT_ENVELOPE_SHIFT);

+		}

+		return pan;

+	}

+	return playing->pan;

+}

+

+

+

+/* Note: if a click remover is provided, and store_end_sample is set, then

+ * the end point will be computed twice. This situation should not arise.

+ */

+static long render_playing(DUMB_IT_SIGRENDERER *sigrenderer, IT_PLAYING *playing, float volume, float main_delta, float delta, long pos, long size, sample_t **samples, int store_end_sample, int *left_to_mix, int cr_record_which)

+{

+	int bits;

+

+	long size_rendered;

+

+	DUMB_VOLUME_RAMP_INFO lvol, rvol;

+

+	if (playing->flags & IT_PLAYING_DEAD)

+		return 0;

+

+	if (*left_to_mix <= 0)

+		volume = 0;

+

+#ifndef END_RAMPING

+	{

+		int quality = sigrenderer->resampling_quality;

+		if (playing->sample->max_resampling_quality >= 0 && quality > playing->sample->max_resampling_quality)

+			quality = playing->sample->max_resampling_quality;

+		playing->resampler.quality = quality;

+	}

+#endif

+

+	bits = playing->sample->flags & IT_SAMPLE_16BIT ? 16 : 8;

+

+	if (volume == 0) {

+		if (playing->sample->flags & IT_SAMPLE_STEREO)

+			size_rendered = dumb_resample_n_2_1(bits, &playing->resampler, NULL, size, 0, 0, delta);

+		else

+			size_rendered = dumb_resample_n_1_1(bits, &playing->resampler, NULL, size, 0, delta);

+	} else {

+		lvol.volume = playing->ramp_volume [0];

+		rvol.volume = playing->ramp_volume [1];

+		lvol.delta  = playing->ramp_delta [0] * main_delta;

+		rvol.delta  = playing->ramp_delta [1] * main_delta;

+		lvol.target = playing->float_volume [0];

+		rvol.target = playing->float_volume [1];

+		rvol.mix = lvol.mix = volume;

+		if (sigrenderer->n_channels == 2) {

+			if (playing->sample->flags & IT_SAMPLE_STEREO) {

+				if ((cr_record_which & 1) && sigrenderer->click_remover) {

+					sample_t click[2];

+					dumb_resample_get_current_sample_n_2_2(bits, &playing->resampler, &lvol, &rvol, click);

+					dumb_record_click(sigrenderer->click_remover[0], pos, click[0]);

+					dumb_record_click(sigrenderer->click_remover[1], pos, click[1]);

+				}

+				size_rendered = dumb_resample_n_2_2(bits, &playing->resampler, samples[0] + pos*2, size, &lvol, &rvol, delta);

+				if (store_end_sample) {

+					sample_t click[2];

+					dumb_resample_get_current_sample_n_2_2(bits, &playing->resampler, &lvol, &rvol, click);

+					samples[0][(pos + size_rendered) * 2] = click[0];

+					samples[0][(pos + size_rendered) * 2 + 1] = click[1];

+				}

+				if ((cr_record_which & 2) && sigrenderer->click_remover) {

+					sample_t click[2];

+					dumb_resample_get_current_sample_n_2_2(bits, &playing->resampler, &lvol, &rvol, click);

+					dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click[0]);

+					dumb_record_click(sigrenderer->click_remover[1], pos + size_rendered, -click[1]);

+				}

+			} else {

+				if ((cr_record_which & 1) && sigrenderer->click_remover) {

+					sample_t click[2];

+					dumb_resample_get_current_sample_n_1_2(bits, &playing->resampler, &lvol, &rvol, click);

+					dumb_record_click(sigrenderer->click_remover[0], pos, click[0]);

+					dumb_record_click(sigrenderer->click_remover[1], pos, click[1]);

+				}

+				size_rendered = dumb_resample_n_1_2(bits, &playing->resampler, samples[0] + pos*2, size, &lvol, &rvol, delta);

+				if (store_end_sample) {

+					sample_t click[2];

+					dumb_resample_get_current_sample_n_1_2(bits, &playing->resampler, &lvol, &rvol, click);

+					samples[0][(pos + size_rendered) * 2] = click[0];

+					samples[0][(pos + size_rendered) * 2 + 1] = click[1];

+				}

+				if ((cr_record_which & 2) && sigrenderer->click_remover) {

+					sample_t click[2];

+					dumb_resample_get_current_sample_n_1_2(bits, &playing->resampler, &lvol, &rvol, click);

+					dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click[0]);

+					dumb_record_click(sigrenderer->click_remover[1], pos + size_rendered, -click[1]);

+				}

+			}

+		} else {

+			if (playing->sample->flags & IT_SAMPLE_STEREO) {

+				if ((cr_record_which & 1) && sigrenderer->click_remover) {

+					sample_t click;

+					dumb_resample_get_current_sample_n_2_1(bits, &playing->resampler, &lvol, &rvol, &click);

+					dumb_record_click(sigrenderer->click_remover[0], pos, click);

+				}

+				size_rendered = dumb_resample_n_2_1(bits, &playing->resampler, samples[0] + pos, size, &lvol, &rvol, delta);

+				if (store_end_sample)

+					dumb_resample_get_current_sample_n_2_1(bits, &playing->resampler, &lvol, &rvol, &samples[0][pos + size_rendered]);

+				if ((cr_record_which & 2) && sigrenderer->click_remover) {

+					sample_t click;

+					dumb_resample_get_current_sample_n_2_1(bits, &playing->resampler, &lvol, &rvol, &click);

+					dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click);

+				}

+			} else {

+				if ((cr_record_which & 1) && sigrenderer->click_remover) {

+					sample_t click;

+					dumb_resample_get_current_sample_n_1_1(bits, &playing->resampler, &lvol, &click);

+					dumb_record_click(sigrenderer->click_remover[0], pos, click);

+				}

+				size_rendered = dumb_resample_n_1_1(bits, &playing->resampler, samples[0] + pos, size, &lvol, delta);

+				if (store_end_sample)

+					dumb_resample_get_current_sample_n_1_1(bits, &playing->resampler, &lvol, &samples[0][pos + size_rendered]);

+				if ((cr_record_which & 2) && sigrenderer->click_remover) {

+					sample_t click;

+					dumb_resample_get_current_sample_n_1_1(bits, &playing->resampler, &lvol, &click);

+					dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click);

+				}

+			}

+		}

+		playing->ramp_volume [0] = lvol.volume;

+		playing->ramp_volume [1] = rvol.volume;

+		(*left_to_mix)--;

+	}

+

+	if (playing->resampler.dir == 0)

+		playing->flags |= IT_PLAYING_DEAD;

+

+	return size_rendered;

+}

+

+#ifdef END_RAMPING

+#if 1

+static long render_playing_part(DUMB_IT_SIGRENDERER *sigrenderer, IT_PLAYING *playing, DUMB_VOLUME_RAMP_INFO * lvol, DUMB_VOLUME_RAMP_INFO * rvol, int bits, float delta, long pos, long size, sample_t **samples, int store_end_sample, int cr_record_which)

+{

+	long size_rendered = 0;

+

+	if (sigrenderer->n_channels == 2) {

+		if (playing->sample->flags & IT_SAMPLE_STEREO) {

+			if ((cr_record_which & 1) && sigrenderer->click_remover) {

+				sample_t click[2];

+				dumb_resample_get_current_sample_n_2_2(bits, &playing->resampler, lvol, rvol, click);

+				dumb_record_click(sigrenderer->click_remover[0], pos, click[0]);

+				dumb_record_click(sigrenderer->click_remover[1], pos, click[1]);

+			}

+			size_rendered = dumb_resample_n_2_2(bits, &playing->resampler, samples[0] + pos*2, size, lvol, rvol, delta);

+			if (store_end_sample) {

+				sample_t click[2];

+				dumb_resample_get_current_sample_n_2_2(bits, &playing->resampler, lvol, rvol, click);

+				samples[0][(pos + size_rendered) * 2] = click[0];

+				samples[0][(pos + size_rendered) * 2 + 1] = click[1];

+			}

+			if ((cr_record_which & 2) && sigrenderer->click_remover) {

+				sample_t click[2];

+				dumb_resample_get_current_sample_n_2_2(bits, &playing->resampler, lvol, rvol, click);

+				dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click[0]);

+				dumb_record_click(sigrenderer->click_remover[1], pos + size_rendered, -click[1]);

+			}

+		} else {

+			if ((cr_record_which & 1) && sigrenderer->click_remover) {

+				sample_t click[2];

+				dumb_resample_get_current_sample_n_1_2(bits, &playing->resampler, lvol, rvol, click);

+				dumb_record_click(sigrenderer->click_remover[0], pos, click[0]);

+				dumb_record_click(sigrenderer->click_remover[1], pos, click[1]);

+			}

+			size_rendered = dumb_resample_n_1_2(bits, &playing->resampler, samples[0] + pos*2, size, lvol, rvol, delta);

+			if (store_end_sample) {

+				sample_t click[2];

+				dumb_resample_get_current_sample_n_1_2(bits, &playing->resampler, lvol, rvol, click);

+				samples[0][(pos + size_rendered) * 2] = click[0];

+				samples[0][(pos + size_rendered) * 2 + 1] = click[1];

+			}

+			if ((cr_record_which & 2) && sigrenderer->click_remover) {

+				sample_t click[2];

+				dumb_resample_get_current_sample_n_1_2(bits, &playing->resampler, lvol, rvol, click);

+				dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click[0]);

+				dumb_record_click(sigrenderer->click_remover[1], pos + size_rendered, -click[1]);

+			}

+		}

+	} else {

+		if (playing->sample->flags & IT_SAMPLE_STEREO) {

+			if ((cr_record_which & 1) && sigrenderer->click_remover) {

+				sample_t click;

+				dumb_resample_get_current_sample_n_2_1(bits, &playing->resampler, lvol, rvol, &click);

+				dumb_record_click(sigrenderer->click_remover[0], pos, click);

+			}

+			size_rendered = dumb_resample_n_2_1(bits, &playing->resampler, samples[0] + pos, size, lvol, rvol, delta);

+			if (store_end_sample)

+				dumb_resample_get_current_sample_n_2_1(bits, &playing->resampler, lvol, rvol, &samples[0][pos + size_rendered]);

+			if ((cr_record_which & 2) && sigrenderer->click_remover) {

+				sample_t click;

+				dumb_resample_get_current_sample_n_2_1(bits, &playing->resampler, lvol, rvol, &click);

+				dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click);

+			}

+		} else {

+			if ((cr_record_which & 1) && sigrenderer->click_remover) {

+				sample_t click;

+				dumb_resample_get_current_sample_n_1_1(bits, &playing->resampler, lvol, &click);

+				dumb_record_click(sigrenderer->click_remover[0], pos, click);

+			}

+			size_rendered = dumb_resample_n_1_1(bits, &playing->resampler, samples[0] + pos, size, lvol, delta);

+			if (store_end_sample)

+				dumb_resample_get_current_sample_n_1_1(bits, &playing->resampler, lvol, &samples[0][pos + size_rendered]);

+			if ((cr_record_which & 2) && sigrenderer->click_remover) {

+				sample_t click;

+				dumb_resample_get_current_sample_n_1_1(bits, &playing->resampler, lvol, &click);

+				dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click);

+			}

+		}

+	}

+	return size_rendered;

+}

+

+static long render_playing_ramp(DUMB_IT_SIGRENDERER *sigrenderer, IT_PLAYING *playing, float volume, float main_delta, float delta, long pos, long size, sample_t **samples, int store_end_sample, int *left_to_mix, int ramp_style)

+{

+	int bits;

+

+	long size_rendered;

+

+	DUMB_VOLUME_RAMP_INFO lvol, rvol;

+

+	if (!size) return 0;

+

+	if (playing->flags & IT_PLAYING_DEAD)

+		return 0;

+

+	if (*left_to_mix <= 0)

+		volume = 0;

+

+	{

+		int quality = sigrenderer->resampling_quality;

+		if (playing->sample->max_resampling_quality >= 0 && quality > playing->sample->max_resampling_quality)

+			quality = playing->sample->max_resampling_quality;

+		playing->resampler.quality = quality;

+	}

+

+	bits = playing->sample->flags & IT_SAMPLE_16BIT ? 16 : 8;

+	size_rendered = size;

+

+	if (volume == 0) {

+		if (playing->declick_stage < 2) {

+			if (playing->sample->flags & IT_SAMPLE_STEREO)

+				size_rendered = dumb_resample_n_2_1(bits, &playing->resampler, NULL, size, 0, 0, delta);

+			else

+				size_rendered = dumb_resample_n_1_1(bits, &playing->resampler, NULL, size, 0, delta);

+		} else {

+			playing->declick_stage = 3;

+		}

+	} else {

+		lvol.volume = playing->ramp_volume [0];

+		rvol.volume = playing->ramp_volume [1];

+		lvol.delta  = playing->ramp_delta [0] * main_delta;

+		rvol.delta  = playing->ramp_delta [1] * main_delta;

+		lvol.target = playing->float_volume [0];

+		rvol.target = playing->float_volume [1];

+		rvol.mix = lvol.mix = volume;

+		if (ramp_style) {

+			if (playing->declick_stage == 1) {

+				size_rendered = render_playing_part(sigrenderer, playing, &lvol, &rvol, bits, delta, pos, size, samples, store_end_sample, 3);

+			} else if (playing->declick_stage == 0 || playing->declick_stage == 2) {

+				float declick_count = ((ramp_style == 2) ? 327.68 : 49.152) / main_delta; /* 5ms / 0.75ms */

+				float declick_remain = playing->declick_volume * declick_count;

+				float declick_dir = -1;

+				float declick_target;

+				int remain;

+				DUMB_VOLUME_RAMP_INFO declick_lvol, declick_rvol;

+				if (playing->declick_stage == 0) {

+					declick_remain = declick_count - declick_remain;

+					declick_dir = 1;

+				}

+				if (size < declick_remain) declick_remain = size;

+				remain = declick_remain;

+				declick_target = playing->declick_volume + declick_dir / declick_count * declick_remain;

+				declick_lvol.volume = lvol.volume * playing->declick_volume;

+				declick_rvol.volume = rvol.volume * playing->declick_volume;

+				lvol.volume += lvol.delta * declick_remain;

+				rvol.volume += rvol.delta * declick_remain;

+				declick_lvol.target = lvol.volume * declick_target;

+				declick_rvol.target = rvol.volume * declick_target;

+				declick_lvol.delta = (declick_lvol.target - declick_lvol.volume) / declick_remain;

+				declick_rvol.delta = (declick_rvol.target - declick_rvol.volume) / declick_remain;

+				declick_lvol.mix = declick_rvol.mix = volume;

+				if (remain < size) {

+					size_rendered = render_playing_part(sigrenderer, playing, &declick_lvol, &declick_rvol, bits, delta, pos, remain, samples, 0, 1);

+					if (size_rendered == remain) {

+						if (playing->declick_stage == 0) {

+							size_rendered += render_playing_part(sigrenderer, playing, &lvol, &rvol, bits, delta, pos + remain, size - remain, samples, store_end_sample, 2);

+						} else {

+							size_rendered = size;

+						}

+					}

+					playing->declick_stage++;

+					playing->declick_volume = 1;

+				} else {

+					size_rendered = render_playing_part(sigrenderer, playing, &declick_lvol, &declick_rvol, bits, delta, pos, remain, samples, store_end_sample, 3);

+					playing->declick_volume = declick_target;

+				}

+			} else /*if (playing->declick_stage == 3)*/ {

+				(*left_to_mix)++;

+			}

+		} else if (playing->declick_stage < 2) {

+			size_rendered = render_playing_part(sigrenderer, playing, &lvol, &rvol, bits, delta, pos, size, samples, store_end_sample, 3);

+		} else {

+			playing->declick_stage = 3;

+			(*left_to_mix)++;

+		}

+		playing->ramp_volume [0] = lvol.volume;

+		playing->ramp_volume [1] = rvol.volume;

+		(*left_to_mix)--;

+	}

+

+	if (playing->resampler.dir == 0)

+		playing->flags |= IT_PLAYING_DEAD;

+

+	return size_rendered;

+}

+#else

+static long render_playing_ramp(DUMB_IT_SIGRENDERER *sigrenderer, IT_PLAYING *playing, float volume, float main_delta, float delta, long pos, long size, sample_t **samples, int store_end_sample, int *left_to_mix, int ramp_style)

+{

+	long rv, trv;

+	int l_t_m_temp, cr_which;

+	if (!size) return 0;

+

+	rv = 0;

+	cr_which = 3;

+

+	{

+		int quality = sigrenderer->resampling_quality;

+		if (playing->sample->max_resampling_quality >= 0 && quality > playing->sample->max_resampling_quality)

+			quality = playing->sample->max_resampling_quality;

+		playing->resampler.quality = quality;

+	}

+

+	if (ramp_style)

+	{

+		if (playing->declick_stage == 0) {

+			/* ramp up! */

+			cr_which = 1;

+			while (playing->declick_stage == 0 && size) {

+				l_t_m_temp = *left_to_mix;

+				if (size == 1) cr_which |= 2;

+				trv = render_playing(sigrenderer, playing, volume * playing->declick_volume, main_delta, delta, pos, 1, samples, store_end_sample, &l_t_m_temp, cr_which);

+				cr_which &= 2;

+				if (ramp_style == 2) playing->declick_volume += (1.f / 256.f) * main_delta;

+				else playing->declick_volume *= (float)pow(2.0f, main_delta);

+				if (playing->declick_volume >= 1.0f) {

+					playing->declick_volume = 1.0f;

+					playing->declick_stage = 1;

+				}

+				if (!trv) {

+					*left_to_mix = l_t_m_temp;

+					return rv;

+				}

+				rv += trv;

+				pos += trv;

+				size -= trv;

+			}

+

+			if (!size) {

+				*left_to_mix = l_t_m_temp;

+				return rv;

+			}

+

+			cr_which = 2;

+

+		}

+#ifdef RAMP_DOWN

+		else if (playing->declick_stage == 2) {

+			float halflife = pow(0.5, 1.0 / 64.0 * main_delta);

+			cr_which = 1;

+			while (playing->declick_stage == 2 && size) {

+				l_t_m_temp = *left_to_mix;

+				if (size == 1) cr_which |= 2;

+				trv = render_playing(sigrenderer, playing, volume * playing->declick_volume, main_delta, delta, pos, 1, samples, store_end_sample, &l_t_m_temp, cr_which);

+				cr_which &= 2;

+				/*if (ramp_style == 2) playing->declick_volume -= (1.f / 256.f) * main_delta;

+				else playing->declick_volume *= (float)pow(0.5f, main_delta);*/

+				playing->declick_volume *= halflife;

+				if (playing->declick_volume < (1.f / 256.f)) {

+					playing->declick_stage = 3;

+				}

+				if (!trv) {

+					*left_to_mix = l_t_m_temp;

+					return rv;

+				}

+				rv += trv;

+				pos += trv;

+				size -= trv;

+			}

+

+			if (size) rv += render_playing(sigrenderer, playing, volume * playing->declick_volume, main_delta, delta, pos, 1, samples, store_end_sample, left_to_mix, 2);

+			else *left_to_mix = l_t_m_temp;

+

+			return rv;

+

+		} else if (playing->declick_stage == 3) {

+			return size;

+		}

+#endif

+	} else if (playing->declick_stage >= 2) {

+		playing->declick_stage = 3;

+		return size;

+	}

+

+	return rv + render_playing(sigrenderer, playing, volume, main_delta, delta, pos, size, samples, store_end_sample, left_to_mix, cr_which);

+}

+#endif

+#else

+#define render_playing_ramp(sigrenderer, playing, volume, main_delta, delta, pos, size, samples, store_end_sample, left_to_mix, ramp_style) render_playing(sigrenderer, playing, volume, main_delta, delta, pos, size, samples, store_end_sample, left_to_mix, 3)

+#endif

+

+typedef struct IT_TO_MIX

+{

+	IT_PLAYING *playing;

+	float volume;

+}

+IT_TO_MIX;

+

+

+

+static int it_to_mix_compare(const void *e1, const void *e2)

+{

+	if (((const IT_TO_MIX *)e1)->volume > ((const IT_TO_MIX *)e2)->volume)

+		return -1;

+

+	if (((const IT_TO_MIX *)e1)->volume < ((const IT_TO_MIX *)e2)->volume)

+		return 1;

+

+	return 0;

+}

+

+

+

+static void apply_pitch_modifications(DUMB_IT_SIGDATA *sigdata, IT_PLAYING *playing, float *delta, int *cutoff)

+{

+	{

+		int sample_vibrato_shift;

+		switch (playing->sample_vibrato_waveform)

+		{

+		default:

+			sample_vibrato_shift = it_sine[playing->sample_vibrato_time];

+			break;

+		case 1:

+			sample_vibrato_shift = it_sawtooth[playing->sample_vibrato_time];

+			break;

+		case 2:

+			sample_vibrato_shift = it_squarewave[playing->sample_vibrato_time];

+			break;

+		case 3:

+			sample_vibrato_shift = (rand() % 129) - 64;

+			break;

+		case 4:

+			sample_vibrato_shift = it_xm_squarewave[playing->sample_vibrato_time];

+			break;

+		case 5:

+			sample_vibrato_shift = it_xm_ramp[playing->sample_vibrato_time];

+			break;

+		case 6:

+			sample_vibrato_shift = it_xm_ramp[255-playing->sample_vibrato_time];

+			break;

+		}

+

+		if (sigdata->flags & IT_WAS_AN_XM) {

+			int depth = playing->sample->vibrato_depth; /* True depth */

+			if (playing->sample->vibrato_rate) {

+				depth *= playing->sample_vibrato_depth; /* Tick number */

+				depth /= playing->sample->vibrato_rate; /* XM sweep */

+			}

+			sample_vibrato_shift *= depth;

+		} else

+			sample_vibrato_shift *= playing->sample_vibrato_depth >> 8;

+

+		sample_vibrato_shift >>= 4;

+

+		if (sample_vibrato_shift) {

+			if ((sigdata->flags & IT_LINEAR_SLIDES) || !(sigdata->flags & IT_WAS_AN_XM))

+				*delta *= (float)pow(DUMB_PITCH_BASE, sample_vibrato_shift);

+			else {

+				/* complicated! */

+				float scale = *delta / playing->delta;

+

+				*delta = (1.0f / 65536.0f) / playing->delta;

+

+				*delta -= sample_vibrato_shift / AMIGA_DIVISOR;

+

+				if (*delta < (1.0f / 65536.0f) / 32767.0f) {

+					*delta = (1.0f / 65536.0f) / 32767.0f;

+				}

+

+				*delta = (1.0f / 65536.0f) / *delta * scale;

+			}

+		}

+	}

+

+	if (playing->env_instrument &&

+		(playing->enabled_envelopes & IT_ENV_PITCH))

+	{

+		int p = envelope_get_y(&playing->env_instrument->pitch_envelope, &playing->pitch_envelope);

+		if (playing->env_instrument->pitch_envelope.flags & IT_ENVELOPE_PITCH_IS_FILTER)

+			*cutoff = (*cutoff * (p+(32<<IT_ENVELOPE_SHIFT))) >> (6 + IT_ENVELOPE_SHIFT);

+		else

+			*delta *= (float)pow(DUMB_PITCH_BASE, p >> (IT_ENVELOPE_SHIFT - 7));

+	}

+}

+

+

+

+static void render(DUMB_IT_SIGRENDERER *sigrenderer, float volume, float delta, long pos, long size, sample_t **samples)

+{

+	int i;

+

+	int n_to_mix = 0;

+	IT_TO_MIX to_mix[DUMB_IT_TOTAL_CHANNELS];

+	int left_to_mix = dumb_it_max_to_mix;

+

+	sample_t **samples_to_filter = NULL;

+

+	int ramp_style = sigrenderer->ramp_style;

+

+	//int max_output = sigrenderer->max_output;

+

+	if (ramp_style > 2) {

+		if ((sigrenderer->sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_MOD)) == IT_WAS_AN_XM) ramp_style = 2;

+		else ramp_style -= 3;

+	}

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+		if (sigrenderer->channel[i].playing && !(sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD)) {

+			to_mix[n_to_mix].playing = sigrenderer->channel[i].playing;

+			to_mix[n_to_mix].volume = volume == 0 ? 0 : calculate_volume(sigrenderer, sigrenderer->channel[i].playing, volume);

+			n_to_mix++;

+		}

+	}

+

+	for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+		if (sigrenderer->playing[i]) { /* Won't be dead; it would have been freed. */

+			to_mix[n_to_mix].playing = sigrenderer->playing[i];

+			to_mix[n_to_mix].volume = volume == 0 ? 0 : calculate_volume(sigrenderer, sigrenderer->playing[i], volume);

+			n_to_mix++;

+		}

+	}

+

+	if (volume != 0)

+		qsort(to_mix, n_to_mix, sizeof(IT_TO_MIX), &it_to_mix_compare);

+

+	for (i = 0; i < n_to_mix; i++) {

+		IT_PLAYING *playing = to_mix[i].playing;

+		float note_delta = delta * playing->delta;

+		int cutoff = playing->filter_cutoff << IT_ENVELOPE_SHIFT;

+		//int output = min( playing->output, max_output );

+

+		apply_pitch_modifications(sigrenderer->sigdata, playing, &note_delta, &cutoff);

+

+		if (cutoff != 127 << IT_ENVELOPE_SHIFT || playing->filter_resonance != 0) {

+			playing->true_filter_cutoff = cutoff;

+			playing->true_filter_resonance = playing->filter_resonance;

+		}

+

+		if (volume && (playing->true_filter_cutoff != 127 << IT_ENVELOPE_SHIFT || playing->true_filter_resonance != 0)) {

+			if (!samples_to_filter) {

+				samples_to_filter = allocate_sample_buffer(sigrenderer->n_channels, size + 1);

+				if (!samples_to_filter) {

+					render_playing_ramp(sigrenderer, playing, 0, delta, note_delta, pos, size, NULL, 0, &left_to_mix, ramp_style);

+					continue;

+				}

+			}

+			{

+				long size_rendered;

+				DUMB_CLICK_REMOVER **cr = sigrenderer->click_remover;

+				dumb_silence(samples_to_filter[0], sigrenderer->n_channels * (size + 1));

+				sigrenderer->click_remover = NULL;

+				size_rendered = render_playing_ramp(sigrenderer, playing, volume, delta, note_delta, 0, size, samples_to_filter, 1, &left_to_mix, ramp_style);

+				sigrenderer->click_remover = cr;

+				if (sigrenderer->n_channels == 2) {

+					it_filter(cr ? cr[0] : NULL, &playing->filter_state[0], samples[0 /*output*/], pos, samples_to_filter[0], size_rendered,

+						2, (int)(65536.0f/delta), playing->true_filter_cutoff, playing->true_filter_resonance);

+					it_filter(cr ? cr[1] : NULL, &playing->filter_state[1], samples[0 /*output*/]+1, pos, samples_to_filter[0]+1, size_rendered,

+						2, (int)(65536.0f/delta), playing->true_filter_cutoff, playing->true_filter_resonance);

+				} else {

+					it_filter(cr ? cr[0] : NULL, &playing->filter_state[0], samples[0 /*output*/], pos, samples_to_filter[0], size_rendered,

+						1, (int)(65536.0f/delta), playing->true_filter_cutoff, playing->true_filter_resonance);

+				}

+				// FIXME: filtering is not prevented by low left_to_mix!

+				// FIXME: change 'warning' to 'FIXME' everywhere

+			}

+		} else {

+			it_reset_filter_state(&playing->filter_state[0]);

+			it_reset_filter_state(&playing->filter_state[1]);

+			render_playing_ramp(sigrenderer, playing, volume, delta, note_delta, pos, size, samples /*&samples[output]*/, 0, &left_to_mix, ramp_style);

+		}

+	}

+

+	destroy_sample_buffer(samples_to_filter);

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+		if (sigrenderer->channel[i].playing) {

+			//if ((sigrenderer->channel[i].playing->flags & (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) == (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) {

+			// This change was made so Gxx would work correctly when a note faded out or whatever. Let's hope nothing else was broken by it.

+			if (

+#ifdef RAMP_DOWN

+			(sigrenderer->channel[i].playing->declick_stage == 3) || 

+#endif

+			(sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD)) {

+				free(sigrenderer->channel[i].playing);

+				sigrenderer->channel[i].playing = NULL;

+			}

+		}

+	}

+

+	for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+		if (sigrenderer->playing[i]) {

+			if (

+#ifdef RAMP_DOWN

+				(sigrenderer->playing[i]->declick_stage == 3) ||

+#endif

+				(sigrenderer->playing[i]->flags & IT_PLAYING_DEAD)) {

+				free(sigrenderer->playing[i]);

+				sigrenderer->playing[i] = NULL;

+			}

+		}

+	}

+}

+

+

+

+static DUMB_IT_SIGRENDERER *init_sigrenderer(DUMB_IT_SIGDATA *sigdata, int n_channels, int startorder, IT_CALLBACKS *callbacks, DUMB_CLICK_REMOVER **cr)

+{

+	DUMB_IT_SIGRENDERER *sigrenderer;

+	int i;

+

+	if (startorder > sigdata->n_orders) {

+		free(callbacks);

+		dumb_destroy_click_remover_array(n_channels, cr);

+		return NULL;

+	}

+

+	sigrenderer = malloc(sizeof(*sigrenderer));

+	if (!sigrenderer) {

+		free(callbacks);

+		dumb_destroy_click_remover_array(n_channels, cr);

+		return NULL;

+	}

+

+	sigrenderer->callbacks = callbacks;

+	sigrenderer->click_remover = cr;

+

+	sigrenderer->sigdata = sigdata;

+	sigrenderer->n_channels = n_channels;

+	sigrenderer->resampling_quality = dumb_resampling_quality;

+	sigrenderer->ramp_style = 0;

+	sigrenderer->globalvolume = sigdata->global_volume;

+	sigrenderer->tempo = sigdata->tempo;

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+		IT_CHANNEL *channel = &sigrenderer->channel[i];

+#if IT_CHANNEL_MUTED != 1

+#error this is wrong

+#endif

+		channel->flags = sigdata->channel_pan[i] >> 7;

+		channel->volume = (sigdata->flags & IT_WAS_AN_XM) ? 0 : 64;

+		channel->pan = sigdata->channel_pan[i] & 0x7F;

+		channel->truepan = channel->pan << IT_ENVELOPE_SHIFT;

+		channel->channelvolume = sigdata->channel_volume[i];

+		channel->instrument = 0;

+		channel->sample = 0;

+		channel->note = 0;

+		channel->SFmacro = 0;

+		channel->filter_cutoff = 127;

+		channel->filter_resonance = 0;

+		channel->new_note_action = 0xFF;

+		channel->xm_retrig = 0;

+		channel->retrig_tick = 0;

+		channel->tremor_time = 0;

+		channel->vibrato_waveform = 0;

+		channel->tremolo_waveform = 0;

+		channel->panbrello_waveform = 0;

+		channel->glissando = 0;

+		channel->toneslide = 0;

+		channel->ptm_toneslide = 0;

+		channel->ptm_last_toneslide = 0;

+		channel->midi_state = 0;

+		channel->lastvolslide = 0;

+		channel->lastDKL = 0;

+		channel->lastEF = 0;

+		channel->lastG = 0;

+		channel->lastHspeed = 0;

+		channel->lastHdepth = 0;

+		channel->lastRspeed = 0;

+		channel->lastRdepth = 0;

+		channel->lastYspeed = 0;

+		channel->lastYdepth = 0;

+		channel->lastI = 0;

+		channel->lastJ = 0;

+		channel->lastN = 0;

+		channel->lastO = 0;

+		channel->high_offset = 0;

+		channel->lastP = 0;

+		channel->lastQ = 0;

+		channel->lastS = 0;

+		channel->pat_loop_row = 0;

+		channel->pat_loop_count = 0;

+		channel->pat_loop_end_row = 0;

+		channel->lastW = 0;

+		channel->xm_lastE1 = 0;

+		channel->xm_lastE2 = 0;

+		channel->xm_lastEA = 0;

+		channel->xm_lastEB = 0;

+		channel->xm_lastX1 = 0;

+		channel->xm_lastX2 = 0;

+		channel->playing = NULL;

+#ifdef BIT_ARRAY_BULLSHIT

+		channel->played_patjump = NULL;

+		channel->played_patjump_order = 0xFFFE;

+#endif

+		//channel->output = 0;

+	}

+

+	if (sigdata->flags & IT_WAS_A_669)

+		reset_effects(sigrenderer);

+

+	for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++)

+		sigrenderer->playing[i] = NULL;

+

+	sigrenderer->speed = sigdata->speed;

+

+	sigrenderer->processrow = 0xFFFE;

+	sigrenderer->n_rows = 0;

+	sigrenderer->breakrow = 0;

+	sigrenderer->rowcount = 1;

+	sigrenderer->order = startorder;

+	/* meh!

+	if (startorder > 0) {

+		int n;

+		for (n = startorder - 1; n >= 0; n--) {

+			if (sigdata->order[n] > sigdata->n_patterns) {

+				sigrenderer->restart_position = n + 1;

+				break;

+			}

+		}

+	}

+	*/

+	if (startorder > 0) {

+		sigrenderer->restart_position = startorder;

+	} else {

+		sigrenderer->restart_position = sigdata->restart_position;

+	}

+

+	sigrenderer->row = 0;

+	sigrenderer->processorder = startorder - 1;

+	sigrenderer->tick = 1;

+

+	{

+		int order;

+		for (order = 0; order < sigdata->n_orders; order++) {

+			int n = sigdata->order[order];

+			if (n < sigdata->n_patterns) goto found_valid_order;

+#ifdef INVALID_ORDERS_END_SONG

+			if (n != IT_ORDER_SKIP)

+#else

+			if (n == IT_ORDER_END)

+#endif

+				break;

+		}

+		/* If we get here, there were no valid orders in the song. */

+		_dumb_it_end_sigrenderer(sigrenderer);

+		return NULL;

+	}

+	found_valid_order:

+

+	sigrenderer->time_left = 0;

+	sigrenderer->sub_time_left = 0;

+

+#ifdef BIT_ARRAY_BULLSHIT

+	sigrenderer->played = bit_array_create(sigdata->n_orders * 256);

+#endif

+

+	sigrenderer->gvz_time = 0;

+	sigrenderer->gvz_sub_time = 0;

+

+	//sigrenderer->max_output = 0;

+

+	return sigrenderer;

+}

+

+

+void dumb_it_set_resampling_quality(DUMB_IT_SIGRENDERER * sigrenderer, int quality)

+{

+	if (sigrenderer && quality >= 0 && quality < DUMB_RQ_N_LEVELS)

+	{

+		int i;

+		sigrenderer->resampling_quality = quality;

+		for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+			if (sigrenderer->channel[i].playing)

+			{

+				IT_PLAYING * playing = sigrenderer->channel[i].playing;

+				playing->resampling_quality = quality;

+				playing->resampler.quality = quality;

+			}

+		}

+		for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) {

+			if (sigrenderer->playing[i]) {

+				IT_PLAYING * playing = sigrenderer->playing[i];

+				playing->resampling_quality = quality;

+				playing->resampler.quality = quality;

+			}

+		}

+	}

+}

+

+

+void dumb_it_set_ramp_style(DUMB_IT_SIGRENDERER * sigrenderer, int ramp_style) {

+	if (sigrenderer && ramp_style >= 0 && ramp_style <= 4) {

+		sigrenderer->ramp_style = ramp_style;

+	}

+}

+

+

+void dumb_it_set_loop_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data), void *data)

+{

+	if (sigrenderer) {

+		sigrenderer->callbacks->loop = callback;

+		sigrenderer->callbacks->loop_data = data;

+	}

+}

+

+

+

+void dumb_it_set_xm_speed_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data), void *data)

+{

+	if (sigrenderer) {

+		sigrenderer->callbacks->xm_speed_zero = callback;

+		sigrenderer->callbacks->xm_speed_zero_data = data;

+	}

+}

+

+

+

+void dumb_it_set_midi_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data, int channel, unsigned char midi_byte), void *data)

+{

+	if (sigrenderer) {

+		sigrenderer->callbacks->midi = callback;

+		sigrenderer->callbacks->midi_data = data;

+	}

+}

+

+

+

+void dumb_it_set_global_volume_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data), void *data)

+{

+	if (sigrenderer) {

+		sigrenderer->callbacks->global_volume_zero = callback;

+		sigrenderer->callbacks->global_volume_zero_data = data;

+	}

+}

+

+

+

+static IT_CALLBACKS *create_callbacks(void)

+{

+	IT_CALLBACKS *callbacks = malloc(sizeof(*callbacks));

+	if (!callbacks) return NULL;

+	callbacks->loop = NULL;

+	callbacks->xm_speed_zero = NULL;

+	callbacks->midi = NULL;

+	callbacks->global_volume_zero = NULL;

+	return callbacks;

+}

+

+

+

+static DUMB_IT_SIGRENDERER *dumb_it_init_sigrenderer(DUMB_IT_SIGDATA *sigdata, int n_channels, int startorder)

+{

+	IT_CALLBACKS *callbacks;

+

+	if (!sigdata) return NULL;

+

+	callbacks = create_callbacks();

+	if (!callbacks) return NULL;

+

+	return init_sigrenderer(sigdata, n_channels, startorder, callbacks,

+		dumb_create_click_remover_array(n_channels));

+}

+

+

+

+DUH_SIGRENDERER *dumb_it_start_at_order(DUH *duh, int n_channels, int startorder)

+{

+	DUMB_IT_SIGDATA *itsd = duh_get_it_sigdata(duh);

+	DUMB_IT_SIGRENDERER *itsr = dumb_it_init_sigrenderer(itsd, n_channels, startorder);

+	/*duh->length = dumb_it_build_checkpoints(itsd, startorder);*/

+	return duh_encapsulate_it_sigrenderer(itsr, n_channels, 0);

+}

+

+

+

+static sigrenderer_t *it_start_sigrenderer(DUH *duh, sigdata_t *vsigdata, int n_channels, long pos)

+{

+	DUMB_IT_SIGDATA *sigdata = vsigdata;

+	DUMB_IT_SIGRENDERER *sigrenderer;

+

+	(void)duh;

+

+	{

+		IT_CALLBACKS *callbacks = create_callbacks();

+		if (!callbacks) return NULL;

+

+		if (sigdata->checkpoint) {

+			IT_CHECKPOINT *checkpoint = sigdata->checkpoint;

+			while (checkpoint->next && checkpoint->next->time < pos)

+				checkpoint = checkpoint->next;

+			sigrenderer = dup_sigrenderer(checkpoint->sigrenderer, n_channels, callbacks);

+			if (!sigrenderer) return NULL;

+			sigrenderer->click_remover = dumb_create_click_remover_array(n_channels);

+			pos -= checkpoint->time;

+		} else {

+			sigrenderer = init_sigrenderer(sigdata, n_channels, 0, callbacks,

+				dumb_create_click_remover_array(n_channels));

+			if (!sigrenderer) return NULL;

+		}

+	}

+

+	while (pos >= sigrenderer->time_left) {

+		render(sigrenderer, 0, 1.0f, 0, sigrenderer->time_left, NULL);

+

+		pos -= sigrenderer->time_left;

+		sigrenderer->time_left = 0;

+

+		if (process_tick(sigrenderer)) {

+			_dumb_it_end_sigrenderer(sigrenderer);

+			return NULL;

+		}

+	}

+

+	render(sigrenderer, 0, 1.0f, 0, pos, NULL);

+	sigrenderer->time_left -= pos;

+

+	return sigrenderer;

+}

+

+

+

+static long it_sigrenderer_get_samples(

+	sigrenderer_t *vsigrenderer,

+	float volume, float delta,

+	long size, sample_t **samples

+)

+{

+	DUMB_IT_SIGRENDERER *sigrenderer = vsigrenderer;

+	long pos;

+	int dt;

+	long todo;

+	LONG_LONG t;

+

+	if (sigrenderer->order < 0) return 0; // problematic

+

+	pos = 0;

+	dt = (int)(delta * 65536.0f + 0.5f);

+

+	/* When samples is finally used in render_playing(), it won't be used if

+	 * volume is 0.

+	 */

+	if (!samples) volume = 0;

+

+	for (;;) {

+		todo = (long)((((LONG_LONG)sigrenderer->time_left << 16) | sigrenderer->sub_time_left) / dt);

+

+		if (todo >= size)

+			break;

+

+		render(sigrenderer, volume, delta, pos, todo, samples);

+

+		pos += todo;

+		size -= todo;

+

+		t = sigrenderer->sub_time_left - (LONG_LONG)todo * dt;

+		sigrenderer->sub_time_left = (long)t & 65535;

+		sigrenderer->time_left += (long)(t >> 16);

+

+		if (process_tick(sigrenderer)) {

+			sigrenderer->order = -1;

+			sigrenderer->row = -1;

+			return pos;

+		}

+	}

+

+	render(sigrenderer, volume, delta, pos, size, samples);

+

+	pos += size;

+

+	t = sigrenderer->sub_time_left - (LONG_LONG)size * dt;

+	sigrenderer->sub_time_left = (long)t & 65535;

+	sigrenderer->time_left += (long)(t >> 16);

+

+	if (samples)

+		dumb_remove_clicks_array(sigrenderer->n_channels, sigrenderer->click_remover, samples, pos, 512.0f / delta);

+

+	return pos;

+}

+

+

+

+static void it_sigrenderer_get_current_sample(sigrenderer_t *vsigrenderer, float volume, sample_t *samples)

+{

+	DUMB_IT_SIGRENDERER *sigrenderer = vsigrenderer;

+	(void)volume; // for consideration: in any of these such functions, is 'volume' going to be required?

+	dumb_click_remover_get_offset_array(sigrenderer->n_channels, sigrenderer->click_remover, samples);

+}

+

+

+

+void _dumb_it_end_sigrenderer(sigrenderer_t *vsigrenderer)

+{

+	DUMB_IT_SIGRENDERER *sigrenderer = vsigrenderer;

+

+	int i;

+

+	if (sigrenderer) {

+		for (i = 0; i < DUMB_IT_N_CHANNELS; i++) {

+			if (sigrenderer->channel[i].playing)

+				free(sigrenderer->channel[i].playing);

+#ifdef BIT_ARRAY_BULLSHIT

+			bit_array_destroy(sigrenderer->channel[i].played_patjump);

+#endif

+		}

+

+		for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++)

+			if (sigrenderer->playing[i])

+				free(sigrenderer->playing[i]);

+

+		dumb_destroy_click_remover_array(sigrenderer->n_channels, sigrenderer->click_remover);

+

+		if (sigrenderer->callbacks)

+			free(sigrenderer->callbacks);

+

+#ifdef BIT_ARRAY_BULLSHIT

+		bit_array_destroy(sigrenderer->played);

+#endif

+

+		free(vsigrenderer);

+	}

+}

+

+

+

+DUH_SIGTYPE_DESC _dumb_sigtype_it = {

+	SIGTYPE_IT,

+	NULL,

+	&it_start_sigrenderer,

+	NULL,

+	&it_sigrenderer_get_samples,

+	&it_sigrenderer_get_current_sample,

+	&_dumb_it_end_sigrenderer,

+	&_dumb_it_unload_sigdata

+};

+

+

+

+DUH_SIGRENDERER *duh_encapsulate_it_sigrenderer(DUMB_IT_SIGRENDERER *it_sigrenderer, int n_channels, long pos)

+{

+	return duh_encapsulate_raw_sigrenderer(it_sigrenderer, &_dumb_sigtype_it, n_channels, pos);

+}

+

+

+

+DUMB_IT_SIGRENDERER *duh_get_it_sigrenderer(DUH_SIGRENDERER *sigrenderer)

+{

+	return duh_get_raw_sigrenderer(sigrenderer, SIGTYPE_IT);

+}

+

+

+

+/* Values of 64 or more will access NNA channels here. */

+void dumb_it_sr_get_channel_state(DUMB_IT_SIGRENDERER *sr, int channel, DUMB_IT_CHANNEL_STATE *state)

+{

+	IT_PLAYING *playing;

+	int t; /* temporary var for holding accurate pan and filter cutoff */

+	float delta;

+	ASSERT(channel < DUMB_IT_TOTAL_CHANNELS);

+	if (!sr) { state->sample = 0; return; }

+	if (channel >= DUMB_IT_N_CHANNELS) {

+		playing = sr->playing[channel - DUMB_IT_N_CHANNELS];

+		if (!playing) { state->sample = 0; return; }

+	} else {

+		playing = sr->channel[channel].playing;

+		if (!playing) { state->sample = 0; return; }

+	}

+

+	if (playing->flags & IT_PLAYING_DEAD) { state->sample = 0; return; }

+

+	state->channel = playing->channel - sr->channel;

+	state->sample = playing->sampnum;

+	state->volume = calculate_volume(sr, playing, 1.0f);

+

+	t = apply_pan_envelope(playing);

+	state->pan = (unsigned char)((t + 128) >> IT_ENVELOPE_SHIFT);

+	state->subpan = (signed char)t;

+

+	delta = playing->delta * 65536.0f;

+	t = playing->filter_cutoff << IT_ENVELOPE_SHIFT;

+	apply_pitch_modifications(sr->sigdata, playing, &delta, &t);

+	state->freq = (int)delta;

+	if (t == 127 << IT_ENVELOPE_SHIFT && playing->filter_resonance == 0) {

+		state->filter_resonance = playing->true_filter_resonance;

+		t = playing->true_filter_cutoff;

+	} else

+		state->filter_resonance = playing->filter_resonance;

+	state->filter_cutoff = (unsigned char)(t >> 8);

+	state->filter_subcutoff = (unsigned char)t;

+}

+

+

+

+int dumb_it_callback_terminate(void *data)

+{

+	(void)data;

+	return 1;

+}

+

+

+

+int dumb_it_callback_midi_block(void *data, int channel, unsigned char midi_byte)

+{

+	(void)data;

+	(void)channel;

+	(void)midi_byte;

+	return 1;

+}

+

+

+

+#define IT_CHECKPOINT_INTERVAL (30 * 65536) /* Half a minute */

+

+#define FUCKIT_THRESHOLD (120 * 60 * 65536) /* two hours? probably a pattern loop mess... */

+

+/* Returns the length of the module, up until it first loops. */

+long dumb_it_build_checkpoints(DUMB_IT_SIGDATA *sigdata, int startorder)

+{

+	IT_CHECKPOINT *checkpoint;

+	if (!sigdata) return 0;

+	checkpoint = sigdata->checkpoint;

+	while (checkpoint) {

+		IT_CHECKPOINT *next = checkpoint->next;

+		_dumb_it_end_sigrenderer(checkpoint->sigrenderer);

+		free(checkpoint);

+		checkpoint = next;

+	}

+	sigdata->checkpoint = NULL;

+	checkpoint = malloc(sizeof(*checkpoint));

+	if (!checkpoint) return 0;

+	checkpoint->time = 0;

+	checkpoint->sigrenderer = dumb_it_init_sigrenderer(sigdata, 0, startorder);

+	if (!checkpoint->sigrenderer) {

+		free(checkpoint);

+		return 0;

+	}

+	checkpoint->sigrenderer->callbacks->loop = &dumb_it_callback_terminate;

+	checkpoint->sigrenderer->callbacks->xm_speed_zero = &dumb_it_callback_terminate;

+	checkpoint->sigrenderer->callbacks->global_volume_zero = &dumb_it_callback_terminate;

+

+	if (sigdata->checkpoint)

+	{

+		IT_CHECKPOINT *checkpoint = sigdata->checkpoint;

+		while (checkpoint) {

+			IT_CHECKPOINT *next = checkpoint->next;

+			_dumb_it_end_sigrenderer(checkpoint->sigrenderer);

+			free(checkpoint);

+			checkpoint = next;

+		}

+	}

+

+	sigdata->checkpoint = checkpoint;

+

+	for (;;) {

+		long l;

+		DUMB_IT_SIGRENDERER *sigrenderer = dup_sigrenderer(checkpoint->sigrenderer, 0, checkpoint->sigrenderer->callbacks);

+		checkpoint->sigrenderer->callbacks = NULL;

+		if (!sigrenderer) {

+			checkpoint->next = NULL;

+			return checkpoint->time;

+		}

+

+		l = it_sigrenderer_get_samples(sigrenderer, 0, 1.0f, IT_CHECKPOINT_INTERVAL, NULL);

+		if (l < IT_CHECKPOINT_INTERVAL) {

+			_dumb_it_end_sigrenderer(sigrenderer);

+			checkpoint->next = NULL;

+			return checkpoint->time + l;

+		}

+

+		checkpoint->next = malloc(sizeof(*checkpoint->next));

+		if (!checkpoint->next) {

+			_dumb_it_end_sigrenderer(sigrenderer);

+			return checkpoint->time + IT_CHECKPOINT_INTERVAL;

+		}

+

+		checkpoint->next->time = checkpoint->time + IT_CHECKPOINT_INTERVAL;

+		checkpoint = checkpoint->next;

+		checkpoint->sigrenderer = sigrenderer;

+

+		if (checkpoint->time >= FUCKIT_THRESHOLD) {

+			checkpoint->next = NULL;

+			return 0;

+		}

+	}

+}

+

+

+

+void dumb_it_do_initial_runthrough(DUH *duh)

+{

+	if (duh) {

+		DUMB_IT_SIGDATA *sigdata = duh_get_it_sigdata(duh);

+

+		if (sigdata)

+			duh_set_length(duh, dumb_it_build_checkpoints(sigdata, 0));

+	}

+}

+

+static int is_pattern_silent(IT_PATTERN * pattern, int order) {

+	int ret = 1;

+	IT_ENTRY * entry, * end;

+	if (!pattern || !pattern->n_rows || !pattern->n_entries || !pattern->entry) return 2;

+

+	if ( pattern->n_entries == pattern->n_rows ) {

+		int n;

+		entry = pattern->entry;

+		for ( n = 0; n < pattern->n_entries; ++n, ++entry ) {

+			if ( !IT_IS_END_ROW(entry) ) break;

+		}

+		if ( n == pattern->n_entries ) return 2;

+		// broken?

+	}

+

+	entry = pattern->entry;

+	end = entry + pattern->n_entries;

+

+	while (entry < end) {

+		if (!IT_IS_END_ROW(entry)) {

+			if (entry->mask & (IT_ENTRY_INSTRUMENT | IT_ENTRY_VOLPAN))

+				return 0;

+			if (entry->mask & IT_ENTRY_NOTE && entry->note < 120)

+				return 0;

+			if (entry->mask & IT_ENTRY_EFFECT) {

+				switch (entry->effect) {

+					case IT_SET_GLOBAL_VOLUME:

+						if (entry->effectvalue) return 0;

+						break;

+

+					case IT_SET_SPEED:

+						if (entry->effectvalue > 64) ret++;

+						break;

+

+					case IT_SET_SONG_TEMPO:

+					case IT_XM_KEY_OFF:

+						break;

+

+					case IT_JUMP_TO_ORDER:

+						if (entry->effectvalue != order)

+							return 0;

+						break;

+

+					case IT_S:

+						switch (entry->effectvalue >> 4) {

+							case 0: // meh bastard

+								if ( entry->effectvalue != 0 ) return 0;

+								break;

+

+							case IT_S_FINE_PATTERN_DELAY:

+							case IT_S_PATTERN_LOOP:

+							case IT_S_PATTERN_DELAY:

+								ret++;

+								break;

+

+							case IT_S7:

+								if ((entry->effectvalue & 15) > 2)

+									return 0;

+								break;

+

+							default:

+								return 0;

+						}

+						break;

+

+					// clever idiot with his S L O W crap; do nothing

+					case IT_VOLSLIDE_TONEPORTA:

+					case IT_SET_SAMPLE_OFFSET:

+					case IT_GLOBAL_VOLUME_SLIDE:

+						if ( entry->effectvalue != 0 ) return 0;

+						break;

+

+					// genius also uses this instead of jump to order by mistake, meh, and it's bloody BCD

+					case IT_BREAK_TO_ROW:						

+						if ( ( ( entry->effectvalue >> 4 ) * 10 + ( entry->effectvalue & 15 ) ) != order ) return 0;

+						break;

+

+					default:

+						return 0;

+				}

+			}

+		}

+		entry++;

+	}

+

+	return ret;

+}

+

+int dumb_it_trim_silent_patterns(DUH * duh) {

+	int n;

+	DUMB_IT_SIGDATA *sigdata;

+

+	if (!duh) return -1;

+

+	sigdata = duh_get_it_sigdata(duh);

+

+	if (!sigdata || !sigdata->order || !sigdata->pattern) return -1;

+

+	for (n = 0; n < sigdata->n_orders; n++) {

+		int p = sigdata->order[n];

+		if (p < sigdata->n_patterns) {

+			IT_PATTERN * pattern = &sigdata->pattern[p];

+			if (is_pattern_silent(pattern, n) > 1) {

+				pattern->n_rows = 1;

+				pattern->n_entries = 0;

+				if (pattern->entry)

+				{

+					free(pattern->entry);

+					pattern->entry = NULL;

+				}

+			} else

+				break;

+		}

+	}

+

+	if (n == sigdata->n_orders) return -1;

+

+	for (n = sigdata->n_orders - 1; n >= 0; n--) {

+		int p = sigdata->order[n];

+		if (p < sigdata->n_patterns) {

+			IT_PATTERN * pattern = &sigdata->pattern[p];

+			if (is_pattern_silent(pattern, n) > 1) {

+				pattern->n_rows = 1;

+				pattern->n_entries = 0;

+				if (pattern->entry)

+				{

+					free(pattern->entry);

+					pattern->entry = NULL;

+				}

+			} else

+				break;

+		}

+	}

+

+	if (n < 0) return -1;

+

+	/*duh->length = dumb_it_build_checkpoints(sigdata, 0);*/

+

+	return 0;

+}

+

+int dumb_it_scan_for_playable_orders(DUMB_IT_SIGDATA *sigdata, dumb_scan_callback callback, void * callback_data)

+{

+	int n;

+	long length;

+	void * ba_played;

+	DUMB_IT_SIGRENDERER * sigrenderer;

+	

+	if (!sigdata->n_orders || !sigdata->order) return -1;

+

+	ba_played = bit_array_create(sigdata->n_orders * 256);

+	if (!ba_played) return -1;

+

+	for (n = 0; n < sigdata->n_orders; n++) {

+		if ((sigdata->order[n] >= sigdata->n_patterns) ||

+			(is_pattern_silent(&sigdata->pattern[sigdata->order[n]], n) > 1))

+			bit_array_set(ba_played, n * 256);

+	}

+

+	for (;;) {

+		for (n = 0; n < sigdata->n_orders; n++) {

+			if (!bit_array_test_range(ba_played, n * 256, 256)) break;

+		}

+

+		if (n == sigdata->n_orders) break;

+

+		sigrenderer = dumb_it_init_sigrenderer(sigdata, 0, n);

+		if (!sigrenderer) {

+			bit_array_destroy(ba_played);

+			return -1;

+		}

+		sigrenderer->callbacks->loop = &dumb_it_callback_terminate;

+		sigrenderer->callbacks->xm_speed_zero = &dumb_it_callback_terminate;

+		sigrenderer->callbacks->global_volume_zero = &dumb_it_callback_terminate;

+

+		length = 0;

+

+		for (;;) {

+			long l;

+

+			l = it_sigrenderer_get_samples(sigrenderer, 0, 1.0f, IT_CHECKPOINT_INTERVAL, NULL);

+			length += l;

+			if (l < IT_CHECKPOINT_INTERVAL || length >= FUCKIT_THRESHOLD) {

+				/* SONG OVA! */

+				break;

+			}

+		}

+

+		if ((*callback)(callback_data, n, length) < 0) return -1;

+

+		bit_array_merge(ba_played, sigrenderer->played, 0);

+

+		_dumb_it_end_sigrenderer(sigrenderer);

+	}

+

+	bit_array_destroy(ba_played);

+

+	return 0;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/itunload.c b/plugins/dumb/dumb-kode54/src/it/itunload.c
new file mode 100644
index 00000000..136fd5c5
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/itunload.c
@@ -0,0 +1,72 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * itunload.c - Code to free an Impulse Tracker       / / \  \

+ *              module from memory.                  | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+void _dumb_it_unload_sigdata(sigdata_t *vsigdata)

+{

+	if (vsigdata) {

+		DUMB_IT_SIGDATA *sigdata = vsigdata;

+		int n;

+

+		if (sigdata->song_message)

+			free(sigdata->song_message);

+

+		if (sigdata->order)

+			free(sigdata->order);

+

+		if (sigdata->instrument)

+			free(sigdata->instrument);

+

+		if (sigdata->sample) {

+			for (n = 0; n < sigdata->n_samples; n++)

+				if (sigdata->sample[n].data)

+					free(sigdata->sample[n].data);

+

+			free(sigdata->sample);

+		}

+

+		if (sigdata->pattern) {

+			for (n = 0; n < sigdata->n_patterns; n++)

+				if (sigdata->pattern[n].entry)

+					free(sigdata->pattern[n].entry);

+			free(sigdata->pattern);

+		}

+

+		if (sigdata->midi)

+			free(sigdata->midi);

+

+		{

+			IT_CHECKPOINT *checkpoint = sigdata->checkpoint;

+			while (checkpoint) {

+				IT_CHECKPOINT *next = checkpoint->next;

+				_dumb_it_end_sigrenderer(checkpoint->sigrenderer);

+				free(checkpoint);

+				checkpoint = next;

+			}

+		}

+

+		free(vsigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/load669.c b/plugins/dumb/dumb-kode54/src/it/load669.c
new file mode 100644
index 00000000..e5a3fc3f
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/load669.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadmod.c - Code to read a 669 Composer module     / / \  \

+ *             file, opening and closing it for      | <  /   \_

+ *             you.                                  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller                                     | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_669_quick(): loads a 669 file into a DUH struct, returning a

+ * pointer to the DUH struct. When you have finished with it, you must

+ * pass the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_669_quick(const char *filename)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = dumb_read_669_quick(f);

+

+	dumbfile_close(f);

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/load6692.c b/plugins/dumb/dumb-kode54/src/it/load6692.c
new file mode 100644
index 00000000..2358838f
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/load6692.c
@@ -0,0 +1,34 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadmod2.c - Code to read a 669 Composer module    / / \  \

+ *              file, opening and closing it for     | <  /   \_

+ *              you, and do an initial run-through.  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller                                     | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_669(): loads a 669 file into a DUH struct, returning a pointer

+ * to the DUH struct. When you have finished with it, you must pass the

+ * pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_669(const char *filename)

+{

+	DUH *duh = dumb_load_669_quick(filename);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadasy.c b/plugins/dumb/dumb-kode54/src/it/loadasy.c
new file mode 100644
index 00000000..86c6ad8c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadasy.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadasy.c - Code to read an ASYLUM Music Format    / / \  \

+ *             module file, opening and closing it   | <  /   \_

+ *             for you.                              |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_asy_quick(): loads a AMF file into a DUH struct, returning a

+ * pointer to the DUH struct. When you have finished with it, you must

+ * pass the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_asy_quick(const char *filename)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = dumb_read_asy_quick(f);

+

+	dumbfile_close(f);

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadasy2.c b/plugins/dumb/dumb-kode54/src/it/loadasy2.c
new file mode 100644
index 00000000..7b253320
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadasy2.c
@@ -0,0 +1,34 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadasy2.c - Code to read an ASYLUM Music Format   / / \  \

+ *              module file, opening and closing it  | <  /   \_

+ *              for you, and do an initial run-      |  \/ /\   /

+ *              through.                              \_  /  > /

+ *                                                      | \ / /

+ * By Chris Moeller.                                    |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_asy(): loads a AMF file into a DUH struct, returning a pointer

+ * to the DUH struct. When you have finished with it, you must pass the

+ * pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_asy(const char *filename)

+{

+	DUH *duh = dumb_load_asy_quick(filename);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadmod.c b/plugins/dumb/dumb-kode54/src/it/loadmod.c
new file mode 100644
index 00000000..1c76302d
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadmod.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadmod.c - Code to read a good old-fashioned      / / \  \

+ *             Amiga module file, opening and        | <  /   \_

+ *             closing it for you.                   |  \/ /\   /

+ *                                                    \_  /  > /

+ * By entheh.                                           | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_mod_quick(): loads a MOD file into a DUH struct, returning a

+ * pointer to the DUH struct. When you have finished with it, you must

+ * pass the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_mod_quick(const char *filename, int restrict)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = dumb_read_mod_quick(f, restrict);

+

+	dumbfile_close(f);

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadmod2.c b/plugins/dumb/dumb-kode54/src/it/loadmod2.c
new file mode 100644
index 00000000..f5ca5310
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadmod2.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadmod2.c - Function to read a good old-          / / \  \

+ *              fashioned Amiga module file,         | <  /   \_

+ *              opening and closing it for you,      |  \/ /\   /

+ *              and do an initial run-through.        \_  /  > /

+ *                                                      | \ / /

+ * Split off from loadmod.c by entheh.                  |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+

+

+

+DUH *dumb_load_mod(const char *filename, int restrict)

+{

+	DUH *duh = dumb_load_mod_quick(filename, restrict);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadmtm.c b/plugins/dumb/dumb-kode54/src/it/loadmtm.c
new file mode 100644
index 00000000..3c974880
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadmtm.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadmtm.c - Code to read a MultiTracker Module     / / \  \

+ *             file, opening and closing it for      | <  /   \_

+ *             you.                                  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller                                     | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_mtm_quick(): loads a MTM file into a DUH struct, returning a

+ * pointer to the DUH struct. When you have finished with it, you must

+ * pass the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_mtm_quick(const char *filename)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = dumb_read_mtm_quick(f);

+

+	dumbfile_close(f);

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadmtm2.c b/plugins/dumb/dumb-kode54/src/it/loadmtm2.c
new file mode 100644
index 00000000..9fc23890
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadmtm2.c
@@ -0,0 +1,34 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadmtm2.c - Code to read a MultiTracker Module    / / \  \

+ *              file, opening and closing it for     | <  /   \_

+ *              you, and do an initial run-through.  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller                                     | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_mtm(): loads a MTM file into a DUH struct, returning a pointer

+ * to the DUH struct. When you have finished with it, you must pass the

+ * pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_mtm(const char *filename)

+{

+	DUH *duh = dumb_load_mtm_quick(filename);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadoldpsm.c b/plugins/dumb/dumb-kode54/src/it/loadoldpsm.c
new file mode 100644
index 00000000..547294b3
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadoldpsm.c
@@ -0,0 +1,43 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadoldpsm.c - Code to read a ProTracker Studio    / / \  \

+ *                file, opening and closing it for   | <  /   \_

+ *                you.                               |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_old_psm_quick(): loads an old PSM file into a DUH struct,

+ * returning a pointer to the DUH struct. When you have finished with it,

+ * you must pass the pointer to unload_duh() so that the memory can be

+ * freed.

+ */

+DUH *dumb_load_old_psm_quick(const char *filename)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = dumb_read_old_psm_quick(f);

+

+	dumbfile_close(f);

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadoldpsm2.c b/plugins/dumb/dumb-kode54/src/it/loadoldpsm2.c
new file mode 100644
index 00000000..ff2e427c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadoldpsm2.c
@@ -0,0 +1,34 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadoldpsm2.c - Code to read a ProTracker Studio   / / \  \

+ *                 file, opening and closing it for  | <  /   \_

+ *                 you, and do an initial run-       |  \/ /\   /

+ *                 through.                           \_  /  > /

+ *                                                      | \ / /

+ * By Chris Moeller.                                    |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_old_psm(): loads an old PSM file into a DUH struct, returning

+ * a pointer to the DUH struct. When you have finished with it, you must

+ * pass the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_old_psm(const char *filename)

+{

+	DUH *duh = dumb_load_old_psm_quick(filename);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadpsm.c b/plugins/dumb/dumb-kode54/src/it/loadpsm.c
new file mode 100644
index 00000000..a6851d5b
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadpsm.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadpsm.c - Code to read a ProTracker Studio       / / \  \

+ *             file, opening and closing it for      | <  /   \_

+ *             you.                                  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_psm_quick(): loads a PSM file into a DUH struct, returning a

+ * pointer to the DUH struct. When you have finished with it, you must

+ * pass the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_psm_quick(const char *filename, int subsong)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = dumb_read_psm_quick(f, subsong);

+

+	dumbfile_close(f);

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadpsm2.c b/plugins/dumb/dumb-kode54/src/it/loadpsm2.c
new file mode 100644
index 00000000..7a12257a
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadpsm2.c
@@ -0,0 +1,34 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadpsm2.c - Code to read a ProTracker Studio      / / \  \

+ *              file, opening and closing it for     | <  /   \_

+ *              you, and do an initial run-through.  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_psm(): loads a PSM file into a DUH struct, returning a pointer

+ * to the DUH struct. When you have finished with it, you must pass the

+ * pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_psm(const char *filename, int subsong)

+{

+	DUH *duh = dumb_load_psm_quick(filename, subsong);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadptm.c b/plugins/dumb/dumb-kode54/src/it/loadptm.c
new file mode 100644
index 00000000..ddcaaec9
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadptm.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadptm.c - Code to read a Poly Tracker v2.03      / / \  \

+ *             file, opening and closing it for      | <  /   \_

+ *             you.                                  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_ptm_quick(): loads a PTM file into a DUH struct, returning a

+ * pointer to the DUH struct. When you have finished with it, you must

+ * pass the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_ptm_quick(const char *filename)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = dumb_read_ptm_quick(f);

+

+	dumbfile_close(f);

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadptm2.c b/plugins/dumb/dumb-kode54/src/it/loadptm2.c
new file mode 100644
index 00000000..ea8982f2
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadptm2.c
@@ -0,0 +1,34 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadptm2.c - Code to read a Poly Tracker v2.03     / / \  \

+ *              file, opening and closing it for     | <  /   \_

+ *              you, and do an initial run-through.  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_ptm(): loads a PTM file into a DUH struct, returning a pointer

+ * to the DUH struct. When you have finished with it, you must pass the

+ * pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_ptm(const char *filename)

+{

+	DUH *duh = dumb_load_ptm_quick(filename);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadriff.c b/plugins/dumb/dumb-kode54/src/it/loadriff.c
new file mode 100644
index 00000000..07994b0f
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadriff.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadriff.c - Code to read a RIFF module file       / / \  \

+ *              opening and closing it for you.      | <  /   \_

+ *                                                   |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_riff_quick(): loads a RIFF file into a DUH struct, returning

+ * a pointer to the DUH struct. When you have finished with it, you must

+ * pass the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH * dumb_load_riff_quick( const char *filename )

+{

+	DUH * duh;

+	DUMBFILE * f = dumbfile_open( filename );

+

+	if ( ! f )

+		return NULL;

+

+	duh = dumb_read_riff_quick( f );

+

+	dumbfile_close( f );

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadriff2.c b/plugins/dumb/dumb-kode54/src/it/loadriff2.c
new file mode 100644
index 00000000..11c5d497
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadriff2.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadriff2.c - Code to read a RIFF module file      / / \  \

+ *               opening and closing it for you,     | <  /   \_

+ *               and do an initial run-through.      |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+

+

+

+DUH *dumb_load_riff(const char *filename)

+{

+	DUH *duh = dumb_load_riff_quick(filename);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loads3m.c b/plugins/dumb/dumb-kode54/src/it/loads3m.c
new file mode 100644
index 00000000..41af114e
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loads3m.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loads3m.c - Code to read a ScreamTracker 3         / / \  \

+ *             file, opening and closing it for      | <  /   \_

+ *             you.                                  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By entheh.                                           | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_s3m_quick(): loads an S3M file into a DUH struct, returning

+ * a pointer to the DUH struct. When you have finished with it, you must

+ * pass the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_s3m_quick(const char *filename)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = dumb_read_s3m_quick(f);

+

+	dumbfile_close(f);

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loads3m2.c b/plugins/dumb/dumb-kode54/src/it/loads3m2.c
new file mode 100644
index 00000000..de81e09a
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loads3m2.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loads3m2.c - Function to read a ScreamTracker 3    / / \  \

+ *              file, opening and closing it for     | <  /   \_

+ *              you, and do an initial run-through.  |  \/ /\   /

+ *                                                    \_  /  > /

+ * Split off from loads3m.c by entheh.                  | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+

+

+

+DUH *dumb_load_s3m(const char *filename)

+{

+	DUH *duh = dumb_load_s3m_quick(filename);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadstm.c b/plugins/dumb/dumb-kode54/src/it/loadstm.c
new file mode 100644
index 00000000..84785208
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadstm.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadstm.c - Code to read a ScreamTracker 2         / / \  \

+ *             file, opening and closing it for      | <  /   \_

+ *             you.                                  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_stm_quick(): loads an STM file into a DUH struct, returning a

+ * pointer to the DUH struct. When you have finished with it, you must

+ * pass the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_stm_quick(const char *filename)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = dumb_read_stm_quick(f);

+

+	dumbfile_close(f);

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadstm2.c b/plugins/dumb/dumb-kode54/src/it/loadstm2.c
new file mode 100644
index 00000000..4655b52d
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadstm2.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadstm2.c - Function to read a ScreamTracker 2    / / \  \

+ *              file, opening and closing it for     | <  /   \_

+ *              you, and do an initial run-through.  |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+

+

+

+DUH *dumb_load_stm(const char *filename)

+{

+	DUH *duh = dumb_load_stm_quick(filename);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadxm.c b/plugins/dumb/dumb-kode54/src/it/loadxm.c
new file mode 100644
index 00000000..a0eba616
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadxm.c
@@ -0,0 +1,42 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadxm.c - Code to read a Fast Tracker II          / / \  \

+ *            file, opening and closing it for       | <  /   \_

+ *            you.                                   |  \/ /\   /

+ *                                                    \_  /  > /

+ * By entheh.                                           | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/* dumb_load_xm_quick(): loads an XM file into a DUH struct, returning a

+ * pointer to the DUH struct. When you have finished with it, you must

+ * pass the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_load_xm_quick(const char *filename)

+{

+	DUH *duh;

+	DUMBFILE *f = dumbfile_open(filename);

+

+	if (!f)

+		return NULL;

+

+	duh = dumb_read_xm_quick(f);

+

+	dumbfile_close(f);

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/loadxm2.c b/plugins/dumb/dumb-kode54/src/it/loadxm2.c
new file mode 100644
index 00000000..242a586d
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/loadxm2.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * loadxm2.c - Function to read a Fast Tracker II     / / \  \

+ *             file, opening and closing it for      | <  /   \_

+ *             you, and do an initial run-through.   |  \/ /\   /

+ *                                                    \_  /  > /

+ * Split off from loadxm.c by entheh.                   | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+

+

+

+DUH *dumb_load_xm(const char *filename)

+{

+	DUH *duh = dumb_load_xm_quick(filename);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/ptmeffect.c b/plugins/dumb/dumb-kode54/src/it/ptmeffect.c
new file mode 100644
index 00000000..b05a5d74
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/ptmeffect.c
@@ -0,0 +1,125 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * ptmeffect.c - Code for converting PTM              / / \  \

+ *               effects to IT effects.              | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Chris Moeller. Based on xmeffect.c              \_  /  > /

+ * by Julien Cugniere.                                  | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+void _dumb_it_ptm_convert_effect(int effect, int value, IT_ENTRY *entry)

+{

+	if (effect >= PTM_N_EFFECTS)

+		return;

+

+	/* Linearisation of the effect number... */

+	if (effect == PTM_E) {

+		effect = PTM_EBASE + HIGH(value);

+		value = LOW(value);

+	}

+

+	/* convert effect */

+	entry->mask |= IT_ENTRY_EFFECT;

+	switch (effect) {

+

+		case PTM_APPREGIO:           effect = IT_ARPEGGIO;           break;

+		case PTM_PORTAMENTO_UP:      effect = IT_PORTAMENTO_UP;      break;

+		case PTM_PORTAMENTO_DOWN:    effect = IT_PORTAMENTO_DOWN;    break;

+		case PTM_TONE_PORTAMENTO:    effect = IT_TONE_PORTAMENTO;    break;

+		case PTM_VIBRATO:            effect = IT_VIBRATO;            break;

+		case PTM_VOLSLIDE_TONEPORTA: effect = IT_VOLSLIDE_TONEPORTA; break;

+		case PTM_VOLSLIDE_VIBRATO:   effect = IT_VOLSLIDE_VIBRATO;   break;

+		case PTM_TREMOLO:            effect = IT_TREMOLO;            break;

+		case PTM_SAMPLE_OFFSET:      effect = IT_SET_SAMPLE_OFFSET;  break;

+		case PTM_VOLUME_SLIDE:       effect = IT_VOLUME_SLIDE;       break;

+		case PTM_POSITION_JUMP:      effect = IT_JUMP_TO_ORDER;      break;

+		case PTM_SET_CHANNEL_VOLUME: effect = IT_SET_CHANNEL_VOLUME; break;

+		case PTM_PATTERN_BREAK:      effect = IT_BREAK_TO_ROW;       break;

+		case PTM_SET_GLOBAL_VOLUME:  effect = IT_SET_GLOBAL_VOLUME;  break;

+		case PTM_RETRIGGER:          effect = IT_RETRIGGER_NOTE;     break;

+		case PTM_FINE_VIBRATO:       effect = IT_FINE_VIBRATO;       break;

+

+		/* TODO properly */

+		case PTM_NOTE_SLIDE_UP:          effect = IT_PTM_NOTE_SLIDE_UP;          break;

+		case PTM_NOTE_SLIDE_DOWN:        effect = IT_PTM_NOTE_SLIDE_DOWN;        break;

+		case PTM_NOTE_SLIDE_UP_RETRIG:   effect = IT_PTM_NOTE_SLIDE_UP_RETRIG;   break;

+		case PTM_NOTE_SLIDE_DOWN_RETRIG: effect = IT_PTM_NOTE_SLIDE_DOWN_RETRIG; break;

+

+		case PTM_SET_TEMPO_BPM:

+			effect = (value < 0x20) ? (IT_SET_SPEED) : (IT_SET_SONG_TEMPO);

+			break;

+

+		case PTM_EBASE+PTM_E_SET_FINETUNE:          effect = SBASE+IT_S_FINETUNE;              break; /** TODO */

+		case PTM_EBASE+PTM_E_SET_LOOP:              effect = SBASE+IT_S_PATTERN_LOOP;          break;

+		case PTM_EBASE+PTM_E_NOTE_CUT:              effect = SBASE+IT_S_DELAYED_NOTE_CUT;      break;

+		case PTM_EBASE+PTM_E_NOTE_DELAY:            effect = SBASE+IT_S_NOTE_DELAY;            break;

+		case PTM_EBASE+PTM_E_PATTERN_DELAY:         effect = SBASE+IT_S_PATTERN_DELAY;         break;

+		case PTM_EBASE+PTM_E_SET_PANNING:           effect = SBASE+IT_S_SET_PAN;               break;

+

+		case PTM_EBASE+PTM_E_FINE_VOLSLIDE_UP:

+			effect = IT_VOLUME_SLIDE;

+			value = EFFECT_VALUE(value, 0xF);

+			break;

+

+		case PTM_EBASE + PTM_E_FINE_VOLSLIDE_DOWN:

+			effect = IT_VOLUME_SLIDE;

+			value = EFFECT_VALUE(0xF, value);

+			break;

+

+		case PTM_EBASE + PTM_E_FINE_PORTA_UP:

+			effect = IT_PORTAMENTO_UP;

+			value = EFFECT_VALUE(0xF, value);

+			break;

+

+		case PTM_EBASE + PTM_E_FINE_PORTA_DOWN:

+			effect = IT_PORTAMENTO_DOWN;

+			value = EFFECT_VALUE(0xF, value);

+			break;

+

+		case PTM_EBASE + PTM_E_RETRIG_NOTE:

+			effect = IT_XM_RETRIGGER_NOTE;

+			value = EFFECT_VALUE(0, value);

+			break;

+

+		case PTM_EBASE + PTM_E_SET_VIBRATO_CONTROL:

+			effect = SBASE+IT_S_SET_VIBRATO_WAVEFORM;

+			value &= ~4; /** TODO: value&4 -> don't retrig wave */

+			break;

+

+		case PTM_EBASE + PTM_E_SET_TREMOLO_CONTROL:

+			effect = SBASE+IT_S_SET_TREMOLO_WAVEFORM;

+			value &= ~4; /** TODO: value&4 -> don't retrig wave */

+			break;

+

+		default:

+			/* user effect (often used in demos for synchronisation) */

+			entry->mask &= ~IT_ENTRY_EFFECT;

+	}

+

+	/* Inverse linearisation... */

+	if (effect >= SBASE && effect < SBASE+16) {

+		value = EFFECT_VALUE(effect-SBASE, value);

+		effect = IT_S;

+	}

+

+	entry->effect = effect;

+	entry->effectvalue = value;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/read669.c b/plugins/dumb/dumb-kode54/src/it/read669.c
new file mode 100644
index 00000000..4cb88d30
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/read669.c
@@ -0,0 +1,447 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * read669.c - Code to read a 669 Composer module     / / \  \

+ *             from an open file.                    | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Chris Moeller.                                  \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>

+#include <math.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+static int it_669_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, int tempo, int breakpoint, unsigned char *buffer, int * used_channels)

+{

+	int pos;

+	int channel;

+	int row;

+	IT_ENTRY *entry;

+

+	pattern->n_rows = 64;

+

+	if (dumbfile_getnc(buffer, 64 * 3 * 8, f) < 64 * 3 * 8)

+		return -1;

+

+	/* compute number of entries */

+	pattern->n_entries = 64 + 1; /* Account for the row end markers, speed command */

+	if (breakpoint < 63) pattern->n_entries++; /* and break to row 0 */

+

+	pos = 0;

+	for (row = 0; row < 64; row++) {

+		for (channel = 0; channel < 8; channel++) {

+			if (buffer[pos+0] != 0xFF || buffer[pos+2] != 0xFF)

+				pattern->n_entries++;

+			pos += 3;

+		}

+	}

+

+	pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry));

+	if (!pattern->entry)

+		return -1;

+

+	if (breakpoint == 63) breakpoint++;

+

+	entry = pattern->entry;

+

+	entry->channel = 8;

+	entry->mask = IT_ENTRY_EFFECT;

+	entry->effect = IT_SET_SPEED;

+	entry->effectvalue = tempo;

+	entry++;

+

+	pos = 0;

+	for (row = 0; row < 64; row++) {

+

+		if (row == breakpoint) {

+			entry->channel = 8;

+			entry->mask = IT_ENTRY_EFFECT;

+			entry->effect = IT_BREAK_TO_ROW;

+			entry->effectvalue = 0;

+			entry++;

+		}

+

+		for (channel = 0; channel < 8; channel++) {

+			if (buffer[pos+0] != 0xFF || buffer[pos+2] != 0xFF) {

+				entry->channel = channel;

+				entry->mask = 0;

+

+				if (buffer[pos+0] < 0xFE) {

+					entry->mask |= IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT;

+					entry->note = (buffer[pos+0] >> 2) + 36;

+					entry->instrument = (((buffer[pos+0] << 4) | (buffer[pos+1] >> 4)) & 0x3F) + 1;

+				}

+				if (buffer[pos+0] <= 0xFE) {

+					entry->mask |= IT_ENTRY_VOLPAN;

+					entry->volpan = ((buffer[pos+1] & 15) << 6) / 15;

+					if (*used_channels < channel + 1) *used_channels = channel + 1;

+				}

+				if (buffer[pos+2] != 0xFF) {

+					entry->mask |= IT_ENTRY_EFFECT;

+					entry->effectvalue = buffer[pos+2] & 15;

+					switch (buffer[pos+2] >> 4) {

+						case 0:

+							entry->effect = IT_PORTAMENTO_UP;

+							break;

+						case 1:

+							entry->effect = IT_PORTAMENTO_DOWN;

+							break;

+						case 2:

+							entry->effect = IT_TONE_PORTAMENTO;

+							break;

+						case 3:

+							entry->effect = IT_S;

+							entry->effectvalue += IT_S_FINETUNE * 16 + 8;

+							break;

+						case 4:

+							entry->effect = IT_VIBRATO;

+							// XXX speed unknown

+							entry->effectvalue |= 0x10;

+							break;

+						case 5:

+							if (entry->effectvalue) {

+								entry->effect = IT_SET_SPEED;

+							} else {

+								entry->mask &= ~IT_ENTRY_EFFECT;

+							}

+							break;

+#if 0

+						/* dunno about this, really... */

+						case 6:

+							if (entry->effectvalue == 0) {

+								entry->effect = IT_PANNING_SLIDE;

+								entry->effectvalue = 0xFE;

+							} else if (entry->effectvalue == 1) {

+								entry->effect = IT_PANNING_SLIDE;

+								entry->effectvalue = 0xEF;

+							} else {

+								entry->mask &= ~IT_ENTRY_EFFECT;

+							}

+							break;

+#endif

+						default:

+							entry->mask &= ~IT_ENTRY_EFFECT;

+							break;

+					}

+					if (*used_channels < channel + 1) *used_channels = channel + 1;

+				}

+

+				entry++;

+			}

+			pos += 3;

+		}

+		IT_SET_END_ROW(entry);

+		entry++;

+	}

+

+	return 0;

+}

+

+

+

+static int it_669_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f)

+{

+	dumbfile_getnc(sample->name, 13, f);

+	sample->name[13] = 0;

+

+	sample->filename[0] = 0;

+

+	sample->length = dumbfile_igetl(f);

+	sample->loop_start = dumbfile_igetl(f);

+	sample->loop_end = dumbfile_igetl(f);

+

+	if (dumbfile_error(f))

+		return -1;

+

+	if (sample->length <= 0) {

+		sample->flags = 0;

+		return 0;

+	}

+

+	sample->flags = IT_SAMPLE_EXISTS;

+

+	sample->global_volume = 64;

+	sample->default_volume = 64;

+

+	sample->default_pan = 0;

+	sample->C5_speed = 8363;

+	// the above line might be wrong

+

+	if ((sample->loop_end > sample->length) && !(sample->loop_start))

+		sample->loop_end = 0;

+

+	if (sample->loop_end > sample->length)

+		sample->loop_end = sample->length;

+

+	if (sample->loop_end - sample->loop_start > 2)

+		sample->flags |= IT_SAMPLE_LOOP;

+

+	sample->vibrato_speed = 0;

+	sample->vibrato_depth = 0;

+	sample->vibrato_rate = 0;

+	sample->vibrato_waveform = 0; // do we have to set _all_ these?

+	sample->finetune = 0;

+	sample->max_resampling_quality = -1;

+

+	return 0;

+}

+

+

+

+static int it_669_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f)

+{

+	long i;

+	long truncated_size;

+

+	/* let's get rid of the sample data coming after the end of the loop */

+	if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) {

+		truncated_size = sample->length - sample->loop_end;

+		sample->length = sample->loop_end;

+	} else {

+		truncated_size = 0;

+	}

+

+	sample->data = malloc(sample->length);

+

+	if (!sample->data)

+		return -1;

+

+	if (sample->length)

+	{

+		i = dumbfile_getnc(sample->data, sample->length, f);

+		

+		if (i < sample->length) {

+			//return -1;

+			// ficking truncated files

+			if (i <= 0) {

+				sample->flags = 0;

+				return 0;

+			}

+			sample->length = i;

+			if (sample->loop_end > i) sample->loop_end = i;

+		} else {

+			/* skip truncated data */

+			dumbfile_skip(f, truncated_size);

+			// Should we be truncating it?

+			if (dumbfile_error(f))

+				return -1;

+		}

+

+		for (i = 0; i < sample->length; i++)

+			((signed char *)sample->data)[i] ^= 0x80;

+	}

+

+	return 0;

+}

+

+

+static DUMB_IT_SIGDATA *it_669_load_sigdata(DUMBFILE *f, int * ext)

+{

+	DUMB_IT_SIGDATA *sigdata;

+	int n_channels;

+	int i;

+	unsigned char tempolist[128];

+	unsigned char breaklist[128];

+

+	i = dumbfile_igetw(f);

+	if (i != 0x6669 && i != 0x4E4A) return NULL;

+

+	*ext = (i == 0x4E4A);

+

+	sigdata = malloc(sizeof(*sigdata));

+	if (!sigdata) {

+		return NULL;

+	}

+

+	if (dumbfile_getnc(sigdata->name, 36, f) < 36) {

+		free(sigdata);

+		return NULL;

+	}

+	sigdata->name[36] = 0;

+

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+	sigdata->sample = NULL;

+

+	sigdata->n_instruments = 0;

+

+	sigdata->song_message = malloc(72 + 2 + 1);

+	if (!sigdata->song_message) {

+		free(sigdata);

+		return NULL;

+	}

+	if (dumbfile_getnc(sigdata->song_message, 36, f) < 36) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+	sigdata->song_message[36] = 13;

+	sigdata->song_message[36 + 1] = 10;

+	if (dumbfile_getnc(sigdata->song_message + 38, 36, f) < 36) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+	sigdata->song_message[38 + 36] = 0;

+

+	sigdata->n_samples = dumbfile_getc(f);

+	sigdata->n_patterns = dumbfile_getc(f);

+	sigdata->restart_position = dumbfile_getc(f);

+

+	if ((sigdata->n_samples) > 64 || (sigdata->n_patterns > 128)) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	sigdata->order = malloc(128); /* We may need to scan the extra ones! */

+	if (!sigdata->order) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+	if (dumbfile_getnc(sigdata->order, 128, f) < 128) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	for (i = 0; i < 128; i++) {

+		if (sigdata->order[i] == 255) break;

+		if (sigdata->order[i] >= sigdata->n_patterns) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+	}

+	if (!i) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+	sigdata->n_orders = i;

+

+	if (dumbfile_getnc(tempolist, 128, f) < 128) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	if (dumbfile_getnc(breaklist, 128, f) < 128) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));

+	if (!sigdata->sample) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	for (i = 0; i < sigdata->n_samples; i++)

+		sigdata->sample[i].data = NULL;

+

+	for (i = 0; i < sigdata->n_samples; i++) {

+		if (it_669_read_sample_header(&sigdata->sample[i], f)) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+	}

+

+	/* May as well try to save a tiny bit of memory. */

+	if (sigdata->n_orders < 128) {

+		unsigned char *order = realloc(sigdata->order, sigdata->n_orders);

+		if (order) sigdata->order = order;

+	}

+

+	sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));

+	if (!sigdata->pattern) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+	for (i = 0; i < sigdata->n_patterns; i++)

+		sigdata->pattern[i].entry = NULL;

+

+	n_channels = 0;

+

+	/* Read in the patterns */

+	{

+		unsigned char *buffer = malloc(64 * 3 * 8); /* 64 rows * 3 bytes * 8 channels */

+		if (!buffer) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		for (i = 0; i < sigdata->n_patterns; i++) {

+			if (it_669_read_pattern(&sigdata->pattern[i], f, tempolist[i], breaklist[i], buffer, &n_channels) != 0) {

+				free(buffer);

+				_dumb_it_unload_sigdata(sigdata);

+				return NULL;

+			}

+		}

+		free(buffer);

+	}

+

+	sigdata->n_pchannels = n_channels;

+

+	/* And finally, the sample data */

+	for (i = 0; i < sigdata->n_samples; i++) {

+		if (it_669_read_sample_data(&sigdata->sample[i], f)) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+	}

+

+	/* Now let's initialise the remaining variables, and we're done! */

+	sigdata->flags = IT_OLD_EFFECTS | IT_LINEAR_SLIDES | IT_STEREO | IT_WAS_A_669;

+

+	sigdata->global_volume = 128;

+	sigdata->mixing_volume = 48;

+	sigdata->speed = 4;

+	sigdata->tempo = 78;

+	sigdata->pan_separation = 128;

+

+	memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i += 2) {

+		sigdata->channel_pan[i+0] = 48;

+		sigdata->channel_pan[i+1] = 16;

+	}

+

+	_dumb_it_fix_invalid_orders(sigdata);

+

+	return sigdata;

+}

+

+

+

+DUH *dumb_read_669_quick(DUMBFILE *f)

+{

+	sigdata_t *sigdata;

+	int ext;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_669_load_sigdata(f, &ext);

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		const char *tag[2][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		tag[1][1] = ext ? "669 Extended" : "669";

+		return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/read6692.c b/plugins/dumb/dumb-kode54/src/it/read6692.c
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/read6692.c
diff --git a/plugins/dumb/dumb-kode54/src/it/readam.c b/plugins/dumb/dumb-kode54/src/it/readam.c
new file mode 100644
index 00000000..14ad3c07
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readam.c
@@ -0,0 +1,752 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readam.c - Code to read a RIFF AM module           / / \  \

+ *             from a parsed RIFF structure.         | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Chris Moeller.                                  \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+#include "internal/riff.h"

+

+static int it_riff_am_process_sample( IT_SAMPLE * sample, const unsigned char * data, int len, int ver )

+{

+	int header_length;

+	int default_pan;

+	int default_volume;

+	int flags;

+	int length;

+	int length_bytes;

+	int loop_start;

+	int loop_end;

+	int sample_rate;

+

+	if ( ver == 0 )

+	{

+		if ( len < 0x38 )

+			return -1;

+

+		header_length = 0x38;

+

+		memcpy( sample->name, data, 28 );

+		sample->name[ 28 ] = 0;

+

+		default_pan = data[ 0x1C ];

+		default_volume = data[ 0x1D ];

+		flags = data[ 0x1E ] | ( data[ 0x1F ] << 8 );

+		length = data[ 0x20 ] | ( data[ 0x21 ] << 8 ) | ( data[ 0x22 ] << 16 ) | ( data[ 0x23 ] << 24 );

+		loop_start = data[ 0x24 ] | ( data[ 0x25 ] << 8 ) | ( data[ 0x26 ] << 16 ) | ( data[ 0x27 ] << 24 );

+		loop_end = data[ 0x28 ] | ( data[ 0x29 ] << 8 ) | ( data[ 0x2A ] << 16 ) | ( data[ 0x2B ] << 24 );

+		sample_rate = data[ 0x2C ] | ( data[ 0x2D ] << 8 ) | ( data[ 0x2E ] << 16 ) | ( data[ 0x2F ] << 24 );

+	}

+	else

+	{

+		if (len < 4) return -1;

+

+		header_length = data[ 0 ] | ( data[ 1 ] << 8 ) | ( data[ 2 ] << 16 ) | ( data[ 3 ] << 24 );

+		if ( header_length < 0x40 )

+			return -1;

+		if ( header_length + 4 > len )

+			return -1;

+

+		data += 4;

+		len -= 4;

+

+		memcpy( sample->name, data, 32 );

+		sample->name[ 32 ] = 0;

+

+		default_pan = data[ 0x20 ] | ( data[ 0x21 ] << 8 );

+		default_volume = data[ 0x22 ] | ( data[ 0x23 ] << 8 );

+		flags = data[ 0x24 ] | ( data[ 0x25 ] << 8 ); /* | ( data[ 0x26 ] << 16 ) | ( data[ 0x27 ] << 24 );*/

+		length = data[ 0x28 ] | ( data[ 0x29 ] << 8 ) | ( data[ 0x2A ] << 16 ) | ( data[ 0x2B ] << 24 );

+		loop_start = data[ 0x2C ] | ( data[ 0x2D ] << 8 ) | ( data[ 0x2E ] << 16 ) | ( data[ 0x2F ] << 24 );

+		loop_end = data[ 0x30 ] | ( data[ 0x31 ] << 8 ) | ( data[ 0x32 ] << 16 ) | ( data[ 0x33 ] << 24 );

+		sample_rate = data[ 0x34 ] | ( data[ 0x35 ] << 8 ) | ( data[ 0x36 ] << 16 ) | ( data[ 0x37 ] << 24 );

+

+		if ( default_pan > 0x7FFF || default_volume > 0x7FFF )

+			return -1;

+

+		default_pan = default_pan * 64 / 32767;

+		default_volume = default_volume * 64 / 32767;

+	}

+

+	/*if ( data[ 0x38 ] || data[ 0x39 ] || data[ 0x3A ] || data[ 0x3B ] )

+		return -1;*/

+

+	if ( ! length ) {

+		sample->flags &= ~IT_SAMPLE_EXISTS;

+		return 0;

+	}

+

+	if ( flags & ~( 0x8000 | 0x80 | 0x20 | 0x10 | 0x08 | 0x04 ) )

+		return -1;

+

+	length_bytes = length << ( ( flags & 0x04 ) >> 2 );

+

+	if ( length_bytes + header_length > len )

+		return -1;

+

+	sample->flags = 0;

+

+	if ( flags & 0x80 ) sample->flags |= IT_SAMPLE_EXISTS;

+	if ( flags & 0x04 ) sample->flags |= IT_SAMPLE_16BIT;

+

+	sample->length = length;

+	sample->loop_start = loop_start;

+	sample->loop_end = loop_end;

+	sample->C5_speed = sample_rate;

+	sample->default_volume = default_volume;

+	sample->default_pan = default_pan | ( ( flags & 0x20 ) << 2 );

+	sample->filename[0] = 0;

+	sample->global_volume = 64;

+	sample->vibrato_speed = 0;

+	sample->vibrato_depth = 0;

+	sample->vibrato_rate = 0;

+	sample->vibrato_waveform = IT_VIBRATO_SINE;

+	sample->finetune = 0;

+	sample->max_resampling_quality = -1;

+

+	if ( flags & 0x08 )

+	{

+		if (((unsigned int)sample->loop_end <= (unsigned int)sample->length) &&

+			((unsigned int)sample->loop_start < (unsigned int)sample->loop_end))

+		{

+			sample->length = sample->loop_end;

+			sample->flags |= IT_SAMPLE_LOOP;

+			if ( flags & 0x10 ) sample->flags |= IT_SAMPLE_PINGPONG_LOOP;

+		}

+	}

+

+	length_bytes = sample->length << ( ( flags & 0x04 ) >> 2 );

+

+	sample->data = malloc( length_bytes );

+	if ( ! sample->data )

+		return -1;

+

+	memcpy( sample->data, data + header_length, length_bytes );

+

+	return 0;

+}

+

+static int it_riff_am_process_pattern( IT_PATTERN * pattern, const unsigned char * data, int len, int ver )

+{

+	int nrows, row, pos;

+	unsigned flags;

+	IT_ENTRY * entry;

+

+	nrows = data[0] + 1;

+

+	pattern->n_rows = nrows;

+

+	data += 1;

+	len -= 1;

+

+	pattern->n_entries = 0;

+

+	row = 0;

+	pos = 0;

+

+	while ( (row < nrows) && (pos < len) ) {

+		if ( ! data[ pos ] ) {

+			++ row;

+			++ pos;

+			continue;

+		}

+

+		flags = data[ pos++ ] & 0xE0;

+

+		if (flags) {

+			++ pattern->n_entries;

+			if (flags & 0x80) pos += 2;

+			if (flags & 0x40) pos += 2;

+			if (flags & 0x20) pos ++;

+		}

+	}

+

+	if ( ! pattern->n_entries ) return 0;

+

+	pattern->n_entries += nrows;

+

+	pattern->entry = malloc( pattern->n_entries * sizeof( * pattern->entry ) );

+	if ( ! pattern->entry ) return -1;

+

+	entry = pattern->entry;

+

+	row = 0;

+	pos = 0;

+

+	while ( ( row < nrows ) && ( pos < len ) )

+	{

+		if ( ! data[ pos ] )

+		{

+			IT_SET_END_ROW( entry );

+			++ entry;

+			++ row;

+			++ pos;

+			continue;

+		}

+

+		flags = data[ pos++ ];

+		entry->channel = flags & 0x1F;

+		entry->mask = 0;

+

+		if (flags & 0xE0)

+		{

+			if ( flags & 0x80 )

+			{

+				_dumb_it_xm_convert_effect( data[ pos + 1 ], data[ pos ], entry, 0 );

+				pos += 2;

+			}

+

+			if ( flags & 0x40 )

+			{

+				if ( data[ pos ] )

+				{

+					entry->mask |= IT_ENTRY_INSTRUMENT;

+					entry->instrument = data[ pos ];

+				}

+				if ( data[ pos + 1 ] )

+				{

+					entry->mask |= IT_ENTRY_NOTE;

+					entry->note = data[ pos + 1 ] - 1;

+				}

+				pos += 2;

+			}

+

+			if ( flags & 0x20 )

+			{

+				entry->mask |= IT_ENTRY_VOLPAN;

+				if ( ver == 0 ) entry->volpan = data[ pos ];

+				else entry->volpan = data[ pos ] * 64 / 127;

+				++ pos;

+			}

+

+			if (entry->mask) entry++;

+		}

+	}

+

+	while ( row < nrows )

+	{

+		IT_SET_END_ROW( entry );

+		++ entry;

+		++ row;

+	}

+

+	pattern->n_entries = entry - pattern->entry;

+	if ( ! pattern->n_entries ) return -1;

+

+	return 0;

+}

+

+static DUMB_IT_SIGDATA *it_riff_amff_load_sigdata( struct riff * stream )

+{

+	DUMB_IT_SIGDATA *sigdata;

+

+	int n, o, found;

+

+	unsigned char * ptr;

+

+	if ( ! stream ) goto error;

+

+	if ( stream->type != DUMB_ID( 'A', 'M', 'F', 'F' ) ) goto error;

+

+	sigdata = malloc( sizeof( *sigdata ) );

+	if ( ! sigdata ) goto error;

+

+	sigdata->n_patterns = 0;

+	sigdata->n_samples = 0;

+	sigdata->name[0] = 0;

+

+	found = 0;

+

+	for ( n = 0; n < stream->chunk_count; ++n )

+	{

+		struct riff_chunk * c = stream->chunks + n;

+		switch( c->type )

+		{

+		case DUMB_ID( 'M', 'A', 'I', 'N' ):

+			/* initialization data */

+			if ( ( found & 1 ) || ( c->size < 0x48 ) ) goto error_sd;

+			found |= 1;

+			break;

+

+		case DUMB_ID( 'O', 'R', 'D', 'R' ):

+			if ( ( found & 2 ) || ( c->size < 1 ) ) goto error_sd;

+			found |= 2;

+			break;

+

+		case DUMB_ID( 'P', 'A', 'T', 'T' ):

+			ptr = ( unsigned char * ) c->data;

+			if ( ptr[ 0 ] >= sigdata->n_patterns ) sigdata->n_patterns = ptr[ 0 ] + 1;

+			o = ptr[ 1 ] | ( ptr[ 2 ] << 8 ) | ( ptr[ 3 ] << 16 ) | ( ptr[ 4 ] << 24 );

+			if ( o + 5 > c->size ) goto error_sd;

+			break;

+

+		case DUMB_ID( 'I', 'N', 'S', 'T' ):

+			{

+				if ( c->size < 0xE1 ) goto error;

+				ptr = ( unsigned char * ) c->data;

+				if ( ptr[ 1 ] >= sigdata->n_samples ) sigdata->n_samples = ptr[ 1 ] + 1;

+				if ( c->size >= 0x121 && ( ptr[ 0xE1 ] == 'S' && ptr[ 0xE2 ] == 'A' &&

+					ptr[ 0xE3 ] == 'M' && ptr[ 0xE4 ] == 'P' ) )

+				{

+					unsigned size = ptr[ 0xE5 ] | ( ptr[ 0xE6 ] << 8 ) | ( ptr[ 0xE7 ] << 16 ) | ( ptr[ 0xE8 ] << 24 );

+					if ( size + 0xE1 + 8 > c->size ) goto error;

+				}

+			}

+			break;

+		}

+	}

+

+	if ( found != 3 || !sigdata->n_samples || !sigdata->n_patterns ) goto error_sd;

+

+	if ( sigdata->n_samples > 255 || sigdata->n_patterns > 255 ) goto error_sd;

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->sample = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->mixing_volume = 48;

+	sigdata->pan_separation = 128;

+

+	sigdata->n_instruments = 0;

+	sigdata->n_orders = 0;

+

+	memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);

+

+	for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) {

+		sigdata->channel_pan[n  ] = 16;

+		sigdata->channel_pan[n+1] = 48;

+		sigdata->channel_pan[n+2] = 48;

+		sigdata->channel_pan[n+3] = 16;

+	}

+

+	for ( n = 0; n < stream->chunk_count; ++n )

+	{

+		struct riff_chunk * c = stream->chunks + n;

+		switch ( c->type )

+		{

+		case DUMB_ID( 'M', 'A', 'I', 'N' ):

+			ptr = ( unsigned char * ) c->data;

+			memcpy( sigdata->name, c->data, 64 );

+			sigdata->name[ 64 ] = 0;

+			sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M;

+			if ( ! ( ptr[ 0x40 ] & 1 ) ) sigdata->flags |= IT_LINEAR_SLIDES;

+			if ( ( ptr[ 0x40 ] & ~3 ) || ! ( ptr[ 0x40 ] & 2 ) ) goto error_usd; // unknown flags

+			sigdata->n_pchannels = ptr[ 0x41 ];

+			sigdata->speed = ptr[ 0x42 ];

+			sigdata->tempo = ptr[ 0x43 ];

+

+			sigdata->global_volume = ptr[ 0x48 ];

+

+			if ( c->size < 0x48 + sigdata->n_pchannels ) goto error_usd;

+

+			for ( o = 0; o < sigdata->n_pchannels; ++o )

+			{

+				sigdata->channel_pan[ o ] = ptr[ 0x49 + o ];

+				if ( ptr[ 0x49 + o ] >= 128 )

+				{

+					sigdata->channel_volume[ o ] = 0;

+				}

+			}

+			break;

+		}

+	}

+

+	sigdata->pattern = malloc( sigdata->n_patterns * sizeof( *sigdata->pattern ) );

+	if ( ! sigdata->pattern ) goto error_usd;

+	for ( n = 0; n < sigdata->n_patterns; ++n )

+		sigdata->pattern[ n ].entry = NULL;

+

+	sigdata->sample = malloc( sigdata->n_samples * sizeof( *sigdata->sample ) );

+	if ( ! sigdata->sample ) goto error_usd;

+	for ( n = 0; n < sigdata->n_samples; ++n )

+	{

+		IT_SAMPLE * sample = sigdata->sample + n;

+		sample->data = NULL;

+		sample->flags = 0;

+		sample->name[ 0 ] = 0;

+	}

+

+	for ( n = 0; n < stream->chunk_count; ++n )

+	{

+		struct riff_chunk * c = stream->chunks + n;

+		switch ( c->type )

+		{

+		case DUMB_ID( 'O', 'R', 'D', 'R' ):

+			ptr = ( unsigned char * ) c->data;

+			sigdata->n_orders = ptr[ 0 ] + 1;

+			if ( sigdata->n_orders + 1 > c->size ) goto error_usd;

+			sigdata->order = malloc( sigdata->n_orders );

+			if ( ! sigdata->order ) goto error_usd;

+			memcpy( sigdata->order, ptr + 1, sigdata->n_orders );

+			break;

+

+		case DUMB_ID( 'P', 'A', 'T', 'T' ):

+			ptr = ( unsigned char * ) c->data;

+			o = ptr[ 1 ] | ( ptr[ 2 ] << 8 ) | ( ptr[ 3 ] << 16 ) | ( ptr[ 4 ] << 24 );

+			if ( it_riff_am_process_pattern( sigdata->pattern + ptr[ 0 ], ptr + 5, o, 0 ) ) goto error_usd;

+			break;

+

+		case DUMB_ID( 'I', 'N', 'S', 'T' ):

+			{

+				IT_SAMPLE * sample;

+				ptr = ( unsigned char * ) c->data;

+				sample = sigdata->sample + ptr[ 1 ];

+				if ( c->size >= 0x121 && ( ptr[ 0xE1 ] == 'S' && ptr[ 0xE2 ] == 'A' &&

+					ptr[ 0xE3 ] == 'M' && ptr[ 0xE4 ] == 'P' ) )

+				{

+					unsigned size = ptr[ 0xE5 ] | ( ptr[ 0xE6 ] << 8 ) | ( ptr[ 0xE7 ] << 16 ) | ( ptr[ 0xE8 ] << 24 );

+					if ( it_riff_am_process_sample( sample, ptr + 0xE1 + 8, size, 0 ) ) goto error_usd;

+				}

+				else

+				{

+					memcpy( sample->name, ptr + 2, 28 );

+					sample->name[ 28 ] = 0;

+				}

+			}

+			break;

+		}

+	}

+

+	_dumb_it_fix_invalid_orders( sigdata );

+

+	return sigdata;

+

+error_usd:

+	_dumb_it_unload_sigdata( sigdata );

+	goto error;

+error_sd:

+	free( sigdata );

+error:

+	return NULL;

+}

+

+static DUMB_IT_SIGDATA *it_riff_am_load_sigdata( struct riff * stream )

+{

+	DUMB_IT_SIGDATA *sigdata;

+

+	int n, o, p, found;

+

+	unsigned char * ptr;

+

+	if ( ! stream ) goto error;

+

+	if ( stream->type != DUMB_ID( 'A', 'M', ' ', ' ' ) ) goto error;

+

+	sigdata = malloc(sizeof(*sigdata));

+	if ( ! sigdata ) goto error;

+

+	sigdata->n_patterns = 0;

+	sigdata->n_samples = 0;

+	sigdata->name[0] = 0;

+

+	found = 0;

+

+	for ( n = 0; n < stream->chunk_count; ++n )

+	{

+		struct riff_chunk * c = stream->chunks + n;

+		switch( c->type )

+		{

+		case DUMB_ID( 'I' ,'N' ,'I' ,'T' ):

+			/* initialization data */

+			if ( ( found & 1 ) || ( c->size < 0x48 ) ) goto error_sd;

+			found |= 1;

+			break;

+

+		case DUMB_ID( 'O', 'R', 'D', 'R' ):

+			if ( ( found & 2 ) || ( c->size < 1 ) ) goto error_sd;

+			found |= 2;

+			break;

+

+		case DUMB_ID( 'P', 'A', 'T', 'T' ):

+			ptr = ( unsigned char * ) c->data;

+			if ( ptr[ 0 ] >= sigdata->n_patterns ) sigdata->n_patterns = ptr[ 0 ] + 1;

+			o = ptr[ 1 ] | ( ptr[ 2 ] << 8 ) | ( ptr[ 3 ] << 16 ) | ( ptr[ 4 ] << 24 );

+			if ( o + 5 > c->size ) goto error_sd;

+			break;

+

+		case DUMB_ID( 'R', 'I', 'F', 'F' ):

+			{

+				struct riff * str = ( struct riff * ) c->data;

+				switch ( str->type )

+				{

+				case DUMB_ID( 'A', 'I', ' ', ' ' ):

+					for ( o = 0; o < str->chunk_count; ++o )

+					{

+						struct riff_chunk * chk = str->chunks + o;

+						switch( chk->type )

+						{

+						case DUMB_ID( 'I', 'N', 'S', 'T' ):

+							{

+								struct riff * temp;

+								unsigned size;

+								unsigned sample_found;

+								ptr = ( unsigned char * ) chk->data;

+								size = ptr[ 0 ] | ( ptr[ 1 ] << 8 ) | ( ptr[ 2 ] << 16 ) | ( ptr[ 3 ] << 24 );

+								if ( size < 0x142 ) goto error;

+								sample_found = 0;

+								if ( ptr[ 5 ] >= sigdata->n_samples ) sigdata->n_samples = ptr[ 5 ] + 1;

+								temp = riff_parse( ptr + 4 + size, chk->size - size - 4, 1 );

+								if ( temp )

+								{

+									if ( temp->type == DUMB_ID( 'A', 'S', ' ', ' ' ) )

+									{

+										for ( p = 0; p < temp->chunk_count; ++p )

+										{

+											if ( temp->chunks[ p ].type == DUMB_ID( 'S', 'A', 'M', 'P' ) )

+											{

+												if ( sample_found )

+												{

+													riff_free( temp );

+													goto error;

+												}

+												sample_found = 1;

+											}

+										}

+									}

+									riff_free( temp );

+								}

+							}

+						}

+					}

+				}

+			}

+			break;

+		}

+	}

+

+	if ( found != 3 || !sigdata->n_samples || !sigdata->n_patterns ) goto error_sd;

+

+	if ( sigdata->n_samples > 255 || sigdata->n_patterns > 255 ) goto error_sd;

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->sample = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->mixing_volume = 48;

+	sigdata->pan_separation = 128;

+

+	sigdata->n_instruments = 0;

+	sigdata->n_orders = 0;

+

+	memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);

+

+	for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) {

+		sigdata->channel_pan[n  ] = 16;

+		sigdata->channel_pan[n+1] = 48;

+		sigdata->channel_pan[n+2] = 48;

+		sigdata->channel_pan[n+3] = 16;

+	}

+

+	for ( n = 0; n < stream->chunk_count; ++n )

+	{

+		struct riff_chunk * c = stream->chunks + n;

+		switch ( c->type )

+		{

+		case DUMB_ID( 'I', 'N', 'I', 'T' ):

+			ptr = ( unsigned char * ) c->data;

+			memcpy( sigdata->name, c->data, 64 );

+			sigdata->name[ 64 ] = 0;

+			sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M;

+			if ( ! ( ptr[ 0x40 ] & 1 ) ) sigdata->flags |= IT_LINEAR_SLIDES;

+			if ( ( ptr[ 0x40 ] & ~3 ) || ! ( ptr[ 0x40 ] & 2 ) ) goto error_usd; // unknown flags

+			sigdata->n_pchannels = ptr[ 0x41 ];

+			sigdata->speed = ptr[ 0x42 ];

+			sigdata->tempo = ptr[ 0x43 ];

+

+			sigdata->global_volume = ptr[ 0x48 ];

+

+			if ( c->size < 0x48 + sigdata->n_pchannels ) goto error_usd;

+

+			for ( o = 0; o < sigdata->n_pchannels; ++o )

+			{

+				if ( ptr[ 0x49 + o ] <= 128 )

+				{

+					sigdata->channel_pan[ o ] = ptr[ 0x49 + o ] / 2;

+				}

+				else

+				{

+					sigdata->channel_volume[ o ] = 0;

+				}

+			}

+			break;

+		}

+	}

+

+	sigdata->pattern = malloc( sigdata->n_patterns * sizeof( *sigdata->pattern ) );

+	if ( ! sigdata->pattern ) goto error_usd;

+	for ( n = 0; n < sigdata->n_patterns; ++n )

+		sigdata->pattern[ n ].entry = NULL;

+

+	sigdata->sample = malloc( sigdata->n_samples * sizeof( *sigdata->sample ) );

+	if ( ! sigdata->sample ) goto error_usd;

+	for ( n = 0; n < sigdata->n_samples; ++n )

+	{

+		IT_SAMPLE * sample = sigdata->sample + n;

+		sample->data = NULL;

+		sample->flags = 0;

+		sample->name[ 0 ] = 0;

+	}

+

+	for ( n = 0; n < stream->chunk_count; ++n )

+	{

+		struct riff_chunk * c = stream->chunks + n;

+		switch ( c->type )

+		{

+		case DUMB_ID( 'O', 'R', 'D', 'R' ):

+			ptr = ( unsigned char * ) c->data;

+			sigdata->n_orders = ptr[ 0 ] + 1;

+			if ( sigdata->n_orders + 1 > c->size ) goto error_usd;

+			sigdata->order = malloc( sigdata->n_orders );

+			if ( ! sigdata->order ) goto error_usd;

+			memcpy( sigdata->order, ptr + 1, sigdata->n_orders );

+			break;

+

+		case DUMB_ID( 'P', 'A', 'T', 'T' ):

+			ptr = ( unsigned char * ) c->data;

+			o = ptr[ 1 ] | ( ptr[ 2 ] << 8 ) | ( ptr[ 3 ] << 16 ) | ( ptr[ 4 ] << 24 );

+			if ( it_riff_am_process_pattern( sigdata->pattern + ptr[ 0 ], ptr + 5, o, 1 ) ) goto error_usd;

+			break;

+

+		case DUMB_ID( 'R', 'I', 'F', 'F' ):

+			{

+				struct riff * str = ( struct riff * ) c->data;

+				switch ( str->type )

+				{

+				case DUMB_ID('A', 'I', ' ', ' '):

+					for ( o = 0; o < str->chunk_count; ++o )

+					{

+						struct riff_chunk * chk = str->chunks + o;

+						switch( chk->type )

+						{

+						case DUMB_ID( 'I', 'N', 'S', 'T' ):

+							{

+								struct riff * temp;

+								unsigned size;

+								unsigned sample_found;

+								IT_SAMPLE * sample;

+								ptr = ( unsigned char * ) chk->data;

+								size = ptr[ 0 ] | ( ptr[ 1 ] << 8 ) | ( ptr[ 2 ] << 16 ) | ( ptr[ 3 ] << 24 );

+								temp = riff_parse( ptr + 4 + size, chk->size - size - 4, 1 );

+								sample_found = 0;

+								sample = sigdata->sample + ptr[ 5 ];

+								if ( temp )

+								{

+									if ( temp->type == DUMB_ID( 'A', 'S', ' ', ' ' ) )

+									{

+										for ( p = 0; p < temp->chunk_count; ++p )

+										{

+											struct riff_chunk * c = temp->chunks + p;

+											if ( c->type == DUMB_ID( 'S', 'A', 'M', 'P' ) )

+											{

+												if ( sample_found )

+												{

+													riff_free( temp );

+													goto error_usd;

+												}

+												if ( it_riff_am_process_sample( sigdata->sample + ptr[ 5 ], ( unsigned char * ) c->data, c->size, 1 ) )

+												{

+													riff_free( temp );

+													goto error_usd;

+												}

+												sample_found = 1;

+											}

+										}

+									}

+									riff_free( temp );

+								}

+								if ( ! sample_found )

+								{

+									memcpy( sample->name, ptr + 6, 32 );

+									sample->name[ 32 ] = 0;

+								}

+							}

+						}

+					}

+				}

+			}

+			break;

+		}

+	}

+

+	_dumb_it_fix_invalid_orders( sigdata );

+

+	return sigdata;

+

+error_usd:

+	_dumb_it_unload_sigdata( sigdata );

+	goto error;

+error_sd:

+	free( sigdata );

+error:

+	return NULL;

+}

+

+DUH *dumb_read_riff_amff( struct riff * stream )

+{

+	sigdata_t *sigdata;

+	long length;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_riff_amff_load_sigdata( stream );

+

+	if (!sigdata)

+		return NULL;

+

+	length = 0;/*_dumb_it_build_checkpoints(sigdata, 0);*/

+

+	{

+		const char *tag[2][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		tag[1][1] = "RIFF AMFF";

+		return make_duh( length, 2, ( const char * const (*) [ 2 ] ) tag, 1, & descptr, & sigdata );

+	}

+}

+

+DUH *dumb_read_riff_am( struct riff * stream )

+{

+	sigdata_t *sigdata;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_riff_am_load_sigdata( stream );

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		const char *tag[2][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		tag[1][1] = "RIFF AM";

+		return make_duh( -1, 2, ( const char * const (*) [ 2 ] ) tag, 1, & descptr, & sigdata );

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readasy.c b/plugins/dumb/dumb-kode54/src/it/readasy.c
new file mode 100644
index 00000000..4c1c09f8
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readasy.c
@@ -0,0 +1,331 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readasy.c - Code to read an ASYLUM Music Format    / / \  \

+ *             module from an open file.             | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Chris Moeller.                                  \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>

+#include <math.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+static int it_asy_read_pattern( IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer )

+{

+	int pos;

+	int channel;

+	int row;

+	IT_ENTRY *entry;

+

+	pattern->n_rows = 64;

+

+	if ( dumbfile_getnc( buffer, 64 * 8 * 4, f ) != 64 * 8 * 4 )

+		return -1;

+

+	/* compute number of entries */

+	pattern->n_entries = 64; /* Account for the row end markers */

+	pos = 0;

+	for ( row = 0; row < 64; ++row ) {

+		for ( channel = 0; channel < 8; ++channel ) {

+			if ( buffer[ pos + 0 ] | buffer[ pos + 1 ] | buffer[ pos + 2 ] | buffer[ pos + 3 ] )

+				++pattern->n_entries;

+			pos += 4;

+		}

+	}

+

+	pattern->entry = malloc( pattern->n_entries * sizeof( *pattern->entry ) );

+	if ( !pattern->entry )

+		return -1;

+

+	entry = pattern->entry;

+	pos = 0;

+	for ( row = 0; row < 64; ++row ) {

+		for ( channel = 0; channel < 8; ++channel ) {

+			if ( buffer[ pos + 0 ] | buffer[ pos + 1 ] | buffer[ pos + 2 ] | buffer[ pos + 3 ] ) {

+				entry->channel = channel;

+				entry->mask = 0;

+

+				if ( buffer[ pos + 0 ] && buffer[ pos + 0 ] < 96 ) {

+					entry->note = buffer[ pos + 0 ];

+					entry->mask |= IT_ENTRY_NOTE;

+				}

+

+				if ( buffer[ pos + 1 ] && buffer[ pos + 1 ] <= 64 ) {

+					entry->instrument = buffer[ pos + 1 ];

+					entry->mask |= IT_ENTRY_INSTRUMENT;

+				}

+

+				_dumb_it_xm_convert_effect( buffer[ pos + 2 ] & 0x0F, buffer[ pos + 3 ], entry, 1 );

+

+				if ( entry->mask ) ++entry;

+			}

+			pos += 4;

+		}

+		IT_SET_END_ROW( entry );

+		++entry;

+	}

+

+	pattern->n_entries = entry - pattern->entry;

+

+	return 0;

+}

+

+

+

+static int it_asy_read_sample_header( IT_SAMPLE *sample, DUMBFILE *f )

+{

+	int finetune;

+

+/**

+     21       22   Chars     Sample 1 name.  If the name is not a full

+                             22 chars in length, it will be null

+                             terminated.

+

+If

+the sample name begins with a '#' character (ASCII $23 (35)) then this is

+assumed not to be an instrument name, and is probably a message.

+*/

+	dumbfile_getnc( sample->name, 22, f );

+	sample->name[22] = 0;

+

+	sample->filename[0] = 0;

+

+/** Each  finetune step changes  the note 1/8th  of  a  semitone. */

+	finetune = ( signed char ) ( dumbfile_getc( f ) << 4 ) >> 4; /* signed nibble */

+	sample->default_volume = dumbfile_getc( f ); // Should we be setting global_volume to this instead?

+	sample->global_volume = 64;

+	if ( sample->default_volume > 64 ) sample->default_volume = 64;

+	dumbfile_skip( f, 1 ); /* XXX unknown */

+	sample->length = dumbfile_igetl( f );

+	sample->loop_start = dumbfile_igetl( f );

+	sample->loop_end = sample->loop_start + dumbfile_igetl( f );

+

+	if ( sample->length <= 0 ) {

+		sample->flags = 0;

+		return 0;

+	}

+

+	sample->flags = IT_SAMPLE_EXISTS;

+

+	sample->default_pan = 0;

+	sample->C5_speed = (int)( AMIGA_CLOCK / 214.0 );//( long )( 16726.0 * pow( DUMB_PITCH_BASE, finetune * 32 ) );

+	sample->finetune = finetune * 32;

+	// the above line might be wrong

+

+	if ( ( sample->loop_end - sample->loop_start > 2 ) && ( sample->loop_end <= sample->length ) )

+		sample->flags |= IT_SAMPLE_LOOP;

+

+	sample->vibrato_speed = 0;

+	sample->vibrato_depth = 0;

+	sample->vibrato_rate = 0;

+	sample->vibrato_waveform = 0; // do we have to set _all_ these?

+	sample->max_resampling_quality = -1;

+

+	return dumbfile_error(f);

+}

+

+

+

+static int it_asy_read_sample_data( IT_SAMPLE *sample, DUMBFILE *f )

+{

+	long truncated_size;

+

+	/* let's get rid of the sample data coming after the end of the loop */

+	if ( ( sample->flags & IT_SAMPLE_LOOP ) && sample->loop_end < sample->length ) {

+		truncated_size = sample->length - sample->loop_end;

+		sample->length = sample->loop_end;

+	} else {

+		truncated_size = 0;

+	}

+

+	sample->data = malloc( sample->length );

+

+	if ( !sample->data )

+		return -1;

+

+	if ( sample->length )

+		dumbfile_getnc( sample->data, sample->length, f );

+

+	dumbfile_skip( f, truncated_size );

+

+	return dumbfile_error( f );

+}

+

+

+

+static DUMB_IT_SIGDATA *it_asy_load_sigdata(DUMBFILE *f)

+{

+	DUMB_IT_SIGDATA *sigdata;

+	int i;

+

+	static const char sig_part[] = "ASYLUM Music Format";

+	static const char sig_rest[] = " V1.0"; /* whee, string space optimization with format type below */

+

+	char signature [32];

+

+	if ( dumbfile_getnc( signature, 32, f ) != 32 ||

+		memcmp( signature, sig_part, 19 ) ||

+		memcmp( signature + 19, sig_rest, 5 ) ) {

+		return NULL;

+	}

+

+	sigdata = malloc(sizeof(*sigdata));

+	if (!sigdata) {

+		return NULL;

+	}

+

+	sigdata->speed = dumbfile_getc( f ); /* XXX seems to fit the files I have */

+	sigdata->tempo = dumbfile_getc( f ); /* ditto */

+	sigdata->n_samples = dumbfile_getc( f ); /* ditto */

+	sigdata->n_patterns = dumbfile_getc( f );

+	sigdata->n_orders = dumbfile_getc( f );

+	sigdata->restart_position = dumbfile_getc( f );

+

+	if ( dumbfile_error( f ) || !sigdata->n_samples || sigdata->n_samples > 64 || !sigdata->n_patterns ||

+		!sigdata->n_orders ) {

+		free( sigdata );

+		return NULL;

+	}

+

+	if ( sigdata->restart_position > sigdata->n_orders ) /* XXX */

+		sigdata->restart_position = 0;

+

+	sigdata->order = malloc( sigdata->n_orders );

+	if ( !sigdata->order ) {

+		free( sigdata );

+		return NULL;

+	}

+

+	if ( dumbfile_getnc( sigdata->order, sigdata->n_orders, f ) != sigdata->n_orders ||

+		dumbfile_skip( f, 256 - sigdata->n_orders ) ) {

+		free( sigdata->order );

+		free( sigdata );

+		return NULL;

+	}

+

+	sigdata->sample = malloc( sigdata->n_samples * sizeof( *sigdata->sample ) );

+	if ( !sigdata->sample ) {

+		free( sigdata->order );

+		free( sigdata );

+		return NULL;

+	}

+

+	sigdata->song_message = NULL;

+	sigdata->instrument = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->n_instruments = 0;

+

+	for ( i = 0; i < sigdata->n_samples; ++i )

+		sigdata->sample[i].data = NULL;

+

+	for ( i = 0; i < sigdata->n_samples; ++i ) {

+		if ( it_asy_read_sample_header( &sigdata->sample[i], f ) ) {

+			_dumb_it_unload_sigdata( sigdata );

+			return NULL;

+		}

+	}

+

+	if ( dumbfile_skip( f, 37 * ( 64 - sigdata->n_samples ) ) ) {

+		_dumb_it_unload_sigdata( sigdata );

+		return NULL;

+	}

+

+	sigdata->pattern = malloc( sigdata->n_patterns * sizeof( *sigdata->pattern ) );

+	if ( !sigdata->pattern ) {

+		_dumb_it_unload_sigdata( sigdata );

+		return NULL;

+	}

+	for (i = 0; i < sigdata->n_patterns; ++i)

+		sigdata->pattern[i].entry = NULL;

+

+	/* Read in the patterns */

+	{

+		unsigned char *buffer = malloc( 64 * 8 * 4 ); /* 64 rows * 8 channels * 4 bytes */

+		if ( !buffer ) {

+			_dumb_it_unload_sigdata( sigdata );

+			return NULL;

+		}

+		for ( i = 0; i < sigdata->n_patterns; ++i ) {

+			if ( it_asy_read_pattern( &sigdata->pattern[i], f, buffer ) != 0 ) {

+				free( buffer );

+				_dumb_it_unload_sigdata( sigdata );

+				return NULL;

+			}

+		}

+		free( buffer );

+	}

+

+	/* And finally, the sample data */

+	for ( i = 0; i < sigdata->n_samples; ++i ) {

+		if ( it_asy_read_sample_data( &sigdata->sample[i], f ) ) {

+			_dumb_it_unload_sigdata( sigdata );

+			return NULL;

+		}

+	}

+

+	/* Now let's initialise the remaining variables, and we're done! */

+	sigdata->flags = IT_WAS_AN_XM | IT_WAS_A_MOD | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_STEREO;

+

+	sigdata->global_volume = 128;

+	sigdata->mixing_volume = 48;

+	sigdata->pan_separation = 128;

+

+	sigdata->n_pchannels = 8;

+

+	sigdata->name[0] = 0;

+

+	memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i += 4) {

+		sigdata->channel_pan[i+0] = 16;

+		sigdata->channel_pan[i+1] = 48;

+		sigdata->channel_pan[i+2] = 48;

+		sigdata->channel_pan[i+3] = 16;

+	}

+

+	_dumb_it_fix_invalid_orders(sigdata);

+

+	return sigdata;

+}

+

+

+

+DUH *dumb_read_asy_quick(DUMBFILE *f)

+{

+	sigdata_t *sigdata;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_asy_load_sigdata(f);

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		const char *tag[2][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		tag[1][1] = "ASYLUM Music Format";

+		return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readdsmf.c b/plugins/dumb/dumb-kode54/src/it/readdsmf.c
new file mode 100644
index 00000000..2a4f23e6
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readdsmf.c
@@ -0,0 +1,373 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readam.c - Code to read a RIFF DSMF module         / / \  \

+ *             from a parsed RIFF structure.         | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Chris Moeller.                                  \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+#include "internal/riff.h"

+

+static int it_riff_dsmf_process_sample( IT_SAMPLE * sample, const unsigned char * data, int len )

+{

+	int flags;

+

+	memcpy( sample->filename, data, 13 );

+	sample->filename[ 14 ] = 0;

+	

+	flags = data[ 13 ] | ( data[ 14 ] << 8 );

+	sample->default_volume = data[ 15 ];

+	sample->length = data[ 16 ] | ( data[ 17 ] << 8 ) | ( data[ 18 ] << 16 ) | ( data[ 19 ] << 24 );

+	sample->loop_start = data[ 20 ] | ( data[ 21 ] << 8 ) | ( data[ 22 ] << 16 ) | ( data[ 23 ] << 24 );

+	sample->loop_end = data[ 24 ] | ( data[ 25 ] << 8 ) | ( data[ 26 ] << 16 ) | ( data[ 27 ] << 24 );

+	sample->C5_speed = ( data[ 32 ] | ( data[ 33 ] << 8 ) ) * 2;

+	memcpy( sample->name, data + 36, 28 );

+	sample->name[ 28 ] = 0;

+

+	/*if ( data[ 0x38 ] || data[ 0x39 ] || data[ 0x3A ] || data[ 0x3B ] )

+		return -1;*/

+

+	if ( ! sample->length ) {

+		sample->flags &= ~IT_SAMPLE_EXISTS;

+		return 0;

+	}

+

+	/*if ( flags & ~( 2 | 1 ) )

+		return -1;*/

+

+	if ( sample->length + 64 > len )

+		return -1;

+

+	sample->flags = IT_SAMPLE_EXISTS;

+

+	sample->default_pan = 0;

+	sample->global_volume = 64;

+	sample->vibrato_speed = 0;

+	sample->vibrato_depth = 0;

+	sample->vibrato_rate = 0;

+	sample->vibrato_waveform = IT_VIBRATO_SINE;

+	sample->finetune = 0;

+	sample->max_resampling_quality = -1;

+

+	if ( flags & 1 )

+	{

+		if (((unsigned int)sample->loop_end <= (unsigned int)sample->length) &&

+			((unsigned int)sample->loop_start < (unsigned int)sample->loop_end))

+		{

+			sample->length = sample->loop_end;

+			sample->flags |= IT_SAMPLE_LOOP;

+			if ( flags & 0x10 ) sample->flags |= IT_SAMPLE_PINGPONG_LOOP;

+		}

+	}

+

+	sample->data = malloc( sample->length );

+	if ( ! sample->data )

+		return -1;

+

+	memcpy( sample->data, data + 64, sample->length );

+

+	if ( ! ( flags & 2 ) )

+	{

+		for ( flags = 0; flags < sample->length; ++flags )

+			( ( signed char * ) sample->data ) [ flags ] ^= 0x80;

+	}

+

+	return 0;

+}

+

+static int it_riff_dsmf_process_pattern( IT_PATTERN * pattern, const unsigned char * data, int len )

+{

+	int length, row, pos;

+	unsigned flags;

+	IT_ENTRY * entry;

+

+	length = data[ 0 ] | ( data[ 1 ] << 8 );

+	if ( length > len ) return -1;

+

+	data += 2;

+	len = length - 2;

+

+	pattern->n_rows = 64;

+	pattern->n_entries = 64;

+

+	row = 0;

+	pos = 0;

+

+	while ( (row < 64) && (pos < len) ) {

+		if ( ! data[ pos ] ) {

+			++ row;

+			++ pos;

+			continue;

+		}

+

+		flags = data[ pos++ ] & 0xF0;

+

+		if (flags) {

+			++ pattern->n_entries;

+			if (flags & 0x80) pos ++;

+			if (flags & 0x40) pos ++;

+			if (flags & 0x20) pos ++;

+			if (flags & 0x10) pos += 2;

+		}

+	}

+

+	if ( pattern->n_entries == 64 ) return 0;

+

+	pattern->entry = malloc( pattern->n_entries * sizeof( * pattern->entry ) );

+	if ( ! pattern->entry ) return -1;

+

+	entry = pattern->entry;

+

+	row = 0;

+	pos = 0;

+

+	while ( ( row < 64 ) && ( pos < len ) )

+	{

+		if ( ! data[ pos ] )

+		{

+			IT_SET_END_ROW( entry );

+			++ entry;

+			++ row;

+			++ pos;

+			continue;

+		}

+

+		flags = data[ pos++ ];

+		entry->channel = flags & 0x0F;

+		entry->mask = 0;

+

+		if ( flags & 0xF0 )

+		{

+			if ( flags & 0x80 )

+			{

+				if ( data[ pos ] )

+				{

+					entry->mask |= IT_ENTRY_NOTE;

+					entry->note = data[ pos ] - 1;

+				}

+				++ pos;

+			}

+

+			if ( flags & 0x40 )

+			{

+				if ( data[ pos ] )

+				{

+					entry->mask |= IT_ENTRY_INSTRUMENT;

+					entry->instrument = data[ pos ];

+				}

+				++ pos;

+			}

+

+			if ( flags & 0x20 )

+			{

+				entry->mask |= IT_ENTRY_VOLPAN;

+				entry->volpan = data[ pos ];

+				++ pos;

+			}

+

+			if ( flags & 0x10 )

+			{

+				_dumb_it_xm_convert_effect( data[ pos ], data[ pos + 1 ], entry, 0 );

+				pos += 2;

+			}

+

+			if (entry->mask) entry++;

+		}

+	}

+

+	while ( row < 64 )

+	{

+		IT_SET_END_ROW( entry );

+		++ entry;

+		++ row;

+	}

+

+	pattern->n_entries = entry - pattern->entry;

+	if ( ! pattern->n_entries ) return -1;

+

+	return 0;

+}

+

+static DUMB_IT_SIGDATA *it_riff_dsmf_load_sigdata( struct riff * stream )

+{

+	DUMB_IT_SIGDATA *sigdata;

+

+	int n, o, found;

+

+	unsigned char * ptr;

+

+	if ( ! stream ) goto error;

+

+	if ( stream->type != DUMB_ID( 'D', 'S', 'M', 'F' ) ) goto error;

+

+	sigdata = malloc(sizeof(*sigdata));

+	if ( ! sigdata ) goto error;

+

+	sigdata->n_patterns = 0;

+	sigdata->n_samples = 0;

+	sigdata->name[0] = 0;

+

+	found = 0;

+

+	for ( n = 0; n < stream->chunk_count; ++n )

+	{

+		struct riff_chunk * c = stream->chunks + n;

+		switch( c->type )

+		{

+		case DUMB_ID( 'S' ,'O' ,'N' ,'G' ):

+			/* initialization data */

+			if ( ( found ) || ( c->size < 192 ) ) goto error_sd;

+			found = 1;

+			break;

+

+		case DUMB_ID( 'P', 'A', 'T', 'T' ):

+			++ sigdata->n_patterns;

+			break;

+

+		case DUMB_ID( 'I', 'N', 'S', 'T' ):

+			++ sigdata->n_samples;

+			break;

+		}

+	}

+

+	if ( !found || !sigdata->n_samples || !sigdata->n_patterns ) goto error_sd;

+

+	if ( sigdata->n_samples > 255 || sigdata->n_patterns > 255 ) goto error_sd;

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->sample = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->mixing_volume = 48;

+	sigdata->pan_separation = 128;

+

+	sigdata->n_instruments = 0;

+	sigdata->n_orders = 0;

+

+	memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);

+

+	for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) {

+		sigdata->channel_pan[n  ] = 16;

+		sigdata->channel_pan[n+1] = 48;

+		sigdata->channel_pan[n+2] = 48;

+		sigdata->channel_pan[n+3] = 16;

+	}

+

+	for ( n = 0; n < stream->chunk_count; ++n )

+	{

+		struct riff_chunk * c = stream->chunks + n;

+		switch ( c->type )

+		{

+		case DUMB_ID( 'S', 'O', 'N', 'G' ):

+			ptr = ( unsigned char * ) c->data;

+			memcpy( sigdata->name, c->data, 28 );

+			sigdata->name[ 28 ] = 0;

+			sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX;

+			sigdata->n_orders = ptr[ 36 ] | ( ptr[ 37 ] << 8 );

+			//sigdata->n_samples = ptr[ 38 ] | ( ptr[ 39 ] << 8 ); // whatever

+			//sigdata->n_patterns = ptr[ 40 ] | ( ptr[ 41 ] << 8 );

+			sigdata->n_pchannels = ptr[ 42 ] | ( ptr[ 43 ] << 8 );

+			sigdata->global_volume = ptr[ 44 ];

+			sigdata->mixing_volume = ptr[ 45 ];

+			sigdata->speed = ptr[ 46 ];

+			sigdata->tempo = ptr[ 47 ];

+

+			for ( o = 0; o < 16; ++o )

+			{

+				sigdata->channel_pan[ o ] = ptr[ 48 + o ] / 2;

+			}

+

+			sigdata->order = malloc( 128 );

+			if ( ! sigdata->order ) goto error_usd;

+			memcpy( sigdata->order, ptr + 64, 128 );

+

+			break;

+		}

+	}

+

+	sigdata->pattern = malloc( sigdata->n_patterns * sizeof( *sigdata->pattern ) );

+	if ( ! sigdata->pattern ) goto error_usd;

+	for ( n = 0; n < sigdata->n_patterns; ++n )

+		sigdata->pattern[ n ].entry = NULL;

+

+	sigdata->sample = malloc( sigdata->n_samples * sizeof( *sigdata->sample ) );

+	if ( ! sigdata->sample ) goto error_usd;

+	for ( n = 0; n < sigdata->n_samples; ++n )

+	{

+		IT_SAMPLE * sample = sigdata->sample + n;

+		sample->data = NULL;

+	}

+

+	sigdata->n_samples = 0;

+	sigdata->n_patterns = 0;

+

+	for ( n = 0; n < stream->chunk_count; ++n )

+	{

+		struct riff_chunk * c = stream->chunks + n;

+		switch ( c->type )

+		{

+		case DUMB_ID( 'P', 'A', 'T', 'T' ):

+			if ( it_riff_dsmf_process_pattern( sigdata->pattern + sigdata->n_patterns, ( unsigned char * ) c->data, c->size ) ) goto error_usd;

+			++ sigdata->n_patterns;

+			break;

+

+		case DUMB_ID( 'I', 'N', 'S', 'T' ):

+			if ( it_riff_dsmf_process_sample( sigdata->sample + sigdata->n_samples, ( unsigned char * ) c->data, c->size ) ) goto error_usd;

+			++ sigdata->n_samples;

+			break;

+		}

+	}

+

+	_dumb_it_fix_invalid_orders( sigdata );

+

+	return sigdata;

+

+error_usd:

+	_dumb_it_unload_sigdata( sigdata );

+	goto error;

+error_sd:

+	free( sigdata );

+error:

+	return NULL;

+}

+

+DUH *dumb_read_riff_dsmf( struct riff * stream )

+{

+	sigdata_t *sigdata;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_riff_dsmf_load_sigdata( stream );

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		const char *tag[2][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		tag[1][1] = "RIFF DSMF";

+		return make_duh( -1, 2, ( const char * const (*) [ 2 ] ) tag, 1, & descptr, & sigdata );

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readmod.c b/plugins/dumb/dumb-kode54/src/it/readmod.c
new file mode 100644
index 00000000..0963c6d9
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readmod.c
@@ -0,0 +1,780 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readmod.c - Code to read a good old-fashioned      / / \  \

+ *             Amiga module from an open file.       | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>

+#include <math.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+static int it_mod_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, int n_channels, unsigned char *buffer)

+{

+	int pos;

+	int channel;

+	int row;

+	IT_ENTRY *entry;

+

+	pattern->n_rows = 64;

+

+	if (n_channels == 0) {

+		/* Read the first four channels, leaving gaps for the rest. */

+		for (pos = 0; pos < 64*8*4; pos += 8*4)

+			dumbfile_getnc(buffer + pos, 4*4, f);

+		/* Read the other channels into the gaps we left. */

+		for (pos = 4*4; pos < 64*8*4; pos += 8*4)

+			dumbfile_getnc(buffer + pos, 4*4, f);

+

+		n_channels = 8;

+	} else

+		dumbfile_getnc(buffer, 64 * n_channels * 4, f);

+

+	if (dumbfile_error(f))

+		return -1;

+

+	/* compute number of entries */

+	pattern->n_entries = 64; /* Account for the row end markers */

+	pos = 0;

+	for (row = 0; row < 64; row++) {

+		for (channel = 0; channel < n_channels; channel++) {

+			if (buffer[pos+0] | buffer[pos+1] | buffer[pos+2] | buffer[pos+3])

+				pattern->n_entries++;

+			pos += 4;

+		}

+	}

+

+	pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry));

+	if (!pattern->entry)

+		return -1;

+

+	entry = pattern->entry;

+	pos = 0;

+	for (row = 0; row < 64; row++) {

+		for (channel = 0; channel < n_channels; channel++) {

+			if (buffer[pos+0] | buffer[pos+1] | buffer[pos+2] | buffer[pos+3]) {

+				unsigned char sample = (buffer[pos+0] & 0xF0) | (buffer[pos+2] >> 4);

+				int period = ((int)(buffer[pos+0] & 0x0F) << 8) | buffer[pos+1];

+

+				entry->channel = channel;

+				entry->mask = 0;

+

+				if (period) {

+					int note;

+					entry->mask |= IT_ENTRY_NOTE;

+

+					/* frequency = (AMIGA_DIVISOR / 8) / (period * 2)

+					 * C-1: period = 214 -> frequency = 16726

+					 * so, set C5_speed to 16726

+					 * and period = 214 should translate to C5 aka 60

+					 * halve the period, go up an octive

+					 *

+					 * period = 214 / pow(DUMB_SEMITONE_BASE, note - 60)

+					 * pow(DUMB_SEMITONE_BASE, note - 60) = 214 / period

+					 * note - 60 = log(214/period) / log(DUMB_SEMITONE_BASE)

+					 */

+					note = (int)floor(log(214.0/period) / log(DUMB_SEMITONE_BASE) + 60.5);

+					entry->note = MID(0, note, 119);

+					// or should we preserve the period?

+					//entry->note = buffer[pos+0] & 0x0F; /* High nibble */

+					//entry->volpan = buffer[pos+1]; /* Low byte */

+					// and what about finetune?

+				}

+

+				if (sample) {

+					entry->mask |= IT_ENTRY_INSTRUMENT;

+					entry->instrument = sample;

+				}

+

+				_dumb_it_xm_convert_effect(buffer[pos+2] & 0x0F, buffer[pos+3], entry, 1);

+

+				entry++;

+			}

+			pos += 4;

+		}

+		IT_SET_END_ROW(entry);

+		entry++;

+	}

+

+	return 0;

+}

+

+

+

+static int it_mod_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f)

+{

+	int finetune, loop_start, loop_length;

+

+/**

+     21       22   Chars     Sample 1 name.  If the name is not a full

+                             22 chars in length, it will be null

+                             terminated.

+

+If

+the sample name begins with a '#' character (ASCII $23 (35)) then this is

+assumed not to be an instrument name, and is probably a message.

+*/

+	dumbfile_getnc(sample->name, 22, f);

+	sample->name[22] = 0;

+

+	sample->filename[0] = 0;

+

+	sample->length = dumbfile_mgetw(f) << 1;

+	finetune = (signed char)(dumbfile_getc(f) << 4) >> 4; /* signed nibble */

+/** Each  finetune step changes  the note 1/8th  of  a  semitone. */

+	sample->global_volume = 64;

+	sample->default_volume = dumbfile_getc(f); // Should we be setting global_volume to this instead?

+	loop_start = dumbfile_mgetw(f) << 1;

+	loop_length = dumbfile_mgetw(f) << 1;

+	if ( loop_length > 2 && loop_start + loop_length > sample->length && loop_start / 2 + loop_length <= sample->length )

+		loop_start /= 2;

+	sample->loop_start = loop_start;

+	sample->loop_end = loop_start + loop_length;

+/**

+Once this sample has been played completely from beginning

+to end, if the  repeat length (next field)  is greater than two  bytes it

+will loop back to this position in the sample and continue playing.  Once

+it has played for  the repeat length,  it continues to  loop back to  the

+repeat start offset.  This means the sample continues playing until it is

+told to stop.

+*/

+

+	if (sample->length <= 0) {

+		sample->flags = 0;

+		return 0;

+	}

+

+	sample->flags = IT_SAMPLE_EXISTS;

+

+	sample->default_pan = 0;

+	sample->C5_speed = (int)( AMIGA_CLOCK / 214.0 ); //(long)(16726.0*pow(DUMB_PITCH_BASE, finetune*32));

+	sample->finetune = finetune * 32;

+	// the above line might be wrong

+

+	if (sample->loop_end > sample->length)

+		sample->loop_end = sample->length;

+

+	if (sample->loop_end - sample->loop_start > 2)

+		sample->flags |= IT_SAMPLE_LOOP;

+

+	sample->vibrato_speed = 0;

+	sample->vibrato_depth = 0;

+	sample->vibrato_rate = 0;

+	sample->vibrato_waveform = 0; // do we have to set _all_ these?

+	sample->max_resampling_quality = -1;

+

+	return dumbfile_error(f);

+}

+

+

+

+static int it_mod_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f, unsigned long fft)

+{

+	long i;

+	long truncated_size;

+

+	/* let's get rid of the sample data coming after the end of the loop */

+	if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) {

+		truncated_size = sample->length - sample->loop_end;

+		sample->length = sample->loop_end;

+	} else {

+		truncated_size = 0;

+	}

+

+	if (sample->length) {

+		sample->data = malloc(sample->length);

+

+		if (!sample->data)

+			return -1;

+

+		/* Sample data are stored in "8-bit two's compliment format" (sic). */

+		/*

+		for (i = 0; i < sample->length; i++)

+			((signed char *)sample->left)[i] = dumbfile_getc(f);

+		*/

+		/* F U Olivier Lapicque */

+		if (sample->length >= 5)

+		{

+			i = dumbfile_getnc(sample->data, 5, f);

+			if (i == 5)

+			{

+				if (!memcmp(sample->data, "ADPCM", 5))

+				{

+					if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0)

+						return -1;

+

+					return 0;

+				}

+				else

+				{

+					i += dumbfile_getnc(((char *)sample->data) + 5, sample->length - 5, f);

+				}

+			}

+		}

+		else

+		{

+			i = dumbfile_getnc(sample->data, sample->length, f);

+		}

+		if (i < sample->length)

+		{

+			if (i <= 0)

+			{

+				sample->flags = 0;

+				return 0;

+			}

+			sample->length = i;

+			if (sample->loop_end > i) sample->loop_end = i;

+			// holy crap!

+			if (sample->loop_start > i) sample->flags &= ~IT_SAMPLE_LOOP;

+		}

+		else

+		{

+			/* skip truncated data */

+			int feh = dumbfile_error(f);

+

+			if (truncated_size) dumbfile_skip(f, truncated_size);

+			// Should we be truncating it?

+

+			if (feh)

+				return -1;

+		}

+

+		if (fft == DUMB_ID('M',0,0,0) || fft == DUMB_ID('8',0,0,0)) {

+			int delta = 0;

+			for (i = 0; i < sample->length; i++) {

+				delta += ((signed char *)sample->data)[i];

+				((signed char *)sample->data)[i] = delta;

+			}

+		}

+	}

+

+	return 0;

+}

+

+

+

+typedef struct BUFFERED_MOD BUFFERED_MOD;

+

+struct BUFFERED_MOD

+{

+	unsigned char *buffered;

+	long ptr, len;

+	DUMBFILE *remaining;

+};

+

+

+

+static int buffer_mod_skip(void *f, long n)

+{

+	BUFFERED_MOD *bm = f;

+	if (bm->buffered) {

+		bm->ptr += n;

+		if (bm->ptr >= bm->len) {

+			free(bm->buffered);

+			bm->buffered = NULL;

+			return dumbfile_skip(bm->remaining, bm->ptr - bm->len);

+		}

+		return 0;

+	}

+	return dumbfile_skip(bm->remaining, n);

+}

+

+

+

+static int buffer_mod_getc(void *f)

+{

+	BUFFERED_MOD *bm = f;

+	if (bm->buffered) {

+		int rv = bm->buffered[bm->ptr++];

+		if (bm->ptr >= bm->len) {

+			free(bm->buffered);

+			bm->buffered = NULL;

+		}

+		return rv;

+	}

+	return dumbfile_getc(bm->remaining);

+}

+

+

+

+static long buffer_mod_getnc(char *ptr, long n, void *f)

+{

+	BUFFERED_MOD *bm = f;

+	if (bm->buffered) {

+		int left = bm->len - bm->ptr;

+		if (n >= left) {

+			memcpy(ptr, bm->buffered + bm->ptr, left);

+			free(bm->buffered);

+			bm->buffered = NULL;

+			if (n - left) {

+				int rv = dumbfile_getnc(ptr + left, n - left, bm->remaining);

+				return left + MAX(rv, 0);

+			} else {

+				return left;

+			}

+		}

+		memcpy(ptr, bm->buffered + bm->ptr, n);

+		bm->ptr += n;

+		return n;

+	}

+	return dumbfile_getnc(ptr, n, bm->remaining);

+}

+

+

+

+static void buffer_mod_close(void *f)

+{

+	BUFFERED_MOD *bm = f;

+	if (bm->buffered) free(bm->buffered);

+	/* Do NOT close bm->remaining */

+	free(f);

+}

+

+

+

+DUMBFILE_SYSTEM buffer_mod_dfs = {

+	NULL,

+	&buffer_mod_skip,

+	&buffer_mod_getc,

+	&buffer_mod_getnc,

+	&buffer_mod_close

+};

+

+

+

+#define MOD_FFT_OFFSET (20 + 31*(22+2+1+1+2+2) + 1 + 1 + 128)

+

+static DUMBFILE *dumbfile_buffer_mod(DUMBFILE *f, unsigned long *fft)

+{

+	BUFFERED_MOD *bm = malloc(sizeof(*bm));

+	if (!bm) return NULL;

+

+	bm->buffered = malloc(MOD_FFT_OFFSET + 4);

+	if (!bm->buffered) {

+		free(bm);

+		return NULL;

+	}

+

+	bm->len = dumbfile_getnc(bm->buffered, MOD_FFT_OFFSET + 4, f);

+

+	if (bm->len > 0) {

+		if (bm->len >= MOD_FFT_OFFSET + 4)

+			*fft = (unsigned long)bm->buffered[MOD_FFT_OFFSET  ] << 24

+			     | (unsigned long)bm->buffered[MOD_FFT_OFFSET+1] << 16

+			     | (unsigned long)bm->buffered[MOD_FFT_OFFSET+2] << 8

+			     | (unsigned long)bm->buffered[MOD_FFT_OFFSET+3];

+		else

+			*fft = 0;

+		bm->ptr = 0;

+	} else {

+		free(bm->buffered);

+		bm->buffered = NULL;

+	}

+

+	bm->remaining = f;

+

+	return dumbfile_open_ex(bm, &buffer_mod_dfs);

+}

+

+static DUMBFILE *dumbfile_buffer_mod_2(DUMBFILE *f, long *remain)

+{

+	long read;

+	BUFFERED_MOD *bm = malloc(sizeof(*bm));

+	if (!bm) return NULL;

+

+	bm->buffered = malloc(32768);

+	if (!bm->buffered) {

+		free(bm);

+		return NULL;

+	}

+

+	bm->len = 0;

+	*remain = 0;

+

+	read = dumbfile_getnc(bm->buffered, 32768, f);

+

+	if (read >= 0) {

+		bm->len += read;

+		*remain += read;

+

+		while (read >= 32768) {

+			bm->buffered = realloc(bm->buffered, *remain + 32768);

+			if (!bm->buffered) {

+				free(bm);

+				return 0;

+			}

+			read = dumbfile_getnc(bm->buffered + *remain, 32768, f);

+			if (read >= 0) {

+				bm->len += read;

+				*remain += read;

+			}

+		}

+	}

+

+	if (*remain) {

+		bm->ptr = 0;

+	} else {

+		free(bm->buffered);

+		bm->buffered = NULL;

+	}

+

+	bm->remaining = f;

+

+	return dumbfile_open_ex(bm, &buffer_mod_dfs);

+}

+

+

+static DUMB_IT_SIGDATA *it_mod_load_sigdata(DUMBFILE *f, int restrict)

+{

+	DUMB_IT_SIGDATA *sigdata;

+	int n_channels;

+	int i;

+	unsigned long fft;

+	DUMBFILE *rem;

+

+	f = dumbfile_buffer_mod(f, &fft);

+	if (!f)

+		return NULL;

+

+	sigdata = malloc(sizeof(*sigdata));

+	if (!sigdata) {

+		dumbfile_close(f);

+		return NULL;

+	}

+

+	/**

+      1       20   Chars     Title of the song.  If the title is not a

+                             full 20 chars in length, it will be null-

+                             terminated.

+	*/

+	if (dumbfile_getnc(sigdata->name, 20, f) < 20) {

+		free(sigdata);

+		dumbfile_close(f);

+		return NULL;

+	}

+	sigdata->name[20] = 0;

+

+	sigdata->n_samples = 31;

+

+	switch (fft) {

+		case DUMB_ID('M','.','K','.'):

+		case DUMB_ID('M','!','K','!'):

+		case DUMB_ID('M','&','K','!'):

+		case DUMB_ID('N','.','T','.'):

+		case DUMB_ID('N','S','M','S'):

+		case DUMB_ID('F','L','T','4'):

+		case DUMB_ID('M',0,0,0):

+		case DUMB_ID('8',0,0,0):

+			n_channels = 4;

+			break;

+		case DUMB_ID('F','L','T','8'):

+			n_channels = 0;

+			/* 0 indicates a special case; two four-channel patterns must be

+			 * combined into one eight-channel pattern. Pattern indexes must

+			 * be halved. Why oh why do they obfuscate so?

+			 */

+			/*for (i = 0; i < 128; i++)

+				sigdata->order[i] >>= 1;*/

+			break;

+		case DUMB_ID('C','D','8','1'):

+		case DUMB_ID('O','C','T','A'):

+		case DUMB_ID('O','K','T','A'):

+			n_channels = 8;

+			break;

+		case DUMB_ID('1','6','C','N'):

+			n_channels = 16;

+			break;

+		case DUMB_ID('3','2','C','N'):

+			n_channels = 32;

+			break;

+		default:

+			/* If we get an illegal tag, assume 4 channels 15 samples. */

+			if ((fft & 0x0000FFFFL) == DUMB_ID(0,0,'C','H')) {

+				if (fft >= '1' << 24 && fft < '4' << 24) {

+					n_channels = ((fft & 0x00FF0000L) >> 16) - '0';

+					if ((unsigned int)n_channels >= 10) {

+						/* Rightmost character wasn't a digit. */

+						n_channels = 4;

+						sigdata->n_samples = 15;

+					} else {

+						n_channels += (((fft & 0xFF000000L) >> 24) - '0') * 10;

+						/* MODs should really only go up to 32 channels, but we're lenient. */

+						if ((unsigned int)(n_channels - 1) >= DUMB_IT_N_CHANNELS - 1) {

+							/* No channels or too many? Can't be right... */

+							n_channels = 4;

+							sigdata->n_samples = 15;

+						}

+					}

+				} else {

+					n_channels = 4;

+					sigdata->n_samples = 15;

+				}

+			} else if ((fft & 0x00FFFFFFL) == DUMB_ID(0,'C','H','N')) {

+				n_channels = (fft >> 24) - '0';

+				if ((unsigned int)(n_channels - 1) >= 9) {

+					/* Character was '0' or it wasn't a digit */

+					n_channels = 4;

+					sigdata->n_samples = 15;

+				}

+			} else if ((fft & 0xFFFFFF00L) == DUMB_ID('T','D','Z',0)) {

+				n_channels = (fft & 0x000000FFL) - '0';

+				if ((unsigned int)(n_channels - 1) >= 9) {

+					/* We've been very lenient, given that it should have

+					 * been 1, 2 or 3, but this MOD has been very naughty and

+					 * must be punished.

+					 */

+					n_channels = 4;

+					sigdata->n_samples = 15;

+				}

+			} else {

+				n_channels = 4;

+				sigdata->n_samples = 15;

+			}

+	}

+

+	// moo

+	if ( restrict && sigdata->n_samples == 15 )

+	{

+		free(sigdata);

+		dumbfile_close(f);

+		return NULL;

+	}

+

+	sigdata->n_pchannels = n_channels ? n_channels : 8; /* special case for 0, see above */

+

+	sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));

+	if (!sigdata->sample) {

+		free(sigdata);

+		dumbfile_close(f);

+		return NULL;

+	}

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->n_instruments = 0;

+

+	for (i = 0; i < sigdata->n_samples; i++)

+		sigdata->sample[i].data = NULL;

+

+	for (i = 0; i < sigdata->n_samples; i++) {

+		if (it_mod_read_sample_header(&sigdata->sample[i], f)) {

+			_dumb_it_unload_sigdata(sigdata);

+			dumbfile_close(f);

+			return NULL;

+		}

+	}

+

+	sigdata->n_orders = dumbfile_getc(f);

+	sigdata->restart_position = dumbfile_getc(f);

+	// what if this is >= 127? what about with Fast Tracker II?

+

+/*	if (sigdata->n_orders <= 0 || sigdata->n_orders > 128) { // is this right?

+		_dumb_it_unload_sigdata(sigdata);

+		dumbfile_close(f);

+		return NULL;

+	}*/

+

+	//if (sigdata->restart_position >= sigdata->n_orders)

+		//sigdata->restart_position = 0;

+

+	sigdata->order = malloc(128); /* We may need to scan the extra ones! */

+	if (!sigdata->order) {

+		_dumb_it_unload_sigdata(sigdata);

+		dumbfile_close(f);

+		return NULL;

+	}

+	if (dumbfile_getnc(sigdata->order, 128, f) < 128) {

+		_dumb_it_unload_sigdata(sigdata);

+		dumbfile_close(f);

+		return NULL;

+	}

+

+	if (sigdata->n_orders <= 0 || sigdata->n_orders > 128) { // is this right?

+		sigdata->n_orders = 128;

+		//while (sigdata->n_orders > 1 && !sigdata->order[sigdata->n_orders - 1]) sigdata->n_orders--;

+	}

+

+	if ( ! n_channels )

+		for (i = 0; i < 128; i++)

+			sigdata->order[i] >>= 1;

+

+	/* "The old NST format contains only 15 samples (instead of 31). Further

+	 * it doesn't contain a file format tag (id). So Pattern data offset is

+	 * at 20+15*30+1+1+128."

+	 * - Then I shall assume the File Format Tag never exists if there are

+	 * only 15 samples. I hope this isn't a faulty assumption...

+	 */

+	if (sigdata->n_samples == 31)

+		dumbfile_skip(f, 4);

+

+	/* Work out how many patterns there are. */

+	sigdata->n_patterns = -1;

+	for (i = 0; i < 128; i++)

+		if (sigdata->n_patterns < sigdata->order[i])

+			sigdata->n_patterns = sigdata->order[i];

+	sigdata->n_patterns++;

+

+	/* May as well try to save a tiny bit of memory. */

+	if (sigdata->n_orders < 128) {

+		unsigned char *order = realloc(sigdata->order, sigdata->n_orders);

+		if (order) sigdata->order = order;

+	}

+

+	sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));

+	if (!sigdata->pattern) {

+		_dumb_it_unload_sigdata(sigdata);

+		dumbfile_close(f);

+		return NULL;

+	}

+	for (i = 0; i < sigdata->n_patterns; i++)

+		sigdata->pattern[i].entry = NULL;

+

+	/* Read in the patterns */

+	{

+		unsigned char *buffer = malloc(256 * n_channels); /* 64 rows * 4 bytes */

+		if (!buffer) {

+			_dumb_it_unload_sigdata(sigdata);

+			dumbfile_close(f);

+			return NULL;

+		}

+		for (i = 0; i < sigdata->n_patterns; i++) {

+			if (it_mod_read_pattern(&sigdata->pattern[i], f, n_channels, buffer) != 0) {

+				free(buffer);

+				_dumb_it_unload_sigdata(sigdata);

+				dumbfile_close(f);

+				return NULL;

+			}

+		}

+		free(buffer);

+	}

+

+	rem = NULL;

+

+	/* uggly */

+	if (fft == DUMB_ID('M',0,0,0) || fft == DUMB_ID('8',0,0,0)) {

+		long skip;

+		long remain;

+		rem = f;

+		f = dumbfile_buffer_mod_2(rem, &remain);

+		if (!f) {

+			_dumb_it_unload_sigdata(sigdata);

+			dumbfile_close(rem);

+			return NULL;

+		}

+		for (skip = 0, i = 0; i < sigdata->n_samples; i++) {

+			if (sigdata->sample[i].flags & IT_SAMPLE_EXISTS) {

+				skip += sigdata->sample[i].length;

+			}

+		}

+		if (remain - skip) {

+			if (dumbfile_skip(f, remain - skip)) {

+				_dumb_it_unload_sigdata(sigdata);

+				dumbfile_close(f);

+				dumbfile_close(rem);

+				return NULL;

+			}

+		}

+	}

+

+	/* And finally, the sample data */

+	for (i = 0; i < sigdata->n_samples; i++) {

+		if (it_mod_read_sample_data(&sigdata->sample[i], f, fft)) {

+			_dumb_it_unload_sigdata(sigdata);

+			dumbfile_close(f);

+			if (rem) dumbfile_close(rem);

+			return NULL;

+		}

+	}

+

+	/* w00t! */

+	/*if ( n_channels == 4 &&

+		( sigdata->n_samples == 15 ||

+		( ( fft & 240 ) != DUMB_ID( 0, 0, 'C', 0 ) &&

+		( fft & 240 ) != DUMB_ID( 0, 0, 'H', 0 ) &&

+		( fft & 240 ) != 0 ) ) ) {

+		for ( i = 0; i < sigdata->n_samples; ++i ) {

+			IT_SAMPLE * sample = &sigdata->sample [i];

+			if ( sample && ( sample->flags & IT_SAMPLE_EXISTS ) ) {

+				int n, o;

+				o = sample->length;

+				if ( o > 4 ) o = 4;

+				for ( n = 0; n < o; ++n )

+					( ( char * ) sample->data ) [n] = 0;

+			}

+		}

+	}*/

+

+	dumbfile_close(f); /* Destroy the BUFFERED_MOD DUMBFILE we were using. */

+	/* The DUMBFILE originally passed to our function is intact. */

+	if (rem) dumbfile_close(rem);

+

+	/* Now let's initialise the remaining variables, and we're done! */

+	sigdata->flags = IT_WAS_AN_XM | IT_WAS_A_MOD | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_STEREO;

+

+	sigdata->global_volume = 128;

+	sigdata->mixing_volume = 48;

+	/* We want 50 ticks per second; 50/6 row advances per second;

+	 * 50*10=500 row advances per minute; 500/4=125 beats per minute.

+	 */

+	sigdata->speed = 6;

+	sigdata->tempo = 125;

+	sigdata->pan_separation = 128;

+

+	memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);

+

+	for (i = 0; i < DUMB_IT_N_CHANNELS; i += 4) {

+		sigdata->channel_pan[i+0] = 16;

+		sigdata->channel_pan[i+1] = 48;

+		sigdata->channel_pan[i+2] = 48;

+		sigdata->channel_pan[i+3] = 16;

+	}

+

+	_dumb_it_fix_invalid_orders(sigdata);

+

+	return sigdata;

+}

+

+

+

+DUH *dumb_read_mod_quick(DUMBFILE *f, int restrict)

+{

+	sigdata_t *sigdata;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_mod_load_sigdata(f, restrict);

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		const char *tag[2][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		tag[1][1] = "MOD";

+		return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readmod2.c b/plugins/dumb/dumb-kode54/src/it/readmod2.c
new file mode 100644
index 00000000..a22548a1
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readmod2.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readmod2.c - Function to read a good old-          / / \  \

+ *              fashioned Amiga module from an       | <  /   \_

+ *              open file and do an initial          |  \/ /\   /

+ *              run-through.                          \_  /  > /

+ *                                                      | \ / /

+ * Split off from readmod.c by entheh.                  |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+

+

+

+DUH *dumb_read_mod(DUMBFILE *f, int restrict)

+{

+	DUH *duh = dumb_read_mod_quick(f, restrict);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readmtm.c b/plugins/dumb/dumb-kode54/src/it/readmtm.c
new file mode 100644
index 00000000..8f0c2e4c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readmtm.c
@@ -0,0 +1,412 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readmtm.c - Code to read a MultiTracker Module     / / \  \

+ *             from an open file.                    | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Chris Moeller.                                  \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>

+#include <math.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+size_t strlen_max(const char * ptr, size_t max)

+{

+	const char * end, * start;

+	if (ptr==0) return 0;

+	start = ptr;

+	end = ptr + max;

+	while(*ptr && ptr < end) ptr++;

+	return ptr - start;

+}

+

+static int it_mtm_assemble_pattern(IT_PATTERN *pattern, const unsigned char * track, const unsigned short * sequence, int n_rows)

+{

+	int n, o, note, sample;

+	const unsigned char * t;

+	IT_ENTRY * entry;

+

+	pattern->n_rows = n_rows;

+	pattern->n_entries = n_rows;

+

+	for (n = 0; n < 32; n++) {

+		if (sequence[n]) {

+			t = &track[192 * (sequence[n] - 1)];

+			for (o = 0; o < n_rows; o++) {

+				if (t[0] || t[1] || t[2]) pattern->n_entries++;

+				t += 3;

+			}

+		}

+	}

+

+	entry = malloc(pattern->n_entries * sizeof(*entry));

+	if (!entry) return -1;

+	pattern->entry = entry;

+

+	for (n = 0; n < n_rows; n++) {

+		for (o = 0; o < 32; o++) {

+			if (sequence[o]) {

+				t = &track[192 * (sequence[o] - 1) + (n * 3)];

+				if (t[0] || t[1] || t[2]) {

+					entry->channel = o;

+					entry->mask = 0;

+					note = t[0] >> 2;

+					sample = ((t[0] << 4) | (t[1] >> 4)) & 0x3F;

+

+					if (note) {

+						entry->mask |= IT_ENTRY_NOTE;

+						entry->note = note + 24;

+					}

+

+					if (sample) {

+						entry->mask |= IT_ENTRY_INSTRUMENT;

+						entry->instrument = sample;

+					}

+

+					_dumb_it_xm_convert_effect(t[1] & 0xF, t[2], entry, 1);

+

+					if (entry->mask) entry++;

+				}

+			}

+		}

+		IT_SET_END_ROW(entry);

+		entry++;

+	}

+

+	pattern->n_entries = entry - pattern->entry;

+

+	return 0;

+}

+

+static int it_mtm_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f)

+{

+	int finetune, flags;

+

+	dumbfile_getnc(sample->name, 22, f);

+	sample->name[22] = 0;

+

+	sample->filename[0] = 0;

+

+	sample->length = dumbfile_igetl(f);

+	sample->loop_start = dumbfile_igetl(f);

+	sample->loop_end = dumbfile_igetl(f);

+	finetune = (signed char)(dumbfile_getc(f) << 4) >> 4; /* signed nibble */

+	sample->global_volume = 64;

+	sample->default_volume = dumbfile_getc(f);

+

+	flags = dumbfile_getc(f);

+

+	if (sample->length <= 0) {

+		sample->flags = 0;

+		return 0;

+	}

+

+	sample->flags = IT_SAMPLE_EXISTS;

+

+	if (flags & 1) {

+		sample->flags |= IT_SAMPLE_16BIT;

+		sample->length >>= 1;

+		sample->loop_start >>= 1;

+		sample->loop_end >>= 1;

+	}

+

+	sample->default_pan = 0;

+	sample->C5_speed = (int)( AMIGA_CLOCK / 214.0 );//(long)(16726.0*pow(DUMB_PITCH_BASE, finetune*32));

+	sample->finetune = finetune * 32;

+	// the above line might be wrong

+

+	if (sample->loop_end > sample->length)

+		sample->loop_end = sample->length;

+

+	if (sample->loop_end - sample->loop_start > 2)

+		sample->flags |= IT_SAMPLE_LOOP;

+

+	sample->vibrato_speed = 0;

+	sample->vibrato_depth = 0;

+	sample->vibrato_rate = 0;

+	sample->vibrato_waveform = 0; // do we have to set _all_ these?

+	sample->max_resampling_quality = -1;

+

+	return dumbfile_error(f);

+}

+

+static int it_mtm_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f)

+{

+	long i;

+	long truncated_size;

+

+	/* let's get rid of the sample data coming after the end of the loop */

+	if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) {

+		truncated_size = sample->length - sample->loop_end;

+		sample->length = sample->loop_end;

+	} else {

+		truncated_size = 0;

+	}

+

+	sample->data = malloc(sample->length);

+

+	if (!sample->data)

+		return -1;

+

+	dumbfile_getnc((char *)sample->data, sample->length, f);

+	dumbfile_skip(f, truncated_size);

+

+	if (dumbfile_error(f))

+		return -1;

+

+	for (i = 0; i < sample->length; i++)

+		((signed char *)sample->data)[i] ^= 0x80;

+

+	return 0;

+}

+

+static DUMB_IT_SIGDATA *it_mtm_load_sigdata(DUMBFILE *f, int * version)

+{

+	DUMB_IT_SIGDATA *sigdata;

+

+	int n, o, n_tracks, l_comment, n_rows, n_channels;

+

+	unsigned char * track;

+

+	unsigned short * sequence;

+

+	char * comment;

+

+	if (dumbfile_getc(f) != 'M' ||

+		dumbfile_getc(f) != 'T' ||

+		dumbfile_getc(f) != 'M') goto error;

+

+	*version = dumbfile_getc(f);

+

+	sigdata = malloc(sizeof(*sigdata));

+	if (!sigdata) goto error;

+

+	dumbfile_getnc(sigdata->name, 20, f);

+	sigdata->name[20] = 0;

+

+	n_tracks = dumbfile_igetw(f);

+	sigdata->n_patterns = dumbfile_getc(f) + 1;

+	sigdata->n_orders = dumbfile_getc(f) + 1;

+	l_comment = dumbfile_igetw(f);

+	sigdata->n_samples = dumbfile_getc(f);

+	//if (dumbfile_getc(f)) goto error_sd;

+	dumbfile_getc(f);

+	n_rows = dumbfile_getc(f);

+	n_channels = dumbfile_getc(f);

+

+	if (dumbfile_error(f) ||

+		(n_tracks <= 0) ||

+		(sigdata->n_samples <= 0) ||

+		(n_rows <= 0 || n_rows > 64) ||

+		(n_channels <= 0 || n_channels > 32)) goto error_sd;

+

+	memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);

+

+	if (dumbfile_getnc(sigdata->channel_pan, 32, f) < 32) goto error_sd;

+

+	for (n = 0; n < 32; n++) {

+		if (sigdata->channel_pan[n] <= 15) {

+			sigdata->channel_pan[n] -= (sigdata->channel_pan[n] & 8) >> 3;

+			sigdata->channel_pan[n] = (sigdata->channel_pan[n] * 32) / 7;

+		} else {

+			sigdata->channel_volume[n] = 0;

+			sigdata->channel_pan[n] = 7;

+		}

+	}

+

+	for (n = 32; n < DUMB_IT_N_CHANNELS; n += 4) {

+		sigdata->channel_pan[n  ] = 16;

+		sigdata->channel_pan[n+1] = 48;

+		sigdata->channel_pan[n+2] = 48;

+		sigdata->channel_pan[n+3] = 16;

+	}

+

+	sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));

+	if (!sigdata->sample) goto error_sd;

+

+	sigdata->flags = IT_WAS_AN_XM | IT_WAS_A_MOD | IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX;

+

+	sigdata->global_volume = 128;

+	sigdata->mixing_volume = 48;

+	sigdata->speed = 6;

+	sigdata->tempo = 125;

+	sigdata->pan_separation = 128;

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->n_instruments = 0;

+

+	sigdata->restart_position = 0;

+	sigdata->n_pchannels = n_channels;

+

+	for (n = 0; n < sigdata->n_samples; n++)

+		sigdata->sample[n].data = NULL;

+

+	for (n = 0; n < sigdata->n_samples; n++) {

+		if (it_mtm_read_sample_header(&sigdata->sample[n], f)) goto error_usd;

+	}

+

+	sigdata->order = malloc(sigdata->n_orders);

+	if (!sigdata->order) goto error_usd;

+

+	if (dumbfile_getnc(sigdata->order, sigdata->n_orders, f) < sigdata->n_orders) goto error_usd;

+	if (sigdata->n_orders < 128)

+		if (dumbfile_skip(f, 128 - sigdata->n_orders)) goto error_usd;

+

+	track = malloc(192 * n_tracks);

+	if (!track) goto error_usd;

+

+	if (dumbfile_getnc(track, 192 * n_tracks, f) < 192 * n_tracks) goto error_ft;

+

+	sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));

+	if (!sigdata->pattern) goto error_ft;

+	for (n = 0; n < sigdata->n_patterns; n++)

+		sigdata->pattern[n].entry = NULL;

+

+	sequence = malloc(sigdata->n_patterns * 32 * sizeof(*sequence));

+	if (!sequence) goto error_ft;

+

+	for (n = 0; n < sigdata->n_patterns; n++) {

+		for (o = 0; o < 32; o++) {

+			sequence[(n * 32) + o] = dumbfile_igetw(f);

+			if (sequence[(n * 32) + o] > n_tracks)

+			{

+				//goto error_fs;

+				// illegal track number, silence instead of rejecting the file

+				sequence[(n * 32) + o] = 0;

+			}

+		}

+	}

+

+	for (n = 0; n < sigdata->n_patterns; n++) {

+		if (it_mtm_assemble_pattern(&sigdata->pattern[n], track, &sequence[n * 32], n_rows)) goto error_fs;

+	}

+

+	if (l_comment) {

+		comment = malloc(l_comment);

+		if (!comment) goto error_fs;

+		if (dumbfile_getnc(comment, l_comment, f) < l_comment) goto error_fc;

+

+		/* Time for annoying "logic", yes. We want each line which has text,

+		 * and each blank line in between all the valid lines.

+		 */

+

+		/* Find last actual line. */

+		for (o = -1, n = 0; n < l_comment; n += 40) {

+			if (comment[n]) o = n;

+		}

+

+		if (o >= 0) {

+

+			int l, m;

+

+			for (l = 0, n = 0; n <= o; n += 40) {

+				l += strlen_max(&comment[n], 40) + 2;

+			}

+

+			l -= 1;

+

+			sigdata->song_message = malloc(l);

+			if (!sigdata->song_message) goto error_fc;

+

+			for (m = 0, n = 0; n <= o; n += 40) {

+				int p = strlen_max(&comment[n], 40);

+				if (p) {

+					memcpy(sigdata->song_message + m, &comment[n], p);

+					m += p;

+				}

+				if (l - m > 1) {

+					sigdata->song_message[m++] = 13;

+					sigdata->song_message[m++] = 10;

+				}

+			}

+			

+			sigdata->song_message[m] = 0;

+		}

+

+		free(comment);

+	}

+

+	for (n = 0; n < sigdata->n_samples; n++) {

+		if (it_mtm_read_sample_data(&sigdata->sample[n], f)) goto error_fs;

+	}

+

+	_dumb_it_fix_invalid_orders(sigdata);

+

+	free(sequence);

+	free(track);

+

+	return sigdata;

+

+error_fc:

+	free(comment);

+error_fs:

+	free(sequence);

+error_ft:

+	free(track);

+error_usd:

+	_dumb_it_unload_sigdata(sigdata);

+	return NULL;

+

+error_sd:

+	free(sigdata);

+error:

+	return NULL;

+}

+

+static char hexdigit(int in)

+{

+	if (in < 10) return in + '0';

+	else return in + 'A' - 10;

+}

+

+DUH *dumb_read_mtm_quick(DUMBFILE *f)

+{

+	sigdata_t *sigdata;

+	int ver;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_mtm_load_sigdata(f, &ver);

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		char version[16];

+		const char *tag[2][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		version[0] = 'M';

+		version[1] = 'T';

+		version[2] = 'M';

+		version[3] = ' ';

+		version[4] = 'v';

+		version[5] = hexdigit(ver >> 4);

+		version[6] = '.';

+		version[7] = hexdigit(ver & 15);

+		version[8] = 0;

+		tag[1][1] = (const char *) &version;

+		return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readoldpsm.c b/plugins/dumb/dumb-kode54/src/it/readoldpsm.c
new file mode 100644
index 00000000..e7830f2a
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readoldpsm.c
@@ -0,0 +1,727 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readpsm.c - Code to read an old Protracker         / / \  \

+ *             Studio module from an open file.      | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Chris Moeller.                                  \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>

+#include <math.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+static int psm_sample_compare(const void *e1, const void *e2)

+{

+	const unsigned char * pa = e1;

+	const unsigned char * pb = e2;

+	int a = pa[37] | (pa[38] << 8) | (pa[39] << 16) | (pa[40] << 24);

+	int b = pb[37] | (pb[38] << 8) | (pb[39] << 16) | (pb[40] << 24);

+	return a - b;

+}

+

+static int it_old_psm_read_samples(IT_SAMPLE ** sample, DUMBFILE * f, int * num, const unsigned char * prebuffer, long data_pos, long data_size)

+{

+	int n, o, pos, count = *num, true_num, snum, offset, flags, finetune, delta;

+

+	unsigned char * buffer, * sbuffer = 0;

+	const unsigned char * sdata;

+

+	buffer = malloc(count * 64);

+	if (!buffer) goto error;

+

+	if (dumbfile_getnc(buffer, count * 64, f) < count * 64) goto error_fb;

+

+	pos = dumbfile_pos(f);

+

+	true_num = 0;

+

+	for (n = 0; n < count; n++) {

+		snum = buffer[(n * 64) + 45] | (buffer[(n * 64) + 46] << 8);

+		if ((snum < 1) || (snum > 255)) goto error_fb;

+		if (true_num < snum) true_num = snum;

+	}

+

+	if (true_num > count) {

+		IT_SAMPLE * meh = realloc(*sample, true_num * sizeof(*meh));

+		if (!meh) goto error_fb;

+		for (n = count; n < true_num; n++) {

+			meh[n].data = NULL;

+		}

+		*sample = meh;

+		*num = true_num;

+	}

+

+	qsort(buffer, count, 64, &psm_sample_compare);

+

+	for (n = 0; n < true_num; n++) {

+		(*sample)[n].flags = 0;

+	}

+

+	for (n = 0; n < count; n++) {

+		IT_SAMPLE * s;

+		snum = buffer[(n * 64) + 45] | (buffer[(n * 64) + 46] << 8);

+		s = &((*sample)[snum - 1]);

+		memcpy(s->filename, buffer + (n * 64), 13);

+		s->filename[13] = 0;

+		memcpy(s->name, buffer + (n * 64) + 13, 24);

+		s->name[24] = 0;

+		offset = buffer[(n * 64) + 37] | (buffer[(n * 64) + 38] << 8) |

+				 (buffer[(n * 64) + 39] << 16) | (buffer[(n * 64) + 40] << 24);

+		flags = buffer[(n * 64) + 47];

+		s->length = buffer[(n * 64) + 48] | (buffer[(n * 64) + 49] << 8) |

+					(buffer[(n * 64) + 50] << 16) | (buffer[(n * 64) + 51] << 24);

+		s->loop_start = buffer[(n * 64) + 52] | (buffer[(n * 64) + 53] << 8) |

+						(buffer[(n * 64) + 54] << 16) | (buffer[(n * 64) + 55] << 24);

+		s->loop_end = buffer[(n * 64) + 56] | (buffer[(n * 64) + 57] << 8) |

+					  (buffer[(n * 64) + 58] << 16) | (buffer[(n * 64) + 59] << 24);

+

+		if (s->length <= 0) continue;

+

+		finetune = buffer[(n * 64) + 60];

+		s->default_volume = buffer[(n * 64) + 61];

+		s->C5_speed = buffer[(n * 64) + 62] | (buffer[(n * 64) + 63] << 8);

+		if (finetune < 16) {

+			if (finetune >= 8) finetune -= 16;

+			//s->C5_speed = (long)((double)s->C5_speed * pow(DUMB_PITCH_BASE, finetune*32));

+			s->finetune = finetune * 32;

+		}

+		else s->finetune = 0;

+

+		s->flags |= IT_SAMPLE_EXISTS;

+		if (flags & 0x41) {

+			s->flags &= ~IT_SAMPLE_EXISTS;

+			continue;

+		}

+		if (flags & 0x20) s->flags |= IT_SAMPLE_PINGPONG_LOOP;

+		if (flags & 4) s->flags |= IT_SAMPLE_16BIT;

+

+		if (flags & 0x80) {

+			s->flags |= IT_SAMPLE_LOOP;

+			if ((unsigned int)s->loop_end > (unsigned int)s->length)

+				s->loop_end = s->length;

+			else if ((unsigned int)s->loop_start >= (unsigned int)s->loop_end)

+				s->flags &= ~IT_SAMPLE_LOOP;

+			else

+				s->length = s->loop_end;

+		}

+

+		s->global_volume = 64;

+

+		s->vibrato_speed = 0;

+		s->vibrato_depth = 0;

+		s->vibrato_rate = 0;

+		s->vibrato_waveform = IT_VIBRATO_SINE;

+		s->max_resampling_quality = -1;

+

+		s->data = malloc(s->length * ((flags & 4) ? 2 : 1));

+		if (!s->data) goto error_fb;

+

+		if ((offset >= data_pos) &&

+			((offset + s->length * ((flags & 4) ? 2 : 1)) <= (data_pos + data_size))) {

+			sdata = prebuffer + offset - data_pos;

+		} else if (offset >= pos) {

+			if (dumbfile_skip(f, offset - pos)) goto error_fb;

+			pos = offset;

+			offset = s->length * ((flags & 4) ? 2 : 1);

+			sbuffer = malloc(offset);

+			if (!sbuffer) goto error_fb;

+			if (dumbfile_getnc(sbuffer, offset, f) < offset) goto error_fsb;

+			sdata = sbuffer;

+		} else

+			goto error_fb;

+

+		if (flags & 0x10) {

+			if (flags & 8) {

+				if (flags & 4) {

+					for (o = 0; o < s->length; o++)

+						((short *)s->data)[o] = (sdata[o * 2] | (sdata[(o * 2) + 1] << 8)) ^ 0x8000;

+				} else {

+					for (o = 0; o < s->length; o++)

+						((signed char *)s->data)[o] = sdata[o] ^ 0x80;

+				}

+			} else {

+				if (flags & 4) {

+					for (o = 0; o < s->length; o++)

+						((short *)s->data)[o] = sdata[o * 2] | (sdata[(o * 2) + 1] << 8);

+				} else {

+					memcpy(s->data, sdata, s->length);

+				}

+			}

+		} else {

+			delta = 0;

+			if (flags & 8) {

+				/* unsigned delta? mehhh, does anything even use this? */

+				if (flags & 4) {

+					for (o = 0; o < s->length; o++) {

+						delta += (short)(sdata[o * 2] | (sdata[(o * 2) + 1] << 8));

+						((short *)s->data)[o] = delta ^ 0x8000;

+					}

+				} else {

+					for (o = 0; o < s->length; o++) {

+						delta += (signed char)sdata[o];

+						((signed char *)s->data)[o] = delta ^ 0x80;

+					}

+				}

+			} else {

+				if (flags & 4) {

+					for (o = 0; o < s->length; o++) {

+						delta += (short)(sdata[o * 2] | (sdata[(o * 2) + 1] << 8));

+						((short *)s->data)[o] = delta;

+					}

+				} else {

+					for (o = 0; o < s->length; o++) {

+						delta += (signed char)sdata[o];

+						((signed char *)s->data)[o] = delta;

+					}

+				}

+			}

+		}

+

+		if (sbuffer) {

+			free(sbuffer);

+			sbuffer = 0;

+		}

+	}

+

+	free(buffer);

+

+	return 0;

+

+error_fsb:

+	if (sbuffer) free(sbuffer);

+error_fb:

+	free(buffer);

+error:

+	return -1;

+}

+

+static int it_old_psm_read_patterns(IT_PATTERN * pattern, DUMBFILE * f, int num, int size, int pchans, int sflags)

+{

+	int n, offset, psize, rows, chans, row, flags, channel;

+

+	unsigned char * buffer, * ptr, * end;

+

+	IT_ENTRY * entry;

+

+	buffer = malloc(size);

+	if (!buffer) goto error;

+

+	if (dumbfile_getnc(buffer, size, f) < size) goto error_fb;

+

+	offset = 0;

+

+	for (n = 0; n < num; n++) {

+		IT_PATTERN * p = &pattern[n];

+

+		if (offset >= size) goto error_fb;

+

+		ptr = buffer + offset;

+		psize = ptr[0] | (ptr[1] << 8);

+		rows = ptr[2];

+		chans = ptr[3];

+

+		if (!rows || !chans) {

+			p->n_rows = 1;

+			p->n_entries = 0;

+			continue;

+		}

+

+		psize = (psize + 15) & ~15;

+

+		end = ptr + psize;

+		ptr += 4;

+

+		p->n_rows = rows;

+		p->n_entries = rows;

+		row = 0;

+

+		while ((row < rows) && (ptr < end)) {

+			flags = *ptr++;

+			if (!flags) {

+				row++;

+				continue;

+			}

+			if (flags & 0xE0) {

+				p->n_entries++;

+				if (flags & 0x80) ptr += 2;

+				if (flags & 0x40) ptr++;

+				if (flags & 0x20) {

+					ptr++;

+					if (*ptr == 40) ptr += 3;

+					else ptr++;

+				}

+			}

+		}

+

+		entry = malloc(p->n_entries * sizeof(*p->entry));

+		if (!entry) goto error_fb;

+

+		p->entry = entry;

+

+		ptr = buffer + offset + 4;

+		row = 0;

+

+		while ((row < rows) && (ptr < end)) {

+			flags = *ptr++;

+			if (!flags) {

+				IT_SET_END_ROW(entry);

+				entry++;

+				row++;

+				continue;

+			}

+			if (flags & 0xE0) {

+				entry->mask = 0;

+				entry->channel = channel = flags & 0x1F;

+				if (channel >= chans)

+				{

+					//channel = 0;

+					goto error_fb;

+				}

+				if (flags & 0x80) {

+					if ((*ptr < 60) && (channel < pchans)) {

+						entry->mask |= IT_ENTRY_NOTE;

+						entry->note = *ptr + 36;

+					}

+					ptr++;

+					if (*ptr) {

+						entry->mask |= IT_ENTRY_INSTRUMENT;

+						entry->instrument = *ptr;

+					}

+					ptr++;

+				}

+				if (flags & 0x40) {

+					if (*ptr <= 64) {

+						entry->mask |= IT_ENTRY_VOLPAN;

+						entry->volpan = *ptr;

+					}

+					ptr++;

+				}

+				if (flags & 0x20) {

+					entry->mask |= IT_ENTRY_EFFECT;

+

+					switch (*ptr) {

+						case 1:

+							entry->effect = IT_XM_FINE_VOLSLIDE_UP;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 2:

+							entry->effect = IT_VOLUME_SLIDE;

+							entry->effectvalue = (ptr[1] << 4) & 0xF0;

+							break;

+

+						case 3:

+							entry->effect = IT_XM_FINE_VOLSLIDE_DOWN;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 4:

+							entry->effect = IT_VOLUME_SLIDE;

+							entry->effectvalue = ptr[1] & 0xF;

+							break;

+

+						case 10:

+							entry->effect = IT_PORTAMENTO_UP;

+							entry->effectvalue = EFFECT_VALUE(0xF, ptr[1]);

+							break;

+

+						case 11:

+							entry->effect = IT_PORTAMENTO_UP;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 12:

+							entry->effect = IT_PORTAMENTO_DOWN;

+							entry->effectvalue = EFFECT_VALUE(ptr[1], 0xF);

+							break;

+

+						case 13:

+							entry->effect = IT_PORTAMENTO_DOWN;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 14:

+							entry->effect = IT_TONE_PORTAMENTO;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 15:

+							entry->effect = IT_S;

+							entry->effectvalue = EFFECT_VALUE(IT_S_SET_GLISSANDO_CONTROL, ptr[1] & 15);

+							break;

+

+						case 16:

+							entry->effect = IT_VOLSLIDE_TONEPORTA;

+							entry->effectvalue = ptr[1] << 4;

+							break;

+

+						case 17:

+							entry->effect = IT_VOLSLIDE_TONEPORTA;

+							entry->effectvalue = ptr[1] & 0xF;

+							break;

+

+						case 20:

+							entry->effect = IT_VIBRATO;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 21:

+							entry->effect = IT_S;

+							entry->effectvalue = EFFECT_VALUE(IT_S_SET_VIBRATO_WAVEFORM, ptr[1] & 11);

+							break;

+

+						case 22:

+							entry->effect = IT_VOLSLIDE_VIBRATO;

+							entry->effectvalue = ptr[1] << 4;

+							break;

+

+						case 23:

+							entry->effect = IT_VOLSLIDE_VIBRATO;

+							entry->effectvalue = ptr[1] & 0xF;

+							break;

+

+						case 30:

+							entry->effect = IT_TREMOLO;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 31:

+							entry->effect = IT_S;

+							entry->effectvalue = EFFECT_VALUE(IT_S_SET_TREMOLO_WAVEFORM, ptr[1] & 11);

+							break;

+

+						case 40:

+							entry->effect = IT_SET_SAMPLE_OFFSET;

+							entry->effectvalue = ptr[2];

+							ptr += 2;

+							break;

+

+						case 41:

+							entry->effect = IT_XM_RETRIGGER_NOTE;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 42:

+							entry->effect = IT_S;

+							entry->effectvalue = EFFECT_VALUE(IT_S_DELAYED_NOTE_CUT, ptr[1] & 0xF);

+							break;

+

+						case 43:

+							entry->effect = IT_S;

+							entry->effectvalue = EFFECT_VALUE(IT_S_NOTE_DELAY, ptr[1] & 0xF);

+							break;

+

+						case 50:

+							entry->effect = IT_JUMP_TO_ORDER;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 51:

+							entry->effect = IT_BREAK_TO_ROW;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 52:

+							entry->effect = IT_S;

+							entry->effectvalue = EFFECT_VALUE(IT_S_PATTERN_LOOP, ptr[1] & 0xF);

+							break;

+

+						case 53:

+							entry->effect = IT_S;

+							entry->effectvalue = EFFECT_VALUE(IT_S_PATTERN_DELAY, ptr[1] & 0xF);

+							break;

+

+						case 60:

+							entry->effect = IT_SET_SPEED;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 61:

+							entry->effect = IT_SET_SONG_TEMPO;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 70:

+							entry->effect = IT_ARPEGGIO;

+							entry->effectvalue = ptr[1];

+							break;

+

+						case 71:

+							entry->effect = IT_S;

+							entry->effectvalue = EFFECT_VALUE(IT_S_FINETUNE, ptr[1] & 0xF);

+							break;

+

+						case 72:

+							/* "balance" ... panning? */

+							entry->effect = IT_SET_PANNING;

+							entry->effectvalue = ((ptr[1] - ((ptr[1] & 8) >> 3)) << 5) / 7;

+							break;

+

+						default:

+							entry->mask &= ~IT_ENTRY_EFFECT;

+					}

+

+					ptr += 2;

+				}

+				if (entry->mask) entry++;

+			}

+		}

+

+		p->n_entries = entry - p->entry;

+		offset += psize;

+	}

+

+	free(buffer);

+

+	return 0;

+

+error_fb:

+	free(buffer);

+error:

+	return -1;

+}

+

+#define PSM_COMPONENT_ORDERS            0

+#define PSM_COMPONENT_PANPOS            1

+#define PSM_COMPONENT_PATTERNS          2

+#define PSM_COMPONENT_SAMPLE_HEADERS    3

+#define PSM_COMPONENT_COMMENTS          4

+

+typedef struct PSM_COMPONENT

+{

+	unsigned char type;

+	long offset;

+}

+PSM_COMPONENT;

+

+static int psm_component_compare(const void *e1, const void *e2)

+{

+	return ((const PSM_COMPONENT *)e1)->offset -

+	       ((const PSM_COMPONENT *)e2)->offset;

+}

+

+static DUMB_IT_SIGDATA *it_old_psm_load_sigdata(DUMBFILE *f)

+{

+	DUMB_IT_SIGDATA *sigdata;

+

+	unsigned char * ptr = 0;

+

+	PSM_COMPONENT *component;

+	int n_components = 0;

+

+	int n, flags, version, pver, n_orders, n_channels, total_pattern_size;

+

+	if (dumbfile_mgetl(f) != DUMB_ID('P','S','M',254)) goto error;

+

+	sigdata = malloc(sizeof(*sigdata));

+	if (!sigdata) goto error;

+

+	if (dumbfile_getnc(sigdata->name, 60, f) < 60 ||

+		sigdata->name[59] != 0x1A) goto error_sd;

+	sigdata->name[59] = 0;

+

+	flags = dumbfile_getc(f);

+	version = dumbfile_getc(f);

+	pver = dumbfile_getc(f);

+	sigdata->speed = dumbfile_getc(f);

+	sigdata->tempo = dumbfile_getc(f);

+	sigdata->mixing_volume = dumbfile_getc(f);

+	sigdata->n_orders = dumbfile_igetw(f);

+	n_orders = dumbfile_igetw(f);

+	sigdata->n_patterns = dumbfile_igetw(f);

+	sigdata->n_samples = dumbfile_igetw(f);

+	sigdata->n_pchannels = dumbfile_igetw(f);

+	n_channels = dumbfile_igetw(f);

+

+	if (dumbfile_error(f) ||

+		(flags & 1) ||

+		(version != 1 && version != 0x10) ||

+		(pver) ||

+		(sigdata->n_orders <= 0) ||

+		(sigdata->n_orders > 255) ||

+		(n_orders > 255) ||

+		(n_orders < sigdata->n_orders) ||

+		(sigdata->n_patterns > 255) ||

+		(sigdata->n_samples > 255) ||

+		(sigdata->n_pchannels > DUMB_IT_N_CHANNELS) ||

+		(sigdata->n_pchannels > n_channels) ||

+		(n_channels > DUMB_IT_N_CHANNELS))

+		goto error_sd;

+

+	sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX;

+

+	sigdata->global_volume = 128;

+	sigdata->pan_separation = 128;

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->sample = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->n_instruments = 0;

+

+	sigdata->restart_position = 0;

+

+	sigdata->order = malloc(sigdata->n_orders);

+	if (!sigdata->order) goto error_usd;

+

+	if (sigdata->n_samples) {

+		sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));

+		if (!sigdata->sample) goto error_usd;

+		for (n = 0; n < sigdata->n_samples; n++)

+			sigdata->sample[n].data = NULL;

+	}

+

+	if (sigdata->n_patterns) {

+		sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));

+		if (!sigdata->pattern) goto error_usd;

+		for (n = 0; n < sigdata->n_patterns; n++)

+			sigdata->pattern[n].entry = NULL;

+	}

+

+	component = malloc(5 * sizeof(*component));

+	if (!component) goto error_usd;

+

+	for (n = 0; n < 5; n++) {

+		component[n_components].offset = dumbfile_igetl(f);

+		if (component[n_components].offset) {

+			component[n_components].type = n;

+			n_components++;

+		}

+	}

+

+	if (!n_components) goto error_fc;

+

+	total_pattern_size = dumbfile_igetl(f);

+	if (!total_pattern_size) goto error_fc;

+

+	qsort(component, n_components, sizeof(PSM_COMPONENT), &psm_component_compare);

+

+	memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);

+

+	for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) {

+		sigdata->channel_pan[n  ] = 16;

+		sigdata->channel_pan[n+1] = 48;

+		sigdata->channel_pan[n+2] = 48;

+		sigdata->channel_pan[n+3] = 16;

+	}

+

+	for (n = 0; n < n_components; n++)

+	{

+		int o;

+		long data_pos, data_size;

+

+		/* Whee, sample data may be before the sample headers */

+

+		data_pos = dumbfile_pos(f);

+		if (data_pos > component[n].offset) goto error_fc;

+

+		data_size = component[n].offset - data_pos;

+

+		if (data_size) {

+			ptr = malloc(data_size);

+			if (!ptr) goto error_fc;

+

+			if (dumbfile_getnc(ptr, data_size, f) < data_size) goto error_fp;

+		}

+

+		switch (component[n].type) {

+

+			case PSM_COMPONENT_ORDERS:

+				if (dumbfile_getnc(sigdata->order, sigdata->n_orders, f) < sigdata->n_orders) goto error_fp;

+				if (n_orders > sigdata->n_orders)

+					if (dumbfile_skip(f, n_orders - sigdata->n_orders))

+						goto error_fp;

+				if (dumbfile_igetw(f)) goto error_fp;

+				break;

+

+			case PSM_COMPONENT_PANPOS:

+				if (dumbfile_getnc(sigdata->channel_pan, sigdata->n_pchannels, f) < sigdata->n_pchannels) goto error_fp;

+				for (o = 0; o < sigdata->n_pchannels; o++) {

+					sigdata->channel_pan[o] -= (sigdata->channel_pan[o] & 8) >> 3;

+					sigdata->channel_pan[o] = ((int)sigdata->channel_pan[o] << 5) / 7;

+				}

+				break;

+

+			case PSM_COMPONENT_PATTERNS:

+				if (it_old_psm_read_patterns(sigdata->pattern, f, sigdata->n_patterns, total_pattern_size, sigdata->n_pchannels, flags)) goto error_fp;

+				break;

+

+			case PSM_COMPONENT_SAMPLE_HEADERS:

+				if (it_old_psm_read_samples(&sigdata->sample, f, &sigdata->n_samples, ptr, data_pos, data_size)) goto error_fp;

+				break;

+

+			case PSM_COMPONENT_COMMENTS:

+				if (dumbfile_mgetl(f) == DUMB_ID('T','E','X','T')) {

+					o = dumbfile_igetw(f);

+					if (o > 0) {

+						sigdata->song_message = malloc(o + 1);

+						if (dumbfile_getnc(sigdata->song_message, o, f) < o) goto error_fp;

+						sigdata->song_message[o] = 0;

+					}

+				}

+				break;

+		}

+

+		if (ptr) {

+			free(ptr);

+			ptr = 0;

+		}

+	}

+

+	_dumb_it_fix_invalid_orders(sigdata);

+

+	free(component);

+

+	return sigdata;

+

+error_fp:

+	if (ptr) free(ptr);

+error_fc:

+	free(component);

+error_usd:

+	_dumb_it_unload_sigdata(sigdata);

+	return NULL;

+error_sd:

+	free(sigdata);

+error:

+	return NULL;

+}

+

+DUH *dumb_read_old_psm_quick(DUMBFILE *f)

+{

+	sigdata_t *sigdata;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_old_psm_load_sigdata(f);

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		const char *tag[2][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		tag[1][1] = "PSM (old)";

+		return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readpsm.c b/plugins/dumb/dumb-kode54/src/it/readpsm.c
new file mode 100644
index 00000000..129cdf6f
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readpsm.c
@@ -0,0 +1,1273 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readpsm.c - Code to read a Protracker Studio       / / \  \

+ *             module from an open file.             | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Chris Moeller.                                  \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+#define PSMV_OLD 940730

+#define PSMV_NEW 940902

+

+typedef struct _PSMCHUNK

+{

+	int id;

+	int len;

+	unsigned char * data;

+} PSMCHUNK;

+

+typedef struct _PSMEVENT

+{

+	int type;

+	unsigned char data[8];

+} PSMEVENT;

+

+#define PSM_EVENT_END               0

+#define PSM_EVENT_PLAY_PATTERN      1

+#define PSM_EVENT_JUMP_TO_LINE      4

+#define PSM_EVENT_SET_SPEED         7

+#define PSM_EVENT_SET_BPM           8

+#define PSM_EVENT_SAMPLE_MAP_TABLE 12

+#define PSM_EVENT_CHANGE_PAN       13

+#define PSM_EVENT_CHANGE_VOL       14

+

+static int it_psm_process_sample(IT_SAMPLE * sample, const unsigned char * data, int len, int id, int version) {

+	int flags;

+	int insno;

+	int length;

+	int loopstart;

+	int loopend;

+	int panpos;

+	int defvol;

+	int samplerate;

+

+	if (len < 0x60) return -1;

+

+	flags = data[0];

+

+	if (version == PSMV_OLD) {

+		memcpy(sample->name, data + 0x0D, 34);

+		sample->name[34] = 0;

+

+		insno = data[0x34] | (data[0x35] << 8);

+		length = data[0x36] | (data[0x37] << 8) | (data[0x38] << 16) | (data[0x39] << 24);

+		loopstart = data[0x3A] | (data[0x3B] << 8) | (data[0x3C] << 16) | (data[0x3D] << 24);

+		loopend = data[0x3E] | (data[0x3F] << 8) | (data[0x40] << 16) | (data[0x41] << 24);

+		panpos = data[0x43];

+		defvol = data[0x44];

+		samplerate = data[0x49] | (data[0x4A] << 8) | (data[0x4B] << 16) | (data[0x4C] << 24);

+	} else if (version == PSMV_NEW) {

+		memcpy(sample->name, data + 0x11, 34);

+		sample->name[34] = 0;

+

+		insno = data[0x38] | (data[0x39] << 8);

+		length = data[0x3A] | (data[0x3B] << 8) | (data[0x3C] << 16) | (data[0x3D] << 24);

+		loopstart = data[0x3E] | (data[0x3F] << 8) | (data[0x40] << 16) | (data[0x41] << 24);

+		loopend = data[0x42] | (data[0x43] << 8) | (data[0x44] << 16) | (data[0x45] << 24);

+		panpos = data[0x48];

+		defvol = data[0x49];

+		samplerate = data[0x4E] | (data[0x4F] << 8) | (data[0x50] << 16) | (data[0x51] << 24);

+	}

+

+	if (insno != id) return -1;

+

+	if (!length) {

+		sample->flags &= ~IT_SAMPLE_EXISTS;

+		return 0;

+	}

+	

+	if ((length > len - 0x60) || ((flags & 0x7F) != 0)) return -1;

+

+	sample->flags = IT_SAMPLE_EXISTS;

+	sample->length = length;

+	sample->loop_start = loopstart;

+	sample->loop_end = loopend;

+	sample->C5_speed = samplerate;

+	sample->default_volume = defvol >> 1;

+	sample->default_pan = 0;

+	sample->filename[0] = 0;

+	sample->global_volume = 64;

+	sample->vibrato_speed = 0;

+	sample->vibrato_depth = 0;

+	sample->vibrato_rate = 0;

+	sample->vibrato_waveform = IT_VIBRATO_SINE;

+	sample->finetune = 0;

+	sample->max_resampling_quality = -1;

+

+	if (flags & 0x80) {

+		if (((unsigned int)sample->loop_end <= (unsigned int)sample->length) &&

+			((unsigned int)sample->loop_start < (unsigned int)sample->loop_end)) {

+			sample->length = sample->loop_end;

+			sample->flags |= IT_SAMPLE_LOOP;

+		}

+	}

+

+	sample->data = malloc(sample->length);

+	if (!sample->data)

+		return -1;

+

+	flags = 0;

+	data += 0x60;

+

+	for (insno = 0; insno < sample->length; insno++) {

+		flags += (signed char)(*data++);

+		((signed char *)sample->data)[insno] = flags;

+	}

+

+	return 0;

+}

+

+static int it_psm_process_pattern(IT_PATTERN * pattern, const unsigned char * data, int len, int speed, int bpm, const unsigned char * pan, const int * vol, int version) {

+	int length, nrows, row, rowlen, pos;

+	unsigned flags, chan;

+	IT_ENTRY * entry;

+

+	length = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);

+	if (len > length) len = length;

+

+	if (version == PSMV_OLD) {

+		if (len < 10) return -1;

+		data += 8;

+		len -= 8;

+	} else if (version == PSMV_NEW) {

+		if (len < 14) return -1;

+		data += 12;

+		len -= 12;

+	}

+

+	nrows = data[0] | (data[1] << 8);

+

+	if (!nrows) return 0;

+

+	pattern->n_rows = nrows;

+

+	data += 2;

+	len -= 2;

+

+	pattern->n_entries = 0;

+

+	row = 0;

+	pos = 2;

+	rowlen = data[0] | (data[1] << 8);

+

+	while ((row < nrows) && (pos < len)) {

+		if (pos >= rowlen) {

+			row++;

+			rowlen += data[pos] | (data[pos+1] << 8);

+			pos += 2;

+			continue;

+		}

+

+		flags = data[pos++];

+		chan = data[pos++];

+

+		if (chan > 63) return -1;

+

+		if (flags & 0xF0) {

+			pattern->n_entries++;

+			if (flags & 0x80) pos++;

+			if (flags & 0x40) pos++;

+			if (flags & 0x20) pos++;

+			if (flags & 0x10) {

+				switch (data[pos]) {

+					case 0x29:

+						pos++;

+					case 0x33:

+						pos++;

+					default:

+						pos += 2;

+				}

+			}

+		}

+	}

+

+	if (!pattern->n_entries) return 0;

+

+	pattern->n_entries += nrows;

+	if (speed) pattern->n_entries++;

+	if (bpm >= 0x20) pattern->n_entries++;

+

+	for (pos = 0; pos < 32; pos++) {

+		if (!(pan[pos*2+1] & 0xF9)) pattern->n_entries++;

+		if (vol[pos] != -1) pattern->n_entries++;

+	}

+

+	pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry));

+	if (!pattern->entry) return -1;

+

+	entry = pattern->entry;

+

+	if (speed) {

+		entry->channel = 0;

+		entry->mask = IT_ENTRY_EFFECT;

+		entry->effect = IT_SET_SPEED;

+		entry->effectvalue = speed;

+		entry++;

+	}

+

+	if (bpm >= 0x20) {

+		entry->channel = 0;

+		entry->mask = IT_ENTRY_EFFECT;

+		entry->effect = IT_SET_SONG_TEMPO;

+		entry->effectvalue = bpm;

+		entry++;

+	}

+

+	for (pos = 0; pos < 32; pos++) {

+		if (!(pan[pos*2+1] & 0xF9)) {

+			entry->channel = pos;

+			entry->mask = IT_ENTRY_EFFECT;

+			switch (pan[pos*2+1]) {

+			case 0:

+				entry->effect = IT_SET_PANNING;

+				entry->effectvalue = pan[pos*2] ^ 128;

+				break;

+			case 2:

+				entry->effect = IT_S;

+				entry->effectvalue = EFFECT_VALUE(IT_S_SET_SURROUND_SOUND,1);

+				break;

+			case 4:

+				entry->effect = IT_SET_PANNING;

+				entry->effectvalue = 128;

+				break;

+			}

+			entry++;

+		}

+		if (vol[pos] != -1) {

+			entry->channel = pos;

+			entry->mask = IT_ENTRY_EFFECT;

+			entry->effect = IT_SET_CHANNEL_VOLUME;

+			entry->effectvalue = (vol[pos] + 2) >> 2;

+			entry++;

+		}

+	}

+

+	row = 0;

+	pos = 2;

+	rowlen = data[0] | (data[1] << 8);

+

+	while ((row < nrows) && (pos < len)) {

+		if (pos >= rowlen) {

+			IT_SET_END_ROW(entry);

+			entry++;

+			row++;

+			rowlen += data[pos] | (data[pos+1] << 8);

+			pos += 2;

+			continue;

+		}

+

+		flags = data[pos++];

+		entry->channel = data[pos++];

+		entry->mask = 0;

+

+		if (flags & 0xF0) {

+			if (flags & 0x80) {

+				entry->mask |= IT_ENTRY_NOTE;

+				if (version == PSMV_OLD) {

+					if ((data[pos] < 0x80)) entry->note = (data[pos]>>4)*12+(data[pos]&0x0f)+12;

+					else entry->mask &= ~IT_ENTRY_NOTE;

+				} else if (version == PSMV_NEW) {

+					if ((data[pos]) && (data[pos] < 84)) entry->note = data[pos] + 35;

+					else entry->mask &= ~IT_ENTRY_NOTE;

+				}

+				pos++;

+			}

+

+			if (flags & 0x40) {

+				entry->mask |= IT_ENTRY_INSTRUMENT;

+				entry->instrument = data[pos++] + 1;

+			}

+

+			if (flags & 0x20) {

+				entry->mask |= IT_ENTRY_VOLPAN;

+				entry->volpan = (data[pos++] + 1) >> 1;

+			}

+

+			if (flags & 0x10) {

+				entry->mask |= IT_ENTRY_EFFECT;

+				length = data[pos+1];

+				switch (data[pos]) {

+					case 1:

+						entry->effect = IT_VOLUME_SLIDE;

+						if (version == PSMV_OLD) entry->effectvalue = ((length&0x1e)<<3) | 0xF;

+						else if (version == PSMV_NEW) entry->effectvalue = (length<<4) | 0xF;

+						break;

+

+					case 2:

+						entry->effect = IT_VOLUME_SLIDE;

+						if (version == PSMV_OLD) entry->effectvalue = (length << 3) & 0xF0;

+						else if (version == PSMV_NEW) entry->effectvalue = (length << 4) & 0xF0;

+						break;

+

+					case 3:

+						entry->effect = IT_VOLUME_SLIDE;

+						if (version == PSMV_OLD) entry->effectvalue = (length >> 1) | 0xF0;

+						else if (version == PSMV_NEW) entry->effectvalue = length | 0xF0;

+						break;

+

+					case 4:

+						entry->effect = IT_VOLUME_SLIDE;

+						if (version == PSMV_OLD) entry->effectvalue = (length >> 1) & 0xF;

+						else if (version == PSMV_NEW) entry->effectvalue = length & 0xF;

+						break;

+

+					case 12:

+						entry->effect = IT_PORTAMENTO_UP;

+						if (version == PSMV_OLD) {

+							if (length < 4) entry->effectvalue = length | 0xF0;

+							else entry->effectvalue = length >> 2;

+						} else if (version == PSMV_NEW) {

+							entry->effectvalue = length;

+						}

+						break;

+

+					case 14:

+						entry->effect = IT_PORTAMENTO_DOWN;

+						if (version == PSMV_OLD) {

+							if (length < 4) entry->effectvalue = length | 0xF0;

+							else entry->effectvalue = length >> 2;

+						} else if (version == PSMV_NEW) {

+							entry->effectvalue = length;

+						}

+						break;

+

+					case 15:

+						entry->effect = IT_TONE_PORTAMENTO;

+						if (version == PSMV_OLD) entry->effectvalue = length >> 2;

+						else if (version == PSMV_NEW) entry->effectvalue = length;

+						break;

+

+					case 0x15:

+						entry->effect = IT_VIBRATO;

+						entry->effectvalue = length;

+						break;

+

+					case 0x18:

+						entry->effect = IT_VOLSLIDE_VIBRATO;

+						entry->effectvalue = length;

+						break;

+

+					case 0x29:

+						entry->effect = IT_SET_SAMPLE_OFFSET;

+						entry->effectvalue = data[pos+2];

+						pos += 2;

+						break;

+

+					case 0x2A:

+						entry->effect = IT_RETRIGGER_NOTE;

+						entry->effectvalue = length;

+						break;

+

+					case 0x33:

+#if 0

+						entry->effect = IT_POSITION_JUMP;

+						entry->effectvalue = data[pos+2];

+#else

+						entry->mask &= ~IT_ENTRY_EFFECT;

+#endif

+						pos++;

+						break;

+

+					case 0x34:

+						entry->effect = IT_BREAK_TO_ROW;

+						entry->effectvalue = length;

+						break;

+

+					case 0x3D:

+						entry->effect = IT_SET_SPEED;

+						entry->effectvalue = length;

+						break;

+

+					case 0x3E:

+						if (length >= 0x20) {

+							entry->effect = IT_SET_SONG_TEMPO;

+							entry->effectvalue = length;

+						} else {

+							entry->mask &= ~IT_ENTRY_EFFECT;

+						}

+						break;

+

+					case 0x47:

+						entry->effect = IT_ARPEGGIO;

+						entry->effectvalue = length;

+						break;

+

+					default:

+						return -1;

+				}

+				pos += 2;

+			}

+			if (entry->mask) entry++;

+		}

+	}

+

+	while (row < nrows) {

+		IT_SET_END_ROW(entry);

+		entry++;

+		row++;

+	}

+

+	pattern->n_entries = entry - pattern->entry;

+	if (!pattern->n_entries) return -1;

+

+	return 0;

+}

+

+

+static void free_chunks(PSMCHUNK * chunk, int count) {

+	int n;

+

+	for (n = 0; n < count; n++) {

+		if (chunk[n].data)

+			free(chunk[n].data);

+	}

+

+	free(chunk);

+}

+

+static void dumb_it_optimize_orders(DUMB_IT_SIGDATA * sigdata);

+

+static int pattcmp( const unsigned char *, const unsigned char *, size_t );

+

+static DUMB_IT_SIGDATA *it_psm_load_sigdata(DUMBFILE *f, int * ver, int subsong)

+{

+	DUMB_IT_SIGDATA *sigdata;

+

+	PSMCHUNK *chunk;

+	int n_chunks = 0;

+

+	PSMCHUNK *songchunk;

+	int n_song_chunks = 0;

+

+	PSMEVENT *event;

+	int n_events = 0;

+

+	unsigned char * ptr;

+

+	int n, length, o;

+

+	int found;

+

+	int n_patterns = 0;

+

+	int first_pattern_line = -1;

+	int first_pattern;

+

+	int speed, bpm;

+	unsigned char pan[64];

+	int vol[32];

+

+	if (dumbfile_mgetl(f) != DUMB_ID('P','S','M',' ')) goto error;

+

+	length = dumbfile_igetl(f);

+

+	if (dumbfile_mgetl(f) != DUMB_ID('F','I','L','E')) goto error;

+

+	chunk = calloc(768, sizeof(*chunk));

+

+	while (length >= 8) {

+		chunk[n_chunks].id = dumbfile_mgetl(f);

+		n = dumbfile_igetl(f);

+		length -= 8;

+		if (n < 0 || n > length)

+			goto error_fc;

+		chunk[n_chunks].len = n;

+		if (n) {

+			ptr = malloc(n);

+			if (!ptr) goto error_fc;

+			if (dumbfile_getnc(ptr, n, f) < n)

+			{

+				free(ptr);

+				goto error_fc;

+			}

+			chunk[n_chunks].data = ptr;

+		}

+		n_chunks++;

+		length -= n;

+	}

+

+	if (!n_chunks) goto error_fc;

+				

+	sigdata = malloc(sizeof(*sigdata));

+	if (!sigdata) goto error_fc;

+

+	sigdata->n_patterns = 0;

+	sigdata->n_samples = 0;

+	sigdata->name[0] = 0;

+

+	found = 0;

+

+	for (n = 0; n < n_chunks; n++) {

+		PSMCHUNK * c = &chunk[n];

+		switch(c->id) {

+		case DUMB_ID('S','D','F','T'):

+			/* song data format? */

+			if ((found & 1) || (c->len != 8) || memcmp(c->data, "MAINSONG", 8)) goto error_sd;

+			found |= 1;

+			break;

+

+		case DUMB_ID('S','O','N','G'):

+			if (/*(found & 2) ||*/ (c->len < 11) /*|| memcmp(c->data, "MAINSONG", 8)*/) goto error_sd;

+			found |= 2;

+			break;

+

+		case DUMB_ID('D','S','M','P'):

+			sigdata->n_samples++;

+			break;

+

+		case DUMB_ID('T','I','T','L'):

+			length = min(sizeof(sigdata->name) - 1, c->len);

+			memcpy(sigdata->name, c->data, length);

+			sigdata->name[length] = 0;

+		}

+	}

+

+	if (found != 3 || !sigdata->n_samples) goto error_sd;

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->sample = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->n_instruments = 0;

+	sigdata->n_orders = 0;

+

+	for (n = 0; n < n_chunks; n++) {

+		PSMCHUNK * c = &chunk[n];

+		if (c->id == DUMB_ID('S','O','N','G')) {

+			if (subsong == 0) break;

+			subsong--;

+		}

+	}

+

+	if (n == n_chunks) return NULL;

+	subsong = n;

+

+	/*for (n = 0; n < n_chunks; n++) {

+		PSMCHUNK * c = &chunk[n];

+		if (c->id == DUMB_ID('S','O','N','G')) {*/

+	{

+		PSMCHUNK * c = &chunk[subsong];

+		{

+			ptr = c->data;

+			if (ptr[10] > 32) goto error_usd;

+			sigdata->n_pchannels = ptr[10];

+			length = c->len - 11;

+			ptr += 11;

+			songchunk = 0;

+			if (length >= 8) {

+				songchunk = malloc(128 * sizeof(*songchunk));

+				if (!songchunk) goto error_usd;

+				while (length >= 8) {

+					songchunk[n_song_chunks].id = DUMB_ID(ptr[0], ptr[1], ptr[2], ptr[3]);

+					n = ptr[4] | (ptr[5] << 8) | (ptr[6] << 16) | (ptr[7] << 24);

+					length -= 8;

+					if (n > length) goto error_sc;

+					songchunk[n_song_chunks].len = n;

+					songchunk[n_song_chunks].data = ptr + 8;

+					n_song_chunks++;

+					length -= n;

+					ptr += 8 + n;

+				}

+			}

+			/*break;*/

+		}

+	}

+

+	if (!n_song_chunks) goto error_sc;

+

+	found = 0;

+

+	for (n = 0; n < n_song_chunks; n++) {

+		PSMCHUNK * c = &songchunk[n];

+

+		if (c->id == DUMB_ID('D','A','T','E')) {

+			/* date of the library build / format spec */

+			if (c->len == 6) {

+				length = c->len;

+				ptr = c->data;

+				while (length > 0) {

+					if (*ptr >= '0' && *ptr <= '9') {

+						found = (found * 10) + (*ptr - '0');

+					} else {

+						found = 0;

+						break;

+					}

+					ptr++;

+					length--;

+				}

+			}

+			break;

+		}

+	}

+

+	/*

+	if (found != 940506 &&

+		found != 940509 &&

+		found != 940510 &&

+		found != 940530 &&

+		found != 940629 &&

+		found != PSMV_OLD &&

+		found != 941011 &&

+		found != PSMV_NEW &&

+		found != 940906 &&

+		found != 940903 &&

+		found != 940914 &&

+		found != 941213 &&

+		found != 800211)   /* WTF?

+		goto error_sc;

+	*/

+

+	*ver = found;

+

+	if (found == 800211 ||

+		found == PSMV_NEW ||

+		found == 940903 ||

+		found == 940906 ||

+		found == 940914 ||

+		found == 941213) found = PSMV_NEW;

+	else found = PSMV_OLD;

+

+	memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);

+

+	for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) {

+		sigdata->channel_pan[n  ] = 16;

+		sigdata->channel_pan[n+1] = 48;

+		sigdata->channel_pan[n+2] = 48;

+		sigdata->channel_pan[n+3] = 16;

+	}

+

+	for (n = 0; n < n_song_chunks; n++) {

+		PSMCHUNK * c = &songchunk[n];

+

+		switch (c->id) {

+			case DUMB_ID('O','P','L','H'):

+				if (c->len < 2) goto error_sc;

+				ptr = c->data;

+				o = ptr[0] | (ptr[1] << 8);

+				if (!o) goto error_sc;

+				event = malloc(o * sizeof(*event));

+				if (!event) goto error_sc;

+				length = c->len - 2;

+				ptr += 2;

+				while ((length > 0) && (n_events < o)) {

+					event[n_events].type = *ptr;

+					switch (*ptr) {

+					case PSM_EVENT_END:

+						ptr++;

+						length--;

+						break;

+

+					case PSM_EVENT_PLAY_PATTERN:

+						if (found == PSMV_OLD) {

+							if (length < 5) goto error_ev;

+							memcpy(event[n_events].data, ptr + 1, 4);

+							ptr += 5;

+							length -= 5;

+						} else if (found == PSMV_NEW) {

+							if (length < 9) goto error_ev;

+							memcpy(event[n_events].data, ptr + 1, 8);

+							ptr += 9;

+							length -= 9;

+						}

+						break;

+

+					case PSM_EVENT_SET_SPEED:

+					case PSM_EVENT_SET_BPM:

+						if (length < 2) goto error_ev;

+						event[n_events].data[0] = ptr[1];

+						ptr += 2;

+						length -= 2;

+						break;

+

+					case PSM_EVENT_JUMP_TO_LINE:

+					case PSM_EVENT_CHANGE_VOL:

+						if (length < 3) goto error_ev;

+						memcpy(event[n_events].data, ptr + 1, 2);

+						ptr += 3;

+						length -= 3;

+						break;

+

+					case PSM_EVENT_SAMPLE_MAP_TABLE:

+						if (length < 7) goto error_ev;

+						memcpy(event[n_events].data, ptr + 1, 6);

+						ptr += 7;

+						length -= 7;

+						break;

+

+					case PSM_EVENT_CHANGE_PAN:

+						if (length < 4) goto error_ev;

+						memcpy(event[n_events].data, ptr + 1, 3);

+						ptr += 4;

+						length -= 4;

+						break;

+

+					default:

+						goto error_ev;

+					}

+					n_events++;

+				}

+				break;

+

+			case DUMB_ID('P','P','A','N'):

+				length = c->len;

+				if (length & 1) goto error_ev;

+				ptr = c->data;

+				o = 0;

+				while (length > 0) {

+					switch (ptr[0]) {

+					case 0:

+						sigdata->channel_pan[o] = ((((int)(signed char)ptr[1]) * 32) / 127) + 32;

+						break;

+					case 2:

+						sigdata->channel_pan[o] = IT_SURROUND;

+						break;

+					case 4:

+						sigdata->channel_pan[o] = 32;

+						break;

+					}

+					ptr += 2;

+					length -= 2;

+					if (++o >= DUMB_IT_N_CHANNELS) break;

+				}

+				break;

+

+			/*

+			case DUMB_ID('P','A','T','T'):

+			case DUMB_ID('D','S','A','M'):

+			*/

+		}

+	}

+

+	sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX;

+

+	sigdata->global_volume = 128;

+	sigdata->speed = 6;

+	sigdata->tempo = 125;

+	sigdata->mixing_volume = 48;

+	sigdata->pan_separation = 128;

+

+	speed = 0;

+	bpm = 0;

+	memset(pan, 255, sizeof(pan));

+	memset(vol, 255, sizeof(vol));

+

+	sigdata->n_patterns = n_events;

+	sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));

+	if (!sigdata->pattern) goto error_ev;

+	for (n = 0; n < sigdata->n_patterns; n++)

+		sigdata->pattern[n].entry = NULL;

+

+	for (n = 0; n < n_events; n++) {

+		PSMEVENT * e = &event[n];

+		switch (e->type) {

+		case PSM_EVENT_END:

+			n = n_events;

+			break;

+

+		case PSM_EVENT_PLAY_PATTERN:

+			for (o = 0; o < n_chunks; o++) {

+				PSMCHUNK * c = &chunk[o];

+				if (c->id == DUMB_ID('P','B','O','D')) {

+					ptr = c->data;

+					length = c->len;

+					if (found == PSMV_OLD) {

+						if (length < 8) goto error_ev;

+						if (!pattcmp(ptr + 4, e->data, 4)) {

+							if (it_psm_process_pattern(&sigdata->pattern[n_patterns], ptr, length, speed, bpm, pan, vol, found)) goto error_ev;

+							if (first_pattern_line < 0) {

+								first_pattern_line = n;

+								first_pattern = o;

+							}

+							e->data[0] = n_patterns;

+							e->data[1] = n_patterns >> 8;

+							n_patterns++;

+							break;

+						}

+					} else if (found == PSMV_NEW) {

+						if (length < 12) goto error_ev;

+						if (!pattcmp(ptr + 4, e->data, 8)) {

+							if (it_psm_process_pattern(&sigdata->pattern[n_patterns], ptr, length, speed, bpm, pan, vol, found)) goto error_ev;

+							if (first_pattern_line < 0) {

+								first_pattern_line = n;

+								first_pattern = o;

+							}

+							e->data[0] = n_patterns;

+							e->data[1] = n_patterns >> 8;

+							n_patterns++;

+							break;

+						}

+					}

+				}

+			}

+			if (o == n_chunks) goto error_ev;

+

+			speed = 0;

+			bpm = 0;

+			memset(pan, 255, sizeof(pan));

+			memset(vol, 255, sizeof(vol));

+

+			e->type = PSM_EVENT_END;

+			break;

+

+		case PSM_EVENT_JUMP_TO_LINE:

+			o = e->data[0] | (e->data[1] << 8);

+			if (o >= n_events) goto error_ev;

+			if (o == 0) {

+				/* whew! easy case! */

+				sigdata->restart_position = 0;

+				n = n_events;

+			} else if (o == n) {

+				/* freeze */

+				n = n_events;

+			} else if (o > n) {

+				/* jump ahead, setting played event numbers to zero will prevent endless looping */

+				n = o - 1;

+			} else if (o >= first_pattern_line) {

+				/* another semi-easy case */

+				sigdata->restart_position = event[o].data[0] | (event[o].data[1] << 8);

+				n = n_events;

+			} else {

+				/* crud, try to simulate rerunning all of the commands from the indicated

+				 * line up to the first pattern, then dupe the first pattern again.

+				 */

+				/*

+				PSMCHUNK * c = &chunk[first_pattern];

+

+				for (; o < first_pattern_line; o++) {

+					PSMEVENT * ev = &event[o];

+					switch (ev->type) {

+					case PSM_EVENT_SET_SPEED:

+						speed = ev->data[0];

+						break;

+					case PSM_EVENT_SET_BPM:

+						bpm = ev->data[0];

+						break;

+					case PSM_EVENT_CHANGE_PAN:

+						if (ev->data[0] > 31) goto error_ev;

+						pan[ev->data[0] * 2] = ev->data[1];

+						pan[ev->data[0] * 2 + 1] = ev->data[2];

+						break;

+					case PSM_EVENT_CHANGE_VOL:

+						if (ev->data[0] > 31) goto error_ev;

+						vol[ev->data[0]] = ev->data[1];

+						break;

+					}

+				}

+

+				if (it_psm_process_pattern(&sigdata->pattern[n_patterns], c->data, c->len, speed, bpm, pan, vol, found)) goto error_ev;

+				n_patterns++;

+				sigdata->restart_position = 1;

+				n = n_events;

+

+				Eh, what the hell? PSM has no panning commands anyway.

+				*/

+				sigdata->restart_position = 0;

+				n = n_events;

+			}

+			e->type = PSM_EVENT_END;

+			break;

+

+		case PSM_EVENT_SET_SPEED:

+			speed = e->data[0];

+			break;

+

+		case PSM_EVENT_SET_BPM:

+			bpm = e->data[0];

+			break;

+

+		case PSM_EVENT_CHANGE_PAN:

+			o = e->data[0];

+			if (o > 31) goto error_ev;

+			pan[o * 2] = e->data[1];

+			pan[o * 2 + 1] = e->data[2];

+			break;

+

+		case PSM_EVENT_CHANGE_VOL:

+			o = e->data[0];

+			if (o > 31) goto error_ev;

+			vol[o] = e->data[1];

+			break;

+

+		case PSM_EVENT_SAMPLE_MAP_TABLE:

+			if (e->data[0] != 0 || e->data[1] != 0xFF ||

+				e->data[2] != 0 || e->data[3] != 0 ||

+				e->data[4] != 1 || e->data[5] != 0)

+				goto error_ev;

+			break;

+		}

+	}

+

+	if (n_patterns > 256) goto error_ev;

+

+	sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));

+	if (!sigdata->sample) goto error_ev;

+	for (n = 0; n < sigdata->n_samples; n++)

+		sigdata->sample[n].data = NULL;

+

+	o = 0;

+	for (n = 0; n < n_chunks; n++) {

+		PSMCHUNK * c = &chunk[n];

+		if (c->id == DUMB_ID('D','S','M','P')) {

+			if (it_psm_process_sample(&sigdata->sample[o], c->data, c->len, o, found)) goto error_ev;

+			o++;

+		}

+	}

+

+	sigdata->n_orders = n_patterns;

+	sigdata->n_patterns = n_patterns;

+

+	sigdata->order = malloc(n_patterns);

+

+	for (n = 0; n < n_patterns; n++) {

+		sigdata->order[n] = n;

+	}

+

+	free(event);

+	free(songchunk);

+	free_chunks(chunk, n_chunks);

+

+	_dumb_it_fix_invalid_orders(sigdata);

+

+	dumb_it_optimize_orders(sigdata);

+

+	return sigdata;

+

+error_ev:

+	free(event);

+error_sc:

+	if (songchunk) free(songchunk);

+error_usd:

+	_dumb_it_unload_sigdata(sigdata);

+	goto error_fc;

+error_sd:

+	free(sigdata);

+error_fc:

+	free_chunks(chunk, n_chunks);

+error:

+	return NULL;

+}

+

+static int it_order_compare(const void *e1, const void *e2) {

+	if (*((const char *)e1) < *((const char *)e2))

+		return -1;

+

+	if (*((const char *)e1) > *((const char *)e2))

+		return 1;

+

+	return 0;

+}

+

+static int it_optimize_compare(const void *e1, const void *e2) {

+	if (((const IT_ENTRY *)e1)->channel < ((const IT_ENTRY *)e2)->channel)

+		return -1;

+

+	if (((const IT_ENTRY *)e1)->channel > ((const IT_ENTRY *)e2)->channel)

+		return 1;

+

+	return 0;

+}

+

+static int it_entry_compare(const IT_ENTRY * e1, const IT_ENTRY * e2) {

+	if (IT_IS_END_ROW(e1) && IT_IS_END_ROW(e2)) return 1;

+	if (e1->channel != e2->channel) return 0;

+	if (e1->mask != e2->mask) return 0;

+	if ((e1->mask & IT_ENTRY_NOTE) && (e1->note != e2->note)) return 0;

+	if ((e1->mask & IT_ENTRY_INSTRUMENT) && (e1->instrument != e2->instrument)) return 0;

+	if ((e1->mask & IT_ENTRY_VOLPAN) && (e1->volpan != e2->volpan)) return 0;

+	if ((e1->mask & IT_ENTRY_EFFECT) && ((e1->effect != e2->effect) || (e1->effectvalue != e2->effectvalue))) return 0;

+	return 1;

+}

+

+/*

+static void dumb_it_optimize_pattern(IT_PATTERN * pattern) {

+	IT_ENTRY * entry, * end;

+	IT_ENTRY * rowstart, * rowend;

+	IT_ENTRY * current;

+

+	if (!pattern->n_entries || !pattern->entry) return;

+

+	current = entry = pattern->entry;

+	end = entry + pattern->n_entries;

+

+	while (entry < end) {

+		rowstart = entry;

+		while (!IT_IS_END_ROW(entry)) entry++;

+		rowend = entry;

+		if (rowend > rowstart + 1)

+			qsort(rowstart, rowend - rowstart, sizeof(IT_ENTRY), &it_optimize_compare);

+		entry = rowstart;

+		while (entry < rowend) {

+			if (!(entry->mask)) {}

+			else if (it_entry_compare(entry, current)) {}

+			else if (!(current->mask) ||

+					 ((entry->channel == current->channel) &&

+					 ((entry->mask | current->mask) == (entry->mask ^ current->mask)))) {

+				current->mask |= entry->mask;

+				if (entry->mask & IT_ENTRY_NOTE) current->note = entry->note;

+				if (entry->mask & IT_ENTRY_INSTRUMENT) current->instrument = entry->instrument;

+				if (entry->mask & IT_ENTRY_VOLPAN) current->volpan = entry->volpan;

+				if (entry->mask & IT_ENTRY_EFFECT) {

+					current->effect = entry->effect;

+					current->effectvalue = entry->effectvalue;

+				}

+			} else {

+				if (++current < entry) *current = *entry;

+			}

+			entry++;

+		}

+		if (++current < entry) *current = *entry;

+		entry++;

+	}

+

+	current++;

+

+	if (current < end) {

+		IT_ENTRY * opt;

+		pattern->n_entries = current - pattern->entry;

+		opt = realloc(pattern->entry, pattern->n_entries * sizeof(*pattern->entry));

+		if (opt) pattern->entry = opt;

+	}

+}

+*/

+

+static int it_pattern_compare(const IT_PATTERN * p1, const IT_PATTERN * p2) {

+	IT_ENTRY * e1, * end;

+	IT_ENTRY * e2;

+

+	if (p1 == p2) return 1;

+	if (p1->n_entries != p2->n_entries) return 0;

+	

+	e1 = p1->entry; end = e1 + p1->n_entries;

+	e2 = p2->entry;

+

+	while (e1 < end) {

+		if (!it_entry_compare(e1, e2)) return 0;

+		e1++; e2++;

+	}

+

+	return 1;

+}

+

+static void dumb_it_optimize_orders(DUMB_IT_SIGDATA * sigdata) {

+	int n, o, p;

+

+	int last_invalid = (sigdata->flags & IT_WAS_AN_XM) ? 255 : 253;

+

+	unsigned char * order_list;

+	int n_patterns;

+

+	IT_PATTERN * pattern;

+

+	if (!sigdata->n_orders || !sigdata->n_patterns) return;

+

+	n_patterns = 0;

+	order_list = malloc(sigdata->n_orders);

+

+	if (!order_list) return;

+

+	for (n = 0; n < sigdata->n_orders; n++) {

+		if (sigdata->order[n] < sigdata->n_patterns) {

+			for (o = 0; o < n_patterns; o++) {

+				if (sigdata->order[n] == order_list[o]) break;

+			}

+			if (o == n_patterns) {

+				order_list[n_patterns++] = sigdata->order[n];

+			}

+		}

+	}

+

+	if (!n_patterns) {

+		free(order_list);

+		return;

+	}

+

+	/*for (n = 0; n < n_patterns; n++) {

+		dumb_it_optimize_pattern(&sigdata->pattern[order_list[n]]);

+	}*/

+

+	for (n = 0; n < n_patterns; n++) {

+		for (o = n + 1; o < n_patterns; o++) {

+			if ((order_list[n] != order_list[o]) &&

+				it_pattern_compare(&sigdata->pattern[order_list[n]], &sigdata->pattern[order_list[o]])) {

+				for (p = 0; p < sigdata->n_orders; p++) {

+					if (sigdata->order[p] == order_list[o]) {

+						sigdata->order[p] = order_list[n];

+					}

+				}

+				for (p = o + 1; p < n_patterns; p++) {

+					if (order_list[p] == order_list[o]) {

+						order_list[p] = order_list[n];

+					}

+				}

+				order_list[o] = order_list[n];

+			}

+		}

+	}

+

+	qsort(order_list, n_patterns, sizeof(*order_list), &it_order_compare);

+

+	for (n = 0, o = 0; n < n_patterns; n++) {

+		if (order_list[n] != order_list[o]) {

+			if (++o < n) order_list[o] = order_list[n];

+		}

+	}

+

+	n_patterns = o + 1;

+

+	pattern = malloc(n_patterns * sizeof(*pattern));

+	if (!pattern) {

+		free(order_list);

+		return;

+	}

+

+	for (n = 0; n < n_patterns; n++) {

+		pattern[n] = sigdata->pattern[order_list[n]];

+	}

+

+	for (n = 0; n < sigdata->n_patterns; n++) {

+		for (o = 0; o < n_patterns; o++) {

+			if (order_list[o] == n) break;

+		}

+		if (o == n_patterns) {

+			if (sigdata->pattern[n].entry)

+				free(sigdata->pattern[n].entry);

+		}

+	}

+

+	free(sigdata->pattern);

+	sigdata->pattern = pattern;

+	sigdata->n_patterns = n_patterns;

+

+	for (n = 0; n < sigdata->n_orders; n++) {

+		for (o = 0; o < n_patterns; o++) {

+			if (sigdata->order[n] == order_list[o]) {

+				sigdata->order[n] = o;

+				break;

+			}

+		}

+	}

+

+	free(order_list);

+}

+

+int dumb_get_psm_subsong_count(DUMBFILE *f) {

+	int length, subsongs;

+	long l;

+	

+	if (dumbfile_mgetl(f) != DUMB_ID('P','S','M',' ')) return 0;

+

+	length = dumbfile_igetl(f);

+

+	if (dumbfile_mgetl(f) != DUMB_ID('F','I','L','E')) return 0;

+

+	subsongs = 0;

+

+	while (length >= 8 && !dumbfile_error(f)) {

+		if (dumbfile_mgetl(f) == DUMB_ID('S','O','N','G')) subsongs++;

+		l = dumbfile_igetl(f);

+		dumbfile_skip(f, l);

+		length -= l + 8;

+	}

+

+	if (dumbfile_error(f)) return 0;

+

+	return subsongs;

+}

+

+

+

+/* Eww */

+int pattcmp( const unsigned char * a, const unsigned char * b, size_t l )

+{

+	int i, j, na, nb;

+	char * p;

+

+	i = memcmp( a, b, l );

+	if ( !i ) return i;

+

+	/* damnit */

+

+	for ( i = 0; i < l; ++i )

+	{

+		if ( a [i] >= '0' && a [i] <= '9' ) break;

+	}

+

+	if ( i < l )

+	{

+		na = strtoul( a + i, &p, 10 );

+		if ( (const unsigned char *)p == a + i ) return 1;

+	}

+

+	for ( j = 0; j < l; ++j )

+	{

+		if ( b [j] >= '0' && b [j] <= '9' ) break;

+	}

+

+	if ( j < l )

+	{

+		nb = strtoul( b + j, &p, 10 );

+		if ( (const unsigned char *)p == b + j ) return -1;

+	}

+

+	if ( i < j ) return -1;

+	else if ( j > i ) return 1;

+

+	i = memcmp( a, b, j );

+	if ( i ) return i;

+

+	return na - nb;

+}

+

+

+

+DUH *dumb_read_psm_quick(DUMBFILE *f, int subsong)

+{

+	sigdata_t *sigdata;

+	int ver;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_psm_load_sigdata(f, &ver, subsong);

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		int n_tags = 2;

+		char version[16];

+		const char *tag[3][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		tag[1][1] = "PSM";

+		if ( ver )

+		{

+			tag[2][0] = "FORMATVERSION";

+			snprintf (version, 10, "%d", ver);

+			tag[2][1] = (const char *) &version;

+			++n_tags;

+		}

+		return make_duh(-1, n_tags, (const char *const (*)[2])tag, 1, &descptr, &sigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readptm.c b/plugins/dumb/dumb-kode54/src/it/readptm.c
new file mode 100644
index 00000000..d8c77297
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readptm.c
@@ -0,0 +1,574 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readptm.c - Code to read a Poly Tracker v2.03      / / \  \

+ *             module from an open file.             | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Chris Moeller. Based on reads3m.c               \_  /  > /

+ * by entheh.                                           | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+// IT_STEREO... :o

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/** WARNING: this is duplicated in itread.c */

+static int it_seek(DUMBFILE *f, long offset)

+{

+	long pos = dumbfile_pos(f);

+

+	if (pos > offset)

+		return -1;

+

+	if (pos < offset)

+		if (dumbfile_skip(f, offset - pos))

+			return -1;

+

+	return 0;

+}

+

+

+

+static int it_ptm_read_sample_header(IT_SAMPLE *sample, long *offset, DUMBFILE *f)

+{

+	int flags;

+

+	flags = dumbfile_getc(f);

+

+	dumbfile_getnc(sample->filename, 12, f);

+	sample->filename[12] = 0;

+

+	sample->default_volume = dumbfile_getc(f);

+

+	sample->C5_speed = dumbfile_igetw(f) << 1;

+

+	dumbfile_skip(f, 2); /* segment */

+

+	*offset = dumbfile_igetl(f);

+

+	sample->length = dumbfile_igetl(f);

+	sample->loop_start = dumbfile_igetl(f);

+	sample->loop_end = dumbfile_igetl(f);

+

+	/* GUSBegin, GUSLStart, GUSLEnd, GUSLoop, reserverd */

+	dumbfile_skip(f, 4+4+4+1+1);

+

+	dumbfile_getnc(sample->name, 28, f);

+	sample->name[28] = 0;

+

+	/*

+	if (dumbfile_mgetl(f) != DUMB_ID('P','T','M','S'))

+		return -1;

+	*/

+

+	/* BLAH! Shit likes to have broken or missing sample IDs */

+	dumbfile_skip(f, 4);

+

+	if ((flags & 3) == 0) {

+		/* Looks like no sample */

+		sample->flags &= ~IT_SAMPLE_EXISTS;

+		return dumbfile_error(f);

+	}

+

+	sample->global_volume = 64;

+

+	sample->flags = IT_SAMPLE_EXISTS;

+	if (flags & 4) sample->flags |= IT_SAMPLE_LOOP;

+	if (flags & 8) sample->flags |= IT_SAMPLE_PINGPONG_LOOP;

+

+	if (flags & 16) {

+		sample->flags |= IT_SAMPLE_16BIT;

+

+		sample->length >>= 1;

+		sample->loop_start >>= 1;

+		sample->loop_end >>= 1;

+	}

+

+	if (sample->loop_end) sample->loop_end--;

+

+	sample->default_pan = 0; // 0 = don't use, or 160 = centre?

+

+	if (sample->length <= 0)

+		sample->flags &= ~IT_SAMPLE_EXISTS;

+	else if (sample->flags & IT_SAMPLE_LOOP) {

+		if ((unsigned int)sample->loop_end > (unsigned int)sample->length)

+			sample->flags &= ~IT_SAMPLE_LOOP;

+		else if ((unsigned int)sample->loop_start >= (unsigned int)sample->loop_end)

+			sample->flags &= ~IT_SAMPLE_LOOP;

+		else

+			sample->length = sample->loop_end;

+	}

+

+

+	//Do we need to set all these?

+	sample->vibrato_speed = 0;

+	sample->vibrato_depth = 0;

+	sample->vibrato_rate = 0;

+	sample->vibrato_waveform = IT_VIBRATO_SINE;

+	sample->finetune = 0;

+	sample->max_resampling_quality = -1;

+

+	return dumbfile_error(f);

+}

+

+

+static int it_ptm_read_byte(DUMBFILE *f)

+{

+	int meh = dumbfile_getc(f);

+	if (meh < 0) return 0;

+	return meh;

+}

+

+static int it_ptm_read_sample_data(IT_SAMPLE *sample, int last, DUMBFILE *f)

+{

+	long n;

+	int s;

+

+	sample->data = malloc(sample->length * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1));

+	if (!sample->data)

+		return -1;

+

+	s = 0;

+

+	if (sample->flags & IT_SAMPLE_16BIT) {

+		unsigned char a, b;

+		for (n = 0; n < sample->length; n++) {

+			a = s += (signed char) it_ptm_read_byte(f);

+			b = s += (signed char) it_ptm_read_byte(f);

+			((short *)sample->data)[n] = a | (b << 8);

+		}

+	} else {

+		for (n = 0; n < sample->length; n++) {

+			s += (signed char) it_ptm_read_byte(f);

+			((signed char *)sample->data)[n] = s;

+		}

+	}

+

+	if (dumbfile_error(f) && !last)

+		return -1;

+

+	return 0;

+}

+

+

+

+static int it_ptm_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer, int length)

+{

+	int buflen = 0;

+	int bufpos = 0;

+	int effect, effectvalue;

+

+	IT_ENTRY *entry;

+

+	unsigned char channel;

+

+	if (!length)

+		return -1;

+

+	pattern->n_rows = 0;

+	pattern->n_entries = 0;

+

+	/* Read in the pattern data, little by little, and work out how many

+	 * entries we need room for. Sorry, but this is just so funny...

+	 */

+	for (;;) {

+		unsigned char b = buffer[buflen++] = dumbfile_getc(f);

+

+#if 1

+		static const unsigned char used[8] = {0, 2, 2, 4, 1, 3, 3, 5};

+		channel = b & 31;

+		b >>= 5;

+		pattern->n_entries++;

+		if (b) {

+			if (buflen + used[b] >= 65536) return -1;

+			dumbfile_getnc(buffer + buflen, used[b], f);

+			buflen += used[b];

+		} else {

+			/* End of row */

+			if (++pattern->n_rows == 64) break;

+			if (buflen >= 65536) return -1;

+		}

+#else

+		if (b == 0) {

+			/* End of row */

+			pattern->n_entries++;

+			if (++pattern->n_rows == 64) break;

+			if (buflen >= 65536) return -1;

+		} else {

+			static const unsigned char used[8] = {0, 2, 2, 4, 1, 3, 3, 5};

+			channel = b & 31;

+			b >>= 5;

+			if (b) {

+				pattern->n_entries++;

+				if (buflen + used[b] >= 65536) return -1;

+				dumbfile_getnc(buffer + buflen, used[b], f);

+				buflen += used[b];

+			}

+		}

+#endif

+

+		/* We have ensured that buflen < 65536 at this point, so it is safe

+		 * to iterate and read at least one more byte without checking.

+		 * However, now would be a good time to check for errors reading from

+		 * the file.

+		 */

+

+		if (dumbfile_error(f))

+			return -1;

+

+		/* Great. We ran out of data, but there should be data for more rows.

+		 * Fill the rest with null data...

+		 */

+		if (buflen >= length && pattern->n_rows < 64)

+		{

+			while (pattern->n_rows < 64)

+			{

+				if (buflen >= 65536) return -1;

+				buffer[buflen++] = 0;

+				pattern->n_entries++;

+				pattern->n_rows++;

+			}

+			break;

+		}

+	}

+

+	pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry));

+

+	if (!pattern->entry)

+		return -1;

+

+	entry = pattern->entry;

+

+	while (bufpos < buflen) {

+		unsigned char b = buffer[bufpos++];

+

+		if (b == 0)

+		{

+			/* End of row */

+			IT_SET_END_ROW(entry);

+			entry++;

+			continue;

+		}

+

+		channel = b & 31;

+

+		if (b & 224) {

+			entry->mask = 0;

+			entry->channel = channel;

+

+			if (b & 32) {

+				unsigned char n = buffer[bufpos++];

+				if (n == 254 || (n >= 1 && n <= 120)) {

+					if (n == 254)

+						entry->note = IT_NOTE_CUT;

+					else

+						entry->note = n - 1;

+					entry->mask |= IT_ENTRY_NOTE;

+				}

+

+				entry->instrument = buffer[bufpos++];

+				if (entry->instrument)

+					entry->mask |= IT_ENTRY_INSTRUMENT;

+			}

+

+			if (b & 64) {

+				effect = buffer[bufpos++];

+				effectvalue = buffer[bufpos++];

+				_dumb_it_ptm_convert_effect(effect, effectvalue, entry);

+			}

+

+			if (b & 128) {

+				entry->volpan = buffer[bufpos++];

+				if (entry->volpan <= 64)

+					entry->mask |= IT_ENTRY_VOLPAN;

+			}

+

+			entry++;

+		}

+	}

+

+	ASSERT(entry == pattern->entry + pattern->n_entries);

+

+	return 0;

+}

+

+

+

+/** WARNING: this is duplicated in itread.c - also bad practice to use the same struct name unless they are unified in a header */

+/* Currently we assume the sample data are stored after the sample headers in

+ * module files. This assumption may be unjustified; let me know if you have

+ * trouble.

+ */

+

+#define PTM_COMPONENT_INSTRUMENT 1

+#define PTM_COMPONENT_PATTERN    2

+#define PTM_COMPONENT_SAMPLE     3

+

+typedef struct PTM_COMPONENT

+{

+	unsigned char type;

+	unsigned char n;

+	long offset;

+}

+PTM_COMPONENT;

+

+

+

+static int ptm_component_compare(const void *e1, const void *e2)

+{

+	return ((const PTM_COMPONENT *)e1)->offset -

+	       ((const PTM_COMPONENT *)e2)->offset;

+}

+

+

+

+static DUMB_IT_SIGDATA *it_ptm_load_sigdata(DUMBFILE *f)

+{

+	DUMB_IT_SIGDATA *sigdata;

+

+	PTM_COMPONENT *component;

+	int n_components = 0;

+

+	int n;

+

+	unsigned char *buffer;

+

+	sigdata = malloc(sizeof(*sigdata));

+	if (!sigdata) return NULL;

+

+	/* Skip song name. */

+	dumbfile_getnc(sigdata->name, 28, f);

+	sigdata->name[28] = 0;

+

+	if (dumbfile_getc(f) != 0x1A || dumbfile_igetw(f) != 0x203) {

+		free(sigdata);

+		return NULL;

+	}

+

+	dumbfile_skip(f, 1);

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->sample = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->n_orders = dumbfile_igetw(f);

+	sigdata->n_instruments = 0;

+	sigdata->n_samples = dumbfile_igetw(f);

+	sigdata->n_patterns = dumbfile_igetw(f);

+

+	if (dumbfile_error(f) || sigdata->n_orders <= 0 || sigdata->n_samples > 255 || sigdata->n_patterns > 128) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	sigdata->n_pchannels = dumbfile_igetw(f);

+

+	if (dumbfile_igetw(f) != 0) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	dumbfile_skip(f, 2);

+

+	if (dumbfile_mgetl(f) != DUMB_ID('P','T','M','F')) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	dumbfile_skip(f, 16);

+

+	sigdata->order = malloc(sigdata->n_orders);

+	if (!sigdata->order) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	if (sigdata->n_samples) {

+		sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));

+		if (!sigdata->sample) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		for (n = 0; n < sigdata->n_samples; n++)

+			sigdata->sample[n].data = NULL;

+	}

+

+	if (sigdata->n_patterns) {

+		sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));

+		if (!sigdata->pattern) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		for (n = 0; n < sigdata->n_patterns; n++)

+			sigdata->pattern[n].entry = NULL;

+	}

+

+	/** WARNING: which ones? */

+	sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_A_PTM;

+

+	sigdata->global_volume = 128;

+	sigdata->speed = 6;

+	sigdata->tempo = 125;

+	sigdata->mixing_volume = 48;

+

+	/* Panning positions for 32 channels */

+	{

+		int i;

+		for (i = 0; i < 32; i++) {

+			int c = dumbfile_getc(f);

+			if (c <= 15) {

+				sigdata->channel_volume[i] = 64;

+				sigdata->channel_pan[i] = c;

+			} else {

+				/** WARNING: this could be improved if we support channel muting... */

+				sigdata->channel_volume[i] = 0;

+				sigdata->channel_pan[i] = 7;

+			}

+		}

+	}

+

+	/* Orders, byte each, length = sigdata->n_orders (should be even) */

+	dumbfile_getnc(sigdata->order, sigdata->n_orders, f);

+	sigdata->restart_position = 0;

+

+	component = malloc(768*sizeof(*component));

+	if (!component) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	if (it_seek(f, 352)) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	for (n = 0; n < sigdata->n_patterns; n++) {

+		component[n_components].type = PTM_COMPONENT_PATTERN;

+		component[n_components].n = n;

+		component[n_components].offset = dumbfile_igetw(f) << 4;

+		n_components++;

+	}

+

+	if (it_seek(f, 608)) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	for (n = 0; n < sigdata->n_samples; n++) {

+		if (it_ptm_read_sample_header(&sigdata->sample[n], &component[n_components].offset, f)) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		if (!(sigdata->sample[n].flags & IT_SAMPLE_EXISTS)) continue;

+		component[n_components].type = PTM_COMPONENT_SAMPLE;

+		component[n_components].n = n;

+		n_components++;

+	}

+

+	qsort(component, n_components, sizeof(PTM_COMPONENT), &ptm_component_compare);

+

+	{

+		int i;

+		for (i = 0; i < 32; i++) {

+			sigdata->channel_pan[i] -= (sigdata->channel_pan[i] & 8) >> 3;

+			sigdata->channel_pan[i] = ((int)sigdata->channel_pan[i] << 5) / 7;

+			if (sigdata->channel_pan[i] > 64) sigdata->channel_pan[i] = 64;

+		}

+	}

+

+	sigdata->pan_separation = 128;

+

+	if (dumbfile_error(f)) {

+		free(component);

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	buffer = malloc(65536);

+	if (!buffer) {

+		free(component);

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	for (n = 0; n < n_components; n++) {

+		if (it_seek(f, component[n].offset)) {

+			free(buffer);

+			free(component);

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+

+		switch (component[n].type) {

+

+			case PTM_COMPONENT_PATTERN:

+				if (it_ptm_read_pattern(&sigdata->pattern[component[n].n], f, buffer, (n + 1 < n_components) ? (component[n+1].offset - component[n].offset) : 0)) {

+					free(buffer);

+					free(component);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+				break;

+

+			case PTM_COMPONENT_SAMPLE:

+				if (it_ptm_read_sample_data(&sigdata->sample[component[n].n], (n + 1 == n_components), f)) {

+					free(buffer);

+					free(component);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+		}

+	}

+

+	free(buffer);

+	free(component);

+

+	_dumb_it_fix_invalid_orders(sigdata);

+

+	return sigdata;

+}

+

+static char hexdigit(int in)

+{

+	if (in < 10) return in + '0';

+	else return in + 'A' - 10;

+}

+

+DUH *dumb_read_ptm_quick(DUMBFILE *f)

+{

+	sigdata_t *sigdata;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_ptm_load_sigdata(f);

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		const char *tag[2][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		tag[1][1] = "PTM";

+		return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readriff.c b/plugins/dumb/dumb-kode54/src/it/readriff.c
new file mode 100644
index 00000000..615e555c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readriff.c
@@ -0,0 +1,73 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readriff.c - Code to read a RIFF module file       / / \  \

+ *              from memory.                         | <  /   \_

+ *                                                   |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+#include "internal/it.h"

+#include "internal/riff.h"

+

+

+DUH *dumb_read_riff_amff( struct riff * stream );

+DUH *dumb_read_riff_am( struct riff * stream );

+DUH *dumb_read_riff_dsmf( struct riff * stream );

+

+/* dumb_read_riff_quick(): reads a RIFF file into a DUH struct, returning a

+ * pointer to the DUH struct. When you have finished with it, you must pass

+ * the pointer to unload_duh() so that the memory can be freed.

+ */

+DUH *dumb_read_riff_quick( DUMBFILE * f )

+{

+	DUH * duh;

+	struct riff * stream;

+

+	{

+		unsigned char * buffer = 0;

+		unsigned size = 0;

+		unsigned read;

+		do

+		{

+			buffer = realloc( buffer, 32768 + size );

+			if ( ! buffer ) return 0;

+			read = dumbfile_getnc( buffer + size, 32768, f );

+			if ( read < 0 )

+			{

+				free( buffer );

+				return 0;

+			}

+			size += read;

+		}

+		while ( read == 32768 );

+		stream = riff_parse( buffer, size, 1 );

+		if ( ! stream ) stream = riff_parse( buffer, size, 0 );

+		free( buffer );

+	}

+

+	if ( ! stream ) return 0;

+

+	if ( stream->type == DUMB_ID( 'A', 'M', ' ', ' ' ) )

+		duh = dumb_read_riff_am( stream );

+	else if ( stream->type == DUMB_ID( 'A', 'M', 'F', 'F' ) )

+		duh = dumb_read_riff_amff( stream );

+	else if ( stream->type == DUMB_ID( 'D', 'S', 'M', 'F' ) )

+		duh = dumb_read_riff_dsmf( stream );

+	else duh = 0;

+

+	riff_free( stream );

+

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/reads3m.c b/plugins/dumb/dumb-kode54/src/it/reads3m.c
new file mode 100644
index 00000000..0dac8331
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/reads3m.c
@@ -0,0 +1,864 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * reads3m.c - Code to read a ScreamTracker 3         / / \  \

+ *             module from an open file.             | <  /   \_

+ *                                                   |  \/ /\   /

+ * By entheh.                                         \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+// IT_STEREO... :o

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+//#define S3M_BROKEN_OVERLAPPED_SAMPLES

+

+/** WARNING: this is duplicated in itread.c */

+static int it_seek(DUMBFILE *f, long offset)

+{

+	long pos = dumbfile_pos(f);

+

+	if (pos > offset) {

+		return -1;

+	}

+

+	if (pos < offset)

+		if (dumbfile_skip(f, offset - pos))

+			return -1;

+

+	return 0;

+}

+

+

+

+static int it_s3m_read_sample_header(IT_SAMPLE *sample, long *offset, unsigned char *pack, int cwtv, DUMBFILE *f)

+{

+	unsigned char type;

+	int flags;

+

+	type = dumbfile_getc(f);

+

+	dumbfile_getnc(sample->filename, 12, f);

+	sample->filename[12] = 0;

+

+	if (type > 1) {

+		/** WARNING: no adlib support */

+		dumbfile_skip(f, 3 + 12 + 1 + 1 + 2 + 2 + 2 + 12);

+		dumbfile_getnc(sample->name, 28, f);

+		sample->name[28] = 0;

+		dumbfile_skip(f, 4);

+		sample->flags &= ~IT_SAMPLE_EXISTS;

+		return -1; // return error so that another plugin could pick that file up

+	}

+

+	*offset = dumbfile_getc(f) << 20;

+	*offset += dumbfile_igetw(f) << 4;

+

+	sample->length = dumbfile_igetl(f);

+	sample->loop_start = dumbfile_igetl(f);

+	sample->loop_end = dumbfile_igetl(f);

+

+	sample->default_volume = dumbfile_getc(f);

+

+	dumbfile_skip(f, 1);

+

+	flags = dumbfile_getc(f);

+

+	if (flags < 0 || (flags != 0 && flags != 4))

+		/* Sample is packed apparently (or error reading from file). We don't

+		 * know how to read packed samples.

+		 */

+		return -1;

+

+	*pack = flags;

+

+	flags = dumbfile_getc(f);

+

+	sample->C5_speed = dumbfile_igetl(f) << 1;

+

+	/* Skip four unused bytes and three internal variables. */

+	dumbfile_skip(f, 4+2+2+4);

+

+	dumbfile_getnc(sample->name, 28, f);

+	sample->name[28] = 0;

+

+	if (type == 0 || sample->length <= 0) {

+		/* Looks like no-existy. Anyway, there's for sure no 'SCRS' ... */

+		sample->flags &= ~IT_SAMPLE_EXISTS;

+		return dumbfile_error(f);

+	}

+

+	if (dumbfile_mgetl(f) != DUMB_ID('S','C','R','S'))

+		return -1;

+

+	sample->global_volume = 64;

+

+	sample->flags = IT_SAMPLE_EXISTS;

+	if (flags & 1) sample->flags |= IT_SAMPLE_LOOP;

+

+	/* The ST3 TECH.DOC is unclear on this, but IMAGO Orpheus is not. Piece of crap. */

+

+	if (flags & 2) {

+		sample->flags |= IT_SAMPLE_STEREO;

+

+		if ((cwtv & 0xF000) == 0x2000) {

+			sample->length >>= 1;

+			sample->loop_start >>= 1;

+			sample->loop_end >>= 1;

+		}

+	}

+

+	if (flags & 4) {

+		sample->flags |= IT_SAMPLE_16BIT;

+

+		if ((cwtv & 0xF000) == 0x2000) {

+			sample->length >>= 1;

+			sample->loop_start >>= 1;

+			sample->loop_end >>= 1;

+		}

+	}

+

+	sample->default_pan = 0; // 0 = don't use, or 160 = centre?

+

+	if (sample->flags & IT_SAMPLE_LOOP) {

+		if ((unsigned int)sample->loop_end > (unsigned int)sample->length)

+			/*sample->flags &= ~IT_SAMPLE_LOOP;*/

+			sample->loop_end = sample->length;

+		else if ((unsigned int)sample->loop_start >= (unsigned int)sample->loop_end)

+			sample->flags &= ~IT_SAMPLE_LOOP;

+		else

+			/* ScreamTracker seems not to save what comes after the loop end

+			 * point, but rather to assume it is a duplicate of what comes at

+			 * the loop start point. I am not completely sure of this though.

+			 * It is easy to evade; simply truncate the sample.

+			 */

+			sample->length = sample->loop_end;

+	}

+

+

+	//Do we need to set all these?

+	sample->vibrato_speed = 0;

+	sample->vibrato_depth = 0;

+	sample->vibrato_rate = 0;

+	sample->vibrato_waveform = IT_VIBRATO_SINE;

+	sample->finetune = 0;

+	sample->max_resampling_quality = -1;

+

+	return dumbfile_error(f);

+}

+

+

+

+static int it_s3m_read_sample_data(IT_SAMPLE *sample, int ffi, unsigned char pack, DUMBFILE *f)

+{

+	long n;

+

+	long datasize = sample->length;

+	if (sample->flags & IT_SAMPLE_STEREO) datasize <<= 1;

+

+	sample->data = malloc(datasize * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1));

+	if (!sample->data)

+		return -1;

+

+	if (pack == 4) {

+		if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0)

+			return -1;

+	}

+	else if (sample->flags & IT_SAMPLE_STEREO) {

+		if (sample->flags & IT_SAMPLE_16BIT) {

+			for (n = 0; n < datasize; n += 2)

+				((short *)sample->data)[n] = dumbfile_igetw(f);

+			for (n = 1; n < datasize; n += 2)

+				((short *)sample->data)[n] = dumbfile_igetw(f);

+		} else {

+			for (n = 0; n < datasize; n += 2)

+				((signed char *)sample->data)[n] = dumbfile_getc(f);

+			for (n = 1; n < datasize; n += 2)

+				((signed char *)sample->data)[n] = dumbfile_getc(f);

+		}

+	} else if (sample->flags & IT_SAMPLE_16BIT)

+		for (n = 0; n < sample->length; n++)

+			((short *)sample->data)[n] = dumbfile_igetw(f);

+	else

+		for (n = 0; n < sample->length; n++)

+			((signed char *)sample->data)[n] = dumbfile_getc(f);

+

+	if (dumbfile_error(f))

+		return -1;

+

+	if (ffi != 1) {

+		/* Convert to signed. */

+		if (sample->flags & IT_SAMPLE_16BIT)

+			for (n = 0; n < datasize; n++)

+				((short *)sample->data)[n] ^= 0x8000;

+		else

+			for (n = 0; n < datasize; n++)

+				((signed char *)sample->data)[n] ^= 0x80;

+	}

+

+	return 0;

+}

+

+

+

+static int it_s3m_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer, int maxlen)

+{

+	int length;

+	int buflen = 0;

+	int bufpos = 0;

+

+	IT_ENTRY *entry;

+

+	unsigned char channel;

+

+	/* Haha, this is hilarious!

+	 *

+	 * Well, after some experimentation, it seems that different S3M writers

+	 * define the format in different ways. The S3M docs say that the first

+	 * two bytes hold the "length of [the] packed pattern", and the packed

+	 * pattern data follow. Judging by the contents of ARMANI.S3M, packaged

+	 * with ScreamTracker itself, the measure of length _includes_ the two

+	 * bytes used to store the length; in other words, we should read

+	 * (length - 2) more bytes. However, aryx.s3m, packaged with ModPlug

+	 * Tracker, excludes these two bytes, so (length) more bytes must be

+	 * read.

+	 *

+	 * Call me crazy, but I just find it insanely funny that the format was

+	 * misunderstood in this way :D

+	 *

+	 * Now we can't just risk reading two extra bytes, because then we

+	 * overshoot, and DUMBFILEs don't support backward seeking (for a good

+	 * reason). Luckily, there is a way. We can read the data little by

+	 * little, and stop when we have 64 rows in memory. Provided we protect

+	 * against buffer overflow, this method should work with all sensibly

+	 * written S3M files. If you find one for which it does not work, please

+	 * let me know at entheh@users.sf.net so I can look at it.

+	 */

+

+	/* Discard the length. */

+	/* read at most length bytes, in case of retarded crap */

+	length = dumbfile_igetw(f);

+	

+	if (maxlen)

+	{

+		maxlen -= 2;

+		if (length > maxlen) length = maxlen;

+	}

+

+	if (dumbfile_error(f) || !length)

+		return -1;

+

+	pattern->n_rows = 0;

+	pattern->n_entries = 0;

+

+	/* Read in the pattern data, little by little, and work out how many

+	 * entries we need room for. Sorry, but this is just so funny...

+	 */

+	for (;;) {

+		unsigned char b = buffer[buflen++] = dumbfile_getc(f);

+

+#if 1

+		static const unsigned char used[8] = {0, 2, 1, 3, 2, 4, 3, 5};

+		channel = b & 31;

+		b >>= 5;

+		pattern->n_entries++;

+		if (b) {

+			if (buflen + used[b] >= 65536) return -1;

+			if (buflen + used[b] <= length)

+				dumbfile_getnc(buffer + buflen, used[b], f);

+			else

+				memset(buffer + buflen, 0, used[b]);

+			buflen += used[b];

+		} else {

+			/* End of row */

+			if (++pattern->n_rows == 64) break;

+			if (buflen >= 65536) return -1;

+		}

+#else

+		if (b == 0) {

+			/* End of row */

+			pattern->n_entries++;

+			if (++pattern->n_rows == 64) break;

+			if (buflen >= 65536) return -1;

+		} else {

+			static const unsigned char used[8] = {0, 2, 1, 3, 2, 4, 3, 5};

+			channel = b & 31;

+			b >>= 5;

+			if (b) {

+				pattern->n_entries++;

+				if (buflen + used[b] >= 65536) return -1;

+				dumbfile_getnc(buffer + buflen, used[b], f);

+				buflen += used[b];

+			}

+		}

+#endif

+

+		/* We have ensured that buflen < 65536 at this point, so it is safe

+		 * to iterate and read at least one more byte without checking.

+		 * However, now would be a good time to check for errors reading from

+		 * the file.

+		 */

+

+		if (dumbfile_error(f))

+			return -1;

+

+		/* Great. We ran out of data, but there should be data for more rows.

+		 * Fill the rest with null data...

+		 */

+		if (buflen >= length && pattern->n_rows < 64)

+		{

+			while (pattern->n_rows < 64)

+			{

+				if (buflen >= 65536) return -1;

+				buffer[buflen++] = 0;

+				pattern->n_entries++;

+				pattern->n_rows++;

+			}

+			break;

+		}

+	}

+

+	pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry));

+

+	if (!pattern->entry)

+		return -1;

+

+	entry = pattern->entry;

+

+	while (bufpos < buflen) {

+		unsigned char b = buffer[bufpos++];

+

+#if 1

+		if (!(b & ~31))

+#else

+		if (b == 0)

+#endif

+		{

+			/* End of row */

+			IT_SET_END_ROW(entry);

+			entry++;

+			continue;

+		}

+

+		channel = b & 31;

+

+		if (b & 224) {

+			entry->mask = 0;

+			entry->channel = channel;

+

+			if (b & 32) {

+				unsigned char n = buffer[bufpos++];

+				if (n != 255) {

+					if (n == 254)

+						entry->note = IT_NOTE_CUT;

+					else

+						entry->note = (n >> 4) * 12 + (n & 15);

+					entry->mask |= IT_ENTRY_NOTE;

+				}

+

+				entry->instrument = buffer[bufpos++];

+				if (entry->instrument)

+					entry->mask |= IT_ENTRY_INSTRUMENT;

+			}

+

+			if (b & 64) {

+				entry->volpan = buffer[bufpos++];

+				if (entry->volpan != 255)

+					entry->mask |= IT_ENTRY_VOLPAN;

+			}

+

+			if (b & 128) {

+				entry->effect = buffer[bufpos++];

+				entry->effectvalue = buffer[bufpos++];

+				// XXX woot

+				if (entry->effect && entry->effect < IT_MIDI_MACRO /*!= 255*/) {

+					entry->mask |= IT_ENTRY_EFFECT;

+					switch (entry->effect) {

+					case IT_BREAK_TO_ROW:

+						entry->effectvalue -= (entry->effectvalue >> 4) * 6;

+						break;

+

+					case IT_SET_CHANNEL_VOLUME:

+					case IT_CHANNEL_VOLUME_SLIDE:

+					case IT_PANNING_SLIDE:

+					case IT_GLOBAL_VOLUME_SLIDE:

+					case IT_PANBRELLO:

+					case IT_MIDI_MACRO:

+						entry->mask &= ~IT_ENTRY_EFFECT;

+						break;

+

+					case IT_S:

+						switch (entry->effectvalue >> 4) {

+						case IT_S_SET_PANBRELLO_WAVEFORM:

+						case IT_S_FINE_PATTERN_DELAY:

+						case IT_S7:

+						case IT_S_SET_SURROUND_SOUND:

+						case IT_S_SET_MIDI_MACRO:

+							entry->mask &= ~IT_ENTRY_EFFECT;

+							break;

+						}

+						break;

+					}

+				}

+				/** WARNING: ARGH! CONVERT TEH EFFECTS!@~ */

+			}

+

+			entry++;

+		}

+	}

+

+	ASSERT(entry == pattern->entry + pattern->n_entries);

+

+	return 0;

+}

+

+

+

+/** WARNING: this is duplicated in itread.c - also bad practice to use the same struct name unless they are unified in a header */

+/* Currently we assume the sample data are stored after the sample headers in

+ * module files. This assumption may be unjustified; let me know if you have

+ * trouble.

+ */

+

+#define S3M_COMPONENT_INSTRUMENT 1

+#define S3M_COMPONENT_PATTERN    2

+#define S3M_COMPONENT_SAMPLE     3

+

+typedef struct S3M_COMPONENT

+{

+	unsigned char type;

+	unsigned char n;

+	long offset;

+	short sampfirst; /* component[sampfirst] = first sample data after this */

+	short sampnext; /* sampnext is used to create linked lists of sample data */

+}

+S3M_COMPONENT;

+

+

+

+static int s3m_component_compare(const void *e1, const void *e2)

+{

+	return ((const S3M_COMPONENT *)e1)->offset -

+	       ((const S3M_COMPONENT *)e2)->offset;

+}

+

+

+

+static DUMB_IT_SIGDATA *it_s3m_load_sigdata(DUMBFILE *f, int * cwtv)

+{

+	DUMB_IT_SIGDATA *sigdata;

+

+	int flags, ffi;

+	int default_pan_present;

+

+	int master_volume;

+

+	unsigned char sample_pack[256];

+

+	S3M_COMPONENT *component;

+	int n_components = 0;

+

+	int n;

+

+	unsigned char *buffer;

+

+	sigdata = malloc(sizeof(*sigdata));

+	if (!sigdata) return NULL;

+

+	dumbfile_getnc(sigdata->name, 28, f);

+	sigdata->name[28] = 0;

+

+	n = dumbfile_getc(f);

+

+	if (n != 0x1A && n != 0) {

+		free(sigdata);

+		return NULL;

+	}

+

+	if (dumbfile_getc(f) != 16) {

+		free(sigdata);

+		return NULL;

+	}

+

+	dumbfile_skip(f, 2);

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->sample = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->n_orders = dumbfile_igetw(f);

+	sigdata->n_instruments = 0;

+	sigdata->n_samples = dumbfile_igetw(f);

+	sigdata->n_patterns = dumbfile_igetw(f);

+

+	if (dumbfile_error(f) || sigdata->n_orders <= 0 || sigdata->n_samples > 256 || sigdata->n_patterns > 256) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	sigdata->order = malloc(sigdata->n_orders);

+	if (!sigdata->order) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	if (sigdata->n_samples) {

+		sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));

+		if (!sigdata->sample) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		for (n = 0; n < sigdata->n_samples; n++)

+			sigdata->sample[n].data = NULL;

+	}

+

+	if (sigdata->n_patterns) {

+		sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));

+		if (!sigdata->pattern) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		for (n = 0; n < sigdata->n_patterns; n++)

+			sigdata->pattern[n].entry = NULL;

+	}

+

+	flags = dumbfile_igetw(f);

+

+	*cwtv = dumbfile_igetw(f);

+

+	if (*cwtv == 0x1300) {

+		/** WARNING: volume slides on every frame */

+	}

+

+	ffi = dumbfile_igetw(f);

+

+	/** WARNING: which ones? */

+	sigdata->flags = IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M;

+

+	if (dumbfile_mgetl(f) != DUMB_ID('S','C','R','M')) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	sigdata->global_volume = dumbfile_getc(f) << 1;

+	if ( !sigdata->global_volume || sigdata->global_volume > 128 ) sigdata->global_volume = 128;

+	sigdata->speed = dumbfile_getc(f);

+	if (sigdata->speed == 0) sigdata->speed = 6; // Should we? What about tempo?

+	sigdata->tempo = dumbfile_getc(f);

+	master_volume = dumbfile_getc(f); // 7 bits; +128 for stereo

+	//what do we do with master_volume? it's not the same as mixing volume...

+	sigdata->mixing_volume = 48;

+

+	if (master_volume & 128) sigdata->flags |= IT_STEREO;

+

+	/* Skip GUS Ultra Click Removal byte. */

+	dumbfile_getc(f);

+

+	default_pan_present = dumbfile_getc(f);

+

+	dumbfile_skip(f, 8);

+

+	/* Skip Special Custom Data Pointer. */

+	/** WARNING: investigate this? */

+	dumbfile_igetw(f);

+

+	sigdata->n_pchannels = 0;

+	/* Channel settings for 32 channels, 255=unused, +128=disabled */

+	{

+		int i;

+		for (i = 0; i < 32; i++) {

+			int c = dumbfile_getc(f);

+			if (!(c & (128 | 16))) { /* +128=disabled, +16=Adlib */

+				if (sigdata->n_pchannels < i + 1) sigdata->n_pchannels = i + 1;

+				sigdata->channel_volume[i] = 64;

+				sigdata->channel_pan[i] = c & 8 ? 12 : 3;

+				/** WARNING: ah, but it should be 7 for mono... */

+			} else {

+				/** WARNING: this could be improved if we support channel muting... */

+				sigdata->channel_volume[i] = 0;

+				sigdata->channel_pan[i] = 7;

+			}

+		}

+	}

+

+	/* Orders, byte each, length = sigdata->n_orders (should be even) */

+	dumbfile_getnc(sigdata->order, sigdata->n_orders, f);

+	sigdata->restart_position = 0;

+

+	component = malloc(768*sizeof(*component));

+	if (!component) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	for (n = 0; n < sigdata->n_samples; n++) {

+		component[n_components].type = S3M_COMPONENT_SAMPLE;

+		component[n_components].n = n;

+		component[n_components].offset = dumbfile_igetw(f) << 4;

+		component[n_components].sampfirst = -1;

+		n_components++;

+	}

+

+	for (n = 0; n < sigdata->n_patterns; n++) {

+		long offset = dumbfile_igetw(f) << 4;

+		if (offset) {

+			component[n_components].type = S3M_COMPONENT_PATTERN;

+			component[n_components].n = n;

+			component[n_components].offset = offset;

+			component[n_components].sampfirst = -1;

+			n_components++;

+		} else {

+			/** WARNING: Empty 64-row pattern ... ? (this does happen!) */

+			sigdata->pattern[n].n_rows = 64;

+			sigdata->pattern[n].n_entries = 0;

+		}

+	}

+

+	qsort(component, n_components, sizeof(S3M_COMPONENT), &s3m_component_compare);

+

+	/* I found a really dumb S3M file that claimed to contain default pan

+	 * data but didn't contain any. Programs would load it by reading part of

+	 * the first instrument header, assuming the data to be default pan

+	 * positions, and then rereading the instrument module. We cannot do this

+	 * without obfuscating the file input model, so we insert an extra check

+	 * here that we won't overrun the start of the first component.

+	 */

+	if (default_pan_present == 252 && component[0].offset >= dumbfile_pos(f) + 32) {

+		/* Channel default pan positions */

+		int i;

+		for (i = 0; i < 32; i++) {

+			int c = dumbfile_getc(f);

+			if (c & 32)

+				sigdata->channel_pan[i] = c & 15;

+		}

+	}

+

+	{

+		int i;

+		for (i = 0; i < 32; i++) {

+			sigdata->channel_pan[i] -= (sigdata->channel_pan[i] & 8) >> 3;

+			sigdata->channel_pan[i] = ((int)sigdata->channel_pan[i] << 5) / 7;

+		}

+	}

+

+	sigdata->pan_separation = 128;

+

+	if (dumbfile_error(f)) {

+		free(component);

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	buffer = malloc(65536);

+	if (!buffer) {

+		free(component);

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	/* Voila, I must deal with a very dumb S3M myself. This file refers to the same file offset twice

+	 * for two different patterns. Solution: Eliminate it.

+	 */

+

+	for (n = 0; n < n_components; n++) {

+		if (component[n].type == S3M_COMPONENT_PATTERN) {

+			int m;

+			for (m = n + 1; m < n_components; m++) {

+				if (component[m].type == S3M_COMPONENT_PATTERN) {

+					if (component[n].offset == component[m].offset) {

+						int o, pattern;

+						pattern = component[m].n;

+						n_components--;

+						for (o = m; o < n_components; o++) {

+							component[o] = component[o + 1];

+						}

+						for (o = 0; o < sigdata->n_orders; o++) {

+							if (sigdata->order[o] == pattern) {

+								sigdata->order[o] = component[n].n;

+							}

+						}

+						sigdata->pattern[pattern].n_rows = 64;

+						sigdata->pattern[pattern].n_entries = 0;

+						m--;

+					} else

+						break;

+				}

+			}

+		}

+	}

+

+	for (n = 0; n < n_components; n++) {

+		long offset;

+		int m;

+#ifdef S3M_BROKEN_OVERLAPPED_SAMPLES

+		int last;

+#endif

+

+		if (it_seek(f, component[n].offset)) {

+			free(buffer);

+			free(component);

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+

+		switch (component[n].type) {

+

+			case S3M_COMPONENT_PATTERN:

+				if (it_s3m_read_pattern(&sigdata->pattern[component[n].n], f, buffer, (n + 1 < n_components) ? (component[n+1].offset - component[n].offset) : 0)) {

+					free(buffer);

+					free(component);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+				break;

+

+			case S3M_COMPONENT_SAMPLE:

+                {

+                int err = it_s3m_read_sample_header(&sigdata->sample[component[n].n], &offset, &sample_pack[component[n].n], *cwtv, f);

+				if (err) {

+					free(buffer);

+					free(component);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+                }

+

+				if (sigdata->sample[component[n].n].flags & IT_SAMPLE_EXISTS) {

+					short *sample;

+

+					for (m = n + 1; m < n_components; m++)

+						if (component[m].offset > offset)

+							break;

+					m--;

+

+					sample = &component[m].sampfirst;

+

+					while (*sample >= 0 && component[*sample].offset <= offset)

+						sample = &component[*sample].sampnext;

+

+					component[n].sampnext = *sample;

+					*sample = n;

+

+					component[n].offset = offset;

+				}

+		}

+

+		m = component[n].sampfirst;

+

+#ifdef S3M_BROKEN_OVERLAPPED_SAMPLES

+		last = -1;

+#endif

+

+		while (m >= 0) {

+			// XXX

+#ifdef S3M_BROKEN_OVERLAPPED_SAMPLES

+			if ( last >= 0 ) {

+				if ( dumbfile_pos( f ) > component[m].offset ) {

+					IT_SAMPLE * s1 = &sigdata->sample[component[last].n];

+					IT_SAMPLE * s2 = &sigdata->sample[component[m].n];

+					if ( ( s1->flags | s2->flags ) & ( IT_SAMPLE_16BIT | IT_SAMPLE_STEREO ) ) {

+						free(buffer);

+						free(component);

+						_dumb_it_unload_sigdata(sigdata);

+						return NULL;

+					}

+					if ( component[m].offset >= component[last].offset &&

+						component[m].offset + s2->length <= component[last].offset + s1->length ) {

+						s2->left = malloc( s2->length );

+						if ( ! s2->left ) {

+							free(buffer);

+							free(component);

+							_dumb_it_unload_sigdata(sigdata);

+							return NULL;

+						}

+						memcpy( s2->left, ( const char * ) s1->left + component[m].offset - component[last].offset, s2->length );

+						last = -1;

+					}

+				}

+			} else last = 0;

+

+			if ( last >= 0 ) {

+#endif

+				if (it_seek(f, component[m].offset)) {

+					free(buffer);

+					free(component);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+

+				if (it_s3m_read_sample_data(&sigdata->sample[component[m].n], ffi, sample_pack[component[m].n], f)) {

+					free(buffer);

+					free(component);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+

+#ifdef S3M_BROKEN_OVERLAPPED_SAMPLES

+				last = m;

+			}

+#endif

+

+			m = component[m].sampnext;

+		}

+	}

+

+	free(buffer);

+	free(component);

+

+	_dumb_it_fix_invalid_orders(sigdata);

+

+	return sigdata;

+}

+

+static char hexdigit(int in)

+{

+	if (in < 10) return in + '0';

+	else return in + 'A' - 10;

+}

+

+DUH *dumb_read_s3m_quick(DUMBFILE *f)

+{

+	sigdata_t *sigdata;

+	int cwtv;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_s3m_load_sigdata(f, &cwtv);

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		char version[8];

+		const char *tag[3][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		tag[1][1] = "S3M";

+		tag[2][0] = "TRACKERVERSION";

+		version[0] = hexdigit((cwtv >> 8) & 15);

+		version[1] = '.';

+		version[2] = hexdigit((cwtv >> 4) & 15);

+		version[3] = hexdigit(cwtv & 15);

+		version[4] = 0;

+		tag[2][1] = (const char *) &version;

+		return make_duh(-1, 3, (const char *const (*)[2])tag, 1, &descptr, &sigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/reads3m2.c b/plugins/dumb/dumb-kode54/src/it/reads3m2.c
new file mode 100644
index 00000000..0499eecd
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/reads3m2.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * reads3m2.c - Function to read a ScreamTracker 3    / / \  \

+ *              module from an open file and do an   | <  /   \_

+ *              initial run-through.                 |  \/ /\   /

+ *                                                    \_  /  > /

+ * Split off from reads3m.c by entheh.                  | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+

+

+

+DUH *dumb_read_s3m(DUMBFILE *f)

+{

+	DUH *duh = dumb_read_s3m_quick(f);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readstm.c b/plugins/dumb/dumb-kode54/src/it/readstm.c
new file mode 100644
index 00000000..5972a0f7
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readstm.c
@@ -0,0 +1,397 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readstm.c - Code to read a ScreamTracker 2         / / \  \

+ *             module from an open file.             | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Chris Moeller.                                  \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+// IT_STEREO... :o

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+/** WARNING: this is duplicated in itread.c */

+static int it_seek(DUMBFILE *f, long offset)

+{

+	long pos = dumbfile_pos(f);

+

+	if (pos > offset) {

+		return -1;

+	}

+

+	if (pos < offset)

+		if (dumbfile_skip(f, offset - pos))

+			return -1;

+

+	return 0;

+}

+

+static int it_stm_read_sample_header( IT_SAMPLE *sample, DUMBFILE *f )

+{

+	dumbfile_getnc( sample->filename, 12, f );

+	sample->filename[12] = 0;

+

+	memcpy( sample->name, sample->filename, 13 );

+

+	dumbfile_skip( f, 2 + 2 );

+

+	sample->length = dumbfile_igetw( f );

+	sample->loop_start = dumbfile_igetw( f );

+	sample->loop_end = dumbfile_igetw( f );

+

+	sample->default_volume = dumbfile_getc( f );

+

+	dumbfile_skip( f, 1 );

+

+	sample->C5_speed = dumbfile_igetw( f ) << 3;

+

+	dumbfile_skip( f, 6 );

+

+	if ( sample->length < 4 || !sample->default_volume ) {

+		/* Looks like no-existy. */

+		sample->flags &= ~IT_SAMPLE_EXISTS;

+		sample->length = 0;

+		return dumbfile_error( f );

+	}

+

+	sample->flags = IT_SAMPLE_EXISTS;

+	sample->global_volume = 64;

+	sample->default_pan = 0; // 0 = don't use, or 160 = centre?

+

+	if ( ( sample->loop_start < sample->length ) &&

+		( sample->loop_end > sample->loop_start ) &&

+		( sample->loop_end != 0xFFFF ) ) {

+		sample->flags |= IT_SAMPLE_LOOP;

+		if ( sample->loop_end > sample->length ) sample->loop_end = sample->length;

+	}

+

+	//Do we need to set all these?

+	sample->vibrato_speed = 0;

+	sample->vibrato_depth = 0;

+	sample->vibrato_rate = 0;

+	sample->vibrato_waveform = IT_VIBRATO_SINE;

+	sample->finetune = 0;

+	sample->max_resampling_quality = -1;

+

+	return dumbfile_error(f);

+}

+

+static int it_stm_read_sample_data( IT_SAMPLE *sample, DUMBFILE *f )

+{

+	long n;

+

+	if ( ! sample->length ) return 0;

+

+	n = dumbfile_pos( f );

+	if ( n & 15 ) {

+		if ( dumbfile_skip( f, 16 - ( n & 15 ) ) )

+			return -1;

+	}

+

+	sample->data = malloc( sample->length );

+	if (!sample->data)

+		return -1;

+

+	if ( dumbfile_getnc( sample->data, sample->length, f ) != sample->length )

+		return -1;

+

+	return 0;

+}

+

+static int it_stm_read_pattern( IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer )

+{

+	int pos;

+	int channel;

+	int row;

+	IT_ENTRY *entry;

+

+	pattern->n_rows = 64;

+

+	if ( dumbfile_getnc( buffer, 64 * 4 * 4, f ) != 64 * 4 * 4 )

+		return -1;

+

+	pattern->n_entries = 64;

+	pos = 0;

+	for ( row = 0; row < 64; ++row ) {

+		for ( channel = 0; channel < 4; ++channel ) {

+			if ( buffer[ pos + 0 ] | buffer[ pos + 1 ] | buffer[ pos + 2 ] | buffer[ pos + 3 ] )

+				++pattern->n_entries;

+			pos += 4;

+		}

+	}

+

+	pattern->entry = malloc( pattern->n_entries * sizeof( *pattern->entry ) );

+	if ( !pattern->entry )

+		return -1;

+

+	entry = pattern->entry;

+	pos = 0;

+	for ( row = 0; row < 64; ++row ) {

+		for ( channel = 0; channel < 4; ++channel ) {

+			if ( buffer[ pos + 0 ] | buffer[ pos + 1 ] | buffer[ pos + 2 ] | buffer[ pos + 3 ] ) {

+				unsigned note;

+				note = buffer[ pos + 0 ];

+				entry->channel = channel;

+				entry->mask = 0;

+				entry->instrument = buffer[ pos + 1 ] >> 3;

+				entry->volpan = ( buffer[ pos + 1 ] & 0x07 ) + ( buffer[ pos + 2 ] >> 1 );

+				entry->effect = buffer[ pos + 2 ] & 0x0F;

+				entry->effectvalue = buffer[ pos + 3 ];

+				if ( entry->instrument && entry->instrument < 32 )

+					entry->mask |= IT_ENTRY_INSTRUMENT;

+				if ( note == 0xFC || note == 0xFE ) {

+					entry->mask |= IT_ENTRY_NOTE;

+					entry->note = IT_NOTE_CUT;

+				}

+				if ( note < 251 ) {

+					entry->mask |= IT_ENTRY_NOTE;

+					entry->note = ( note >> 4 ) * 12 + ( note & 0x0F );

+				}

+				if ( entry->volpan <= 64 )

+					entry->mask |= IT_ENTRY_VOLPAN;

+				entry->mask |= IT_ENTRY_EFFECT;

+				switch ( entry->effect ) {

+					case IT_SET_SPEED:

+						entry->effectvalue >>= 4;

+						break;

+

+					case IT_BREAK_TO_ROW:

+						entry->effectvalue -= (entry->effectvalue >> 4) * 6;

+						break;

+

+					case IT_JUMP_TO_ORDER:

+					case IT_VOLUME_SLIDE:

+					case IT_PORTAMENTO_DOWN:

+					case IT_PORTAMENTO_UP:

+					case IT_TONE_PORTAMENTO:

+					case IT_VIBRATO:

+					case IT_TREMOR:

+					case IT_ARPEGGIO:

+					case IT_VOLSLIDE_VIBRATO:

+					case IT_VOLSLIDE_TONEPORTA:

+						break;

+

+					default:

+						entry->mask &= ~IT_ENTRY_EFFECT;

+						break;

+				}

+				if ( entry->mask ) ++entry;

+			}

+			pos += 4;

+		}

+		IT_SET_END_ROW(entry);

+		++entry;

+	}

+

+	pattern->n_entries = entry - pattern->entry;

+

+	return 0;

+}

+

+

+

+static DUMB_IT_SIGDATA *it_stm_load_sigdata(DUMBFILE *f /*, int * version*/)

+{

+	DUMB_IT_SIGDATA *sigdata;

+

+	char tracker_name[ 8 ];

+

+	int n;

+

+	sigdata = malloc(sizeof(*sigdata));

+	if (!sigdata) return NULL;

+

+	/* Skip song name. */

+	dumbfile_getnc(sigdata->name, 20, f);

+	sigdata->name[20] = 0;

+

+	dumbfile_getnc(tracker_name, 8, f);

+	n = dumbfile_getc(f);

+	if ( n != 0x02 && n != 0x1A && n != 0x1B )

+	{

+		free( sigdata );

+		return NULL;

+	}

+	if ( dumbfile_getc(f) != 2 ) /* only support modules */

+	{

+		free( sigdata );

+		return NULL;

+	}

+	if ( strncasecmp( tracker_name, "!Scream!", 8 ) &&

+		strncasecmp( tracker_name, "BMOD2STM", 8 ) &&

+		strncasecmp( tracker_name, "WUZAMOD!", 8 ) )

+	{

+		free( sigdata );

+		return NULL;

+	}

+

+	/* *version = dumbfile_mgetw(f); */

+	dumbfile_skip( f, 2 );

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->sample = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->n_instruments = 0;

+	sigdata->n_samples = 31;

+	sigdata->n_pchannels = 4;

+

+	sigdata->tempo = 125;

+	sigdata->mixing_volume = 48;

+	sigdata->pan_separation = 128;

+

+	/** WARNING: which ones? */

+	sigdata->flags = IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M;

+

+	sigdata->speed = dumbfile_getc(f) >> 4;

+	if ( sigdata->speed < 1 ) sigdata->speed = 1;

+	sigdata->n_patterns = dumbfile_getc(f);

+	sigdata->global_volume = dumbfile_getc(f) << 1;

+	if ( sigdata->global_volume > 128 ) sigdata->global_volume = 128;

+	

+	dumbfile_skip(f, 13);

+

+	if ( dumbfile_error(f) || sigdata->n_patterns < 1 || sigdata->n_patterns > 99 ) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));

+	if (!sigdata->sample) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+	for (n = 0; n < sigdata->n_samples; n++)

+		sigdata->sample[n].data = NULL;

+

+	if (sigdata->n_patterns) {

+		sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));

+		if (!sigdata->pattern) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		for (n = 0; n < sigdata->n_patterns; n++)

+			sigdata->pattern[n].entry = NULL;

+	}

+

+	memset( sigdata->channel_volume, 64, 4 );

+	sigdata->channel_pan[ 0 ] = 48;

+	sigdata->channel_pan[ 1 ] = 16;

+	sigdata->channel_pan[ 2 ] = 48;

+	sigdata->channel_pan[ 3 ] = 16;

+

+	for ( n = 0; n < sigdata->n_samples; ++n ) {

+		if ( it_stm_read_sample_header( &sigdata->sample[ n ], f ) ) {

+			_dumb_it_unload_sigdata( sigdata );

+			return NULL;

+		}

+	}

+

+	sigdata->order = malloc( 128 );

+	if ( !sigdata->order ) {

+		_dumb_it_unload_sigdata( sigdata );

+		return NULL;

+	}

+

+	/* Orders, byte each, length = sigdata->n_orders (should be even) */

+	dumbfile_getnc( sigdata->order, 128, f );

+	sigdata->restart_position = 0;

+

+	for ( n = 127; n >= 0; --n ) {

+		if ( sigdata->order[ n ] < sigdata->n_patterns ) break;

+	}

+	if ( n < 0 ) {

+		_dumb_it_unload_sigdata( sigdata );

+		return NULL;

+	}

+	sigdata->n_orders = n + 1;

+

+	for ( n = 0; n < 128; ++n ) {

+		if ( sigdata->order[ n ] >= 99 ) sigdata->order[ n ] = 0xFF;

+	}

+

+	if ( sigdata->n_patterns ) {

+		unsigned char * buffer = malloc( 64 * 4 * 4 );

+		if ( ! buffer ) {

+			_dumb_it_unload_sigdata( sigdata );

+			return NULL;

+		}

+		for ( n = 0; n < sigdata->n_patterns; ++n ) {

+			if ( it_stm_read_pattern( &sigdata->pattern[ n ], f, buffer ) ) {

+				free( buffer );

+				_dumb_it_unload_sigdata( sigdata );

+				return NULL;

+			}

+		}

+		free( buffer );

+	}

+

+	for ( n = 0; n < sigdata->n_samples; ++n ) {

+		if ( it_stm_read_sample_data( &sigdata->sample[ n ], f ) ) {

+			_dumb_it_unload_sigdata( sigdata );

+			return NULL;

+		}

+	}

+

+	_dumb_it_fix_invalid_orders(sigdata);

+

+	return sigdata;

+}

+

+/*static char hexdigit(int in)

+{

+	if (in < 10) return in + '0';

+	else return in + 'A' - 10;

+}*/

+

+DUH *dumb_read_stm_quick(DUMBFILE *f)

+{

+	sigdata_t *sigdata;

+	/*int ver;*/

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_stm_load_sigdata(f /*, &ver*/);

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		/*char version[16];*/

+		const char *tag[2][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		tag[1][1] = "STM";

+		/*version[0] = 'S';

+		version[1] = 'T';

+		version[2] = 'M';

+		version[3] = ' ';

+		version[4] = 'v';

+		version[5] = hexdigit((ver >> 8) & 15);

+		version[6] = '.';

+		version[7] = hexdigit((ver >> 4) & 15);

+		version[8] = hexdigit(ver & 15);

+		version[9] = 0;

+		tag[1][1] = (const char *) &version;*/

+		return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readstm2.c b/plugins/dumb/dumb-kode54/src/it/readstm2.c
new file mode 100644
index 00000000..c336b2a3
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readstm2.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readstm2.c - Function to read a ScreamTracker 2    / / \  \

+ *              module from an open file and do an   | <  /   \_

+ *              initial run-through.                 |  \/ /\   /

+ *                                                    \_  /  > /

+ * By Chris Moeller.                                    | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+

+

+

+DUH *dumb_read_stm(DUMBFILE *f)

+{

+	DUH *duh = dumb_read_stm_quick(f);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readxm.c b/plugins/dumb/dumb-kode54/src/it/readxm.c
new file mode 100644
index 00000000..c76d0f3e
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readxm.c
@@ -0,0 +1,1210 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readxm.c - Code to read a Fast Tracker II          / / \  \

+ *            module from an open file.              | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Julien Cugniere. Some bits of code taken        \_  /  > /

+ * from reads3m.c.                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <stdlib.h>

+#include <string.h>

+#include <math.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+

+

+/** TODO:

+

+ * XM_TREMOLO                        doesn't sound quite right...

+ * XM_SET_ENVELOPE_POSITION          todo.

+

+ * VIBRATO conversion needs to be checked (sample/effect/volume). Plus check

+   that effect memory is correct when using XM_VOLSLIDE_VIBRATO.

+   - sample vibrato (instrument vibrato) is now handled correctly. - entheh

+

+ * XM_E_SET_VIBRATO/TREMOLO_CONTROL: effectvalue&4 -> don't retrig wave when

+   a new instrument is played. In retrigger_note()?. Is it worth implementing?

+

+ * Lossy fadeout approximation. 0..31 converted to 0 --> won't fade at all.

+

+ * Replace DUMB's sawtooth by ramp_down/ramp_up. Update XM loader.

+

+ * A lot of things need to be reset when the end of the song is reached.

+

+ * It seems that IT and XM don't behave the same way when dealing with

+   mixed loops. When IT encounters multiple SBx (x>0) commands on the same

+   row, it decrements the loop count for all, but only execute the loop of

+   the last one (highest channel). FT2 only decrements the loop count of the

+   last one. Not that I know of any modules using so convoluted combinations!

+

+ * Maybe we could remove patterns that don't appear in the order table ? Or

+   provide a function to "optimize" a DUMB_IT_SIGDATA ?

+

+*/

+

+

+

+#define XM_LINEAR_FREQUENCY        1 /* otherwise, use amiga slides */

+

+#define XM_ENTRY_PACKED            128

+#define XM_ENTRY_NOTE              1

+#define XM_ENTRY_INSTRUMENT        2

+#define XM_ENTRY_VOLUME            4

+#define XM_ENTRY_EFFECT            8

+#define XM_ENTRY_EFFECTVALUE       16

+

+#define XM_NOTE_OFF                97

+

+#define XM_ENVELOPE_ON             1

+#define XM_ENVELOPE_SUSTAIN        2

+#define XM_ENVELOPE_LOOP           4

+

+#define XM_SAMPLE_NO_LOOP          0

+#define XM_SAMPLE_FORWARD_LOOP     1

+#define XM_SAMPLE_PINGPONG_LOOP    2

+#define XM_SAMPLE_16BIT            16

+#define XM_SAMPLE_STEREO           32

+

+#define XM_VIBRATO_SINE            0

+#define XM_VIBRATO_SQUARE          1

+#define XM_VIBRATO_RAMP_DOWN       2

+#define XM_VIBRATO_RAMP_UP         3

+

+

+

+/* Probably useless :) */

+const char xm_convert_vibrato[] = {

+	IT_VIBRATO_SINE,

+	IT_VIBRATO_XM_SQUARE,

+	IT_VIBRATO_RAMP_DOWN,

+	IT_VIBRATO_RAMP_UP,

+	IT_VIBRATO_RANDOM

+};

+

+

+

+#define XM_MAX_SAMPLES_PER_INSTRUMENT 16

+

+

+

+/* Extra data that doesn't fit inside IT_INSTRUMENT */

+typedef struct XM_INSTRUMENT_EXTRA

+{

+	int n_samples;

+	int vibrato_type;

+	int vibrato_sweep; /* 0-0xFF */

+	int vibrato_depth; /* 0-0x0F */

+	int vibrato_speed; /* 0-0x3F */

+}

+XM_INSTRUMENT_EXTRA;

+

+

+

+/* Frees the original block if it can't resize it or if size is 0, and acts

+ * as malloc if ptr is NULL.

+ */

+static void *safe_realloc(void *ptr, size_t size)

+{

+	if (ptr == NULL)

+		return malloc(size);

+

+	if (size == 0) {

+		free(ptr);

+		return NULL;

+	} else {

+		void *new_block = realloc(ptr, size);

+		if (!new_block)

+			free(ptr);

+		return new_block;

+	}

+}

+

+

+

+/* The interpretation of the XM volume column is left to the player. Here, we

+ * just filter bad values.

+ */

+// This function is so tiny now, should we inline it?

+static void it_xm_convert_volume(int volume, IT_ENTRY *entry)

+{

+	entry->mask |= IT_ENTRY_VOLPAN;

+	entry->volpan = volume;

+

+	switch (volume >> 4) {

+		case 0xA: /* set vibrato speed */

+		case 0xB: /* vibrato */

+		case 0xF: /* tone porta */

+		case 0x6: /* vol slide up */

+		case 0x7: /* vol slide down */

+		case 0x8: /* fine vol slide up */

+		case 0x9: /* fine vol slide down */

+		case 0xC: /* set panning */

+		case 0xD: /* pan slide left */

+		case 0xE: /* pan slide right */

+		case 0x1: /* set volume */

+		case 0x2: /* set volume */

+		case 0x3: /* set volume */

+		case 0x4: /* set volume */

+			break;

+

+		case 0x5:

+			if (volume == 0x50)

+				break; /* set volume */

+			/* else fall through */

+

+		default:

+			entry->mask &= ~IT_ENTRY_VOLPAN;

+			break;

+	}

+}

+

+

+

+static int it_xm_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, int n_channels, unsigned char *buffer, int version)

+{

+	int size;

+	int pos;

+	int channel;

+	int row;

+	int effect, effectvalue;

+	IT_ENTRY *entry;

+

+	/* pattern header size */

+	if (dumbfile_igetl(f) != ( version == 0x0102 ? 0x08 : 0x09 ) ) {

+		TRACE("XM error: unexpected pattern header size\n");

+		return -1;

+	}

+

+	/* pattern data packing type */

+	if (dumbfile_getc(f) != 0) {

+		TRACE("XM error: unexpected pattern packing type\n");

+		return -1;

+	}

+

+	if ( version == 0x0102 )

+		pattern->n_rows = dumbfile_getc(f) + 1;

+	else

+		pattern->n_rows = dumbfile_igetw(f);  /* 1..256 */

+	size = dumbfile_igetw(f);

+	pattern->n_entries = 0;

+

+	if (dumbfile_error(f))

+		return -1;

+

+	if (size == 0)

+		return 0;

+

+	if (size > 1280 * n_channels) {

+		TRACE("XM error: pattern data size > %d bytes\n", 1280 * n_channels);

+		return -1;

+	}

+

+	if (dumbfile_getnc(buffer, size, f) < size)

+		return -1;

+

+	/* compute number of entries */

+	pattern->n_entries = 0;

+	pos = channel = row = 0;

+	while (pos < size) {

+		if (!(buffer[pos] & XM_ENTRY_PACKED) || (buffer[pos] & 31))

+			pattern->n_entries++;

+

+		channel++;

+		if (channel >= n_channels) {

+			channel = 0;

+			row++;

+			pattern->n_entries++;

+		}

+

+		if (buffer[pos] & XM_ENTRY_PACKED) {

+			static const char offset[] = { 0, 1, 1, 2, 1, 2, 2, 3,   1, 2, 2, 3, 2, 3, 3, 4,

+			                               1, 2, 2, 3, 2, 3, 3, 4,   2, 3, 3, 4, 3, 4, 4, 5 };

+			pos += 1 + offset[buffer[pos] & 31];

+		} else {

+			pos += 5;

+		}

+	}

+

+	if (row > pattern->n_rows) {

+		TRACE("XM error: wrong number of rows in pattern data\n");

+		return -1;

+	}

+

+	/* Whoops, looks like some modules may be short, a few channels, maybe even rows... */

+

+	while (row < pattern->n_rows)

+	{

+		pattern->n_entries++;

+		row++;

+	}

+

+	pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry));

+	if (!pattern->entry)

+		return -1;

+

+	/* read the entries */

+	entry = pattern->entry;

+	pos = channel = row = 0;

+	while (pos < size) {

+		unsigned char mask;

+

+		if (buffer[pos] & XM_ENTRY_PACKED)

+			mask = buffer[pos++] & 31;

+		else

+			mask = 31;

+

+		if (mask) {

+			ASSERT(entry < pattern->entry + pattern->n_entries);

+

+			entry->channel = channel;

+			entry->mask = 0;

+

+			if (mask & XM_ENTRY_NOTE) {

+				int note = buffer[pos++]; /* 1-96 <=> C0-B7 */

+				entry->note = (note == XM_NOTE_OFF) ? (IT_NOTE_OFF) : (note-1);

+				entry->mask |= IT_ENTRY_NOTE;

+			}

+

+			if (mask & XM_ENTRY_INSTRUMENT) {

+				entry->instrument = buffer[pos++]; /* 1-128 */

+				entry->mask |= IT_ENTRY_INSTRUMENT;

+			}

+

+			if (mask & XM_ENTRY_VOLUME)

+				it_xm_convert_volume(buffer[pos++], entry);

+

+			effect = effectvalue = 0;

+			if (mask & XM_ENTRY_EFFECT)      effect = buffer[pos++];

+			if (mask & XM_ENTRY_EFFECTVALUE) effectvalue = buffer[pos++];

+			_dumb_it_xm_convert_effect(effect, effectvalue, entry, 0);

+

+			entry++;

+		}

+

+		channel++;

+		if (channel >= n_channels) {

+			channel = 0;

+			row++;

+			IT_SET_END_ROW(entry);

+			entry++;

+		}

+	}

+

+	while (row < pattern->n_rows)

+	{

+		row++;

+		IT_SET_END_ROW(entry);

+		entry++;

+	}

+

+	return 0;

+}

+

+

+

+static int it_xm_make_envelope(IT_ENVELOPE *envelope, const unsigned short *data, int y_offset)

+{

+	int i, pos;

+

+	if (envelope->n_nodes > 12) {

+		/* XXX

+		TRACE("XM error: wrong number of envelope nodes (%d)\n", envelope->n_nodes);

+		envelope->n_nodes = 0;

+		return -1; */

+		envelope->n_nodes = 12;

+	}

+

+	if (envelope->sus_loop_start >= 12) envelope->flags &= ~IT_ENVELOPE_SUSTAIN_LOOP;

+	if (envelope->loop_end >= 12) envelope->loop_end = 0;

+	if (envelope->loop_start >= envelope->loop_end) envelope->flags &= ~IT_ENVELOPE_LOOP_ON;

+

+	pos = 0;

+	for (i = 0; i < envelope->n_nodes; i++) {

+		envelope->node_t[i] = data[pos++];

+		if (data[pos] > 64) {

+			TRACE("XM error: out-of-range envelope node (node_y[%d]=%d)\n", i, data[pos]);

+			envelope->n_nodes = 0;

+			return -1;

+		}

+		envelope->node_y[i] = (signed char)(data[pos++] + y_offset);

+	}

+

+	return 0;

+}

+

+

+

+static int it_xm_read_instrument(IT_INSTRUMENT *instrument, XM_INSTRUMENT_EXTRA *extra, DUMBFILE *f)

+{

+	unsigned long size, bytes_read;

+	unsigned short vol_points[24];

+	unsigned short pan_points[24];

+	int i, type;

+

+	/* Header size. Tends to be more than the actual size of the structure.

+	 * So unread bytes must be skipped before reading the first sample

+	 * header.

+	 */

+	size = dumbfile_igetl(f);

+

+	dumbfile_getnc(instrument->name, 22, f);

+	instrument->name[22] = 0;

+	instrument->filename[0] = 0;

+	dumbfile_skip(f, 1);  /* Instrument type. Should be 0, but seems random. */

+	extra->n_samples = dumbfile_igetw(f);

+

+	if (dumbfile_error(f) || (unsigned int)extra->n_samples > XM_MAX_SAMPLES_PER_INSTRUMENT)

+		return -1;

+

+	bytes_read = 4 + 22 + 1 + 2;

+

+	if (extra->n_samples) {

+		/* sample header size */

+		dumbfile_skip(f, 4); // XXX can't be trusted, as there are trackers that write the wrong value here

+		/*i = dumbfile_igetl(f);

+		if (i && i != 0x28) { // XXX some crap with 0 here

+			TRACE("XM error: unexpected sample header size\n");

+			return -1;

+		}*/

+

+		/* sample map */

+		for (i = 0; i < 96; i++) {

+			instrument->map_sample[i] = dumbfile_getc(f) + 1;

+			instrument->map_note[i] = i;

+		}

+

+		if (dumbfile_error(f))

+			return 1;

+

+		/* volume/panning envelopes */

+		for (i = 0; i < 24; i++)

+			vol_points[i] = dumbfile_igetw(f);

+		for (i = 0; i < 24; i++)

+			pan_points[i] = dumbfile_igetw(f);

+

+		instrument->volume_envelope.n_nodes = dumbfile_getc(f);

+		instrument->pan_envelope.n_nodes = dumbfile_getc(f);

+

+		if (dumbfile_error(f))

+			return -1;

+

+		instrument->volume_envelope.sus_loop_start = dumbfile_getc(f);

+		instrument->volume_envelope.loop_start = dumbfile_getc(f);

+		instrument->volume_envelope.loop_end = dumbfile_getc(f);

+

+		instrument->pan_envelope.sus_loop_start = dumbfile_getc(f);

+		instrument->pan_envelope.loop_start = dumbfile_getc(f);

+		instrument->pan_envelope.loop_end = dumbfile_getc(f);

+

+		/* The envelope handler for XM files won't use sus_loop_end. */

+

+		type = dumbfile_getc(f);

+		instrument->volume_envelope.flags = 0;

+		if ((type & XM_ENVELOPE_ON) && instrument->volume_envelope.n_nodes)

+			instrument->volume_envelope.flags |= IT_ENVELOPE_ON;

+		if (type & XM_ENVELOPE_LOOP)    instrument->volume_envelope.flags |= IT_ENVELOPE_LOOP_ON;

+#if 1

+		if (type & XM_ENVELOPE_SUSTAIN) instrument->volume_envelope.flags |= IT_ENVELOPE_SUSTAIN_LOOP;

+#else // This is now handled in itrender.c

+		/* let's avoid fading out when reaching the last envelope node */

+		if (!(type & XM_ENVELOPE_LOOP)) {

+			instrument->volume_envelope.loop_start = instrument->volume_envelope.n_nodes-1;

+			instrument->volume_envelope.loop_end = instrument->volume_envelope.n_nodes-1;

+		}

+		instrument->volume_envelope.flags |= IT_ENVELOPE_LOOP_ON;

+#endif

+

+		type = dumbfile_getc(f);

+		instrument->pan_envelope.flags = 0;

+		if ((type & XM_ENVELOPE_ON) && instrument->pan_envelope.n_nodes)

+			instrument->pan_envelope.flags |= IT_ENVELOPE_ON;

+		if (type & XM_ENVELOPE_LOOP)    instrument->pan_envelope.flags |= IT_ENVELOPE_LOOP_ON; // should this be here?

+		if (type & XM_ENVELOPE_SUSTAIN) instrument->pan_envelope.flags |= IT_ENVELOPE_SUSTAIN_LOOP;

+

+		if (it_xm_make_envelope(&instrument->volume_envelope, vol_points, 0) != 0) {

+			TRACE("XM error: volume envelope\n");

+			if (instrument->volume_envelope.flags & IT_ENVELOPE_ON) return -1;

+		}

+

+		if (it_xm_make_envelope(&instrument->pan_envelope, pan_points, -32) != 0) {

+			TRACE("XM error: pan envelope\n");

+			if (instrument->pan_envelope.flags & IT_ENVELOPE_ON) return -1;

+		}

+

+		instrument->pitch_envelope.flags = 0;

+

+		extra->vibrato_type = dumbfile_getc(f);

+		extra->vibrato_sweep = dumbfile_getc(f);

+		extra->vibrato_depth = dumbfile_getc(f);

+		extra->vibrato_speed = dumbfile_getc(f);

+

+		if (dumbfile_error(f) || extra->vibrato_type > 4) // XXX

+			return -1;

+

+		/** WARNING: lossy approximation */

+		instrument->fadeout = (dumbfile_igetw(f)*128 + 64)/0xFFF;

+

+		dumbfile_skip(f, 2); /* reserved */

+

+		bytes_read += 4 + 96 + 48 + 48 + 14*1 + 2 + 2;

+	} else

+		for (i = 0; i < 96; i++)

+			instrument->map_sample[i] = 0;

+

+	if (dumbfile_skip(f, size - bytes_read))

+		return -1;

+

+	instrument->new_note_action = NNA_NOTE_CUT;

+	instrument->dup_check_type = DCT_OFF;

+	instrument->dup_check_action = DCA_NOTE_CUT;

+	instrument->pp_separation = 0;

+	instrument->pp_centre = 60; /* C-5 */

+	instrument->global_volume = 128;

+	instrument->default_pan = 32;

+	instrument->random_volume = 0;

+	instrument->random_pan = 0;

+	instrument->filter_cutoff = 0;

+	instrument->filter_resonance = 0;

+

+	return 0;

+}

+

+

+

+/* I (entheh) have two XM files saved by a very naughty program. After a

+ * 16-bit sample, it saved a rogue byte. The length of the sample was indeed

+ * an odd number, incremented to include the rogue byte.

+ *

+ * In this function we are converting sample lengths and loop points so they

+ * are measured in samples. This means we forget about the extra bytes, and

+ * they don't get skipped. So we fail trying to read the next instrument.

+ *

+ * To get around this, this function returns the number of rogue bytes that

+ * won't be accounted for by reading sample->length samples. It returns a

+ * negative number on failure.

+ */

+static int it_xm_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f)

+{

+	int type;

+	int relative_note_number; /* relative to C4 */

+	int finetune;

+	int roguebytes;

+	int roguebytesmask;

+	int reserved;

+

+	sample->length         = dumbfile_igetl(f);

+	sample->loop_start     = dumbfile_igetl(f);

+	sample->loop_end       = sample->loop_start + dumbfile_igetl(f);

+	sample->global_volume  = 64;

+	sample->default_volume = dumbfile_getc(f);

+	finetune               = (signed char)dumbfile_getc(f); /* -128..127 <=> -1 semitone .. +127/128 of a semitone */

+	type                   = dumbfile_getc(f);

+	sample->default_pan    = dumbfile_getc(f); /* 0-255 */

+	relative_note_number   = (signed char)dumbfile_getc(f);

+

+	/*dumbfile_skip(f, 1);  /* reserved */

+	reserved = dumbfile_getc(f);

+

+	dumbfile_getnc(sample->name, 22, f);

+	sample->name[22] = 0;

+

+	sample->filename[0] = 0;

+

+	if (dumbfile_error(f))

+		return -1;

+

+	sample->C5_speed = (long)(16726.0*pow(DUMB_SEMITONE_BASE, relative_note_number) /**pow(DUMB_PITCH_BASE, )*/ );

+	sample->finetune = finetune*2;

+

+	sample->flags = IT_SAMPLE_EXISTS;

+

+	if (reserved == 0xAD &&

+		(!(type & (XM_SAMPLE_16BIT | XM_SAMPLE_STEREO))))

+	{

+		/* F U Olivier Lapicque */

+		roguebytes = 4;

+		roguebytesmask = 4 << 2;

+	}

+	else

+	{

+		roguebytes = (int)sample->length;

+		roguebytesmask = 3;

+	}

+

+	if (type & XM_SAMPLE_16BIT) {

+		sample->flags |= IT_SAMPLE_16BIT;

+		sample->length >>= 1;

+		sample->loop_start >>= 1;

+		sample->loop_end >>= 1;

+	} else

+		roguebytesmask >>= 1;

+

+	if (type & XM_SAMPLE_STEREO) {

+		sample->flags |= IT_SAMPLE_STEREO;

+		sample->length >>= 1;

+		sample->loop_start >>= 1;

+		sample->loop_end >>= 1;

+	} else

+		roguebytesmask >>= 1;

+

+	roguebytes &= roguebytesmask;

+

+	if ((unsigned int)sample->loop_start < (unsigned int)sample->loop_end) {

+		if (type & XM_SAMPLE_FORWARD_LOOP) sample->flags |= IT_SAMPLE_LOOP;

+		if (type & XM_SAMPLE_PINGPONG_LOOP) sample->flags |= IT_SAMPLE_LOOP | IT_SAMPLE_PINGPONG_LOOP;

+	}

+

+	if (sample->length <= 0)

+		sample->flags &= ~IT_SAMPLE_EXISTS;

+	else if ((unsigned int)sample->loop_end > (unsigned int)sample->length)

+		sample->flags &= ~IT_SAMPLE_LOOP;

+	else if ((unsigned int)sample->loop_start >= (unsigned int)sample->loop_end)

+		sample->flags &= ~IT_SAMPLE_LOOP;

+

+	return roguebytes;

+}

+

+

+

+static int it_xm_read_sample_data(IT_SAMPLE *sample, unsigned char roguebytes, DUMBFILE *f)

+{

+	int old;

+	long i;

+	long truncated_size;

+	int n_channels;

+	long datasize;

+

+	if (!(sample->flags & IT_SAMPLE_EXISTS))

+		return dumbfile_skip(f, roguebytes);

+

+	/* let's get rid of the sample data coming after the end of the loop */

+	if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length && roguebytes != 4) {

+		truncated_size = sample->length - sample->loop_end;

+		sample->length = sample->loop_end;

+	} else {

+		truncated_size = 0;

+	}

+

+	n_channels = sample->flags & IT_SAMPLE_STEREO ? 2 : 1;

+	datasize = sample->length * n_channels;

+

+	sample->data = malloc(datasize * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1));

+	if (!sample->data)

+		return -1;

+

+	if (roguebytes == 4)

+	{

+		if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0)

+			return -1;

+		roguebytes = 0;

+	}

+	else

+	{

+		/* sample data is stored as signed delta values */

+		old = 0;

+		if (sample->flags & IT_SAMPLE_16BIT)

+			for (i = 0; i < sample->length; i++)

+				((short *)sample->data)[i*n_channels] = old += dumbfile_igetw(f);

+		else

+			for (i = 0; i < sample->length; i++)

+				((signed char *)sample->data)[i*n_channels] = old += dumbfile_getc(f);

+	}

+

+	/* skip truncated data */

+	dumbfile_skip(f, (sample->flags & IT_SAMPLE_16BIT) ? (2*truncated_size) : (truncated_size));

+

+	if (sample->flags & IT_SAMPLE_STEREO) {

+		old = 0;

+		if (sample->flags & IT_SAMPLE_16BIT)

+			for (i = 1; i < datasize; i += 2)

+				((short *)sample->data)[i] = old += dumbfile_igetw(f);

+		else

+			for (i = 1; i < datasize; i += 2)

+				((signed char *)sample->data)[i] = old += dumbfile_getc(f);

+

+		/* skip truncated data */

+		dumbfile_skip(f, (sample->flags & IT_SAMPLE_16BIT) ? (2*truncated_size) : (truncated_size));

+	}

+

+	dumbfile_skip(f, roguebytes);

+

+	if (dumbfile_error(f))

+		return -1;

+

+	return 0;

+}

+

+

+

+/* "Real programmers don't document. If it was hard to write,

+ *  it should be hard to understand."

+ *

+ * (Never trust the documentation provided with a tracker.

+ *  Real files are the only truth...)

+ */

+static DUMB_IT_SIGDATA *it_xm_load_sigdata(DUMBFILE *f, int * version)

+{

+	DUMB_IT_SIGDATA *sigdata;

+	char id_text[18];

+

+	int header_size;

+	int flags;

+	int n_channels;

+	int total_samples;

+	int i, j;

+

+	/* check ID text */

+	if (dumbfile_getnc(id_text, 17, f) < 17)

+		return NULL;

+	id_text[17] = 0;

+	if (strcmp(id_text, "Extended Module: ") != 0) {

+		TRACE("XM error: Not an Extended Module\n");

+		return NULL;

+	}

+

+	sigdata = malloc(sizeof(*sigdata));

+	if (!sigdata)

+		return NULL;

+

+	/* song name */

+	if (dumbfile_getnc(sigdata->name, 20, f) < 20) {

+		free(sigdata);

+		return NULL;

+	}

+	sigdata->name[20] = 0;

+

+	if (dumbfile_getc(f) != 0x1A) {

+		TRACE("XM error: 0x1A not found\n");

+		free(sigdata);

+		return NULL;

+	}

+

+	/* tracker name */

+	if (dumbfile_skip(f, 20)) {

+		free(sigdata);

+		return NULL;

+	}

+

+	/* version number */

+	* version = dumbfile_igetw(f);

+	if (* version > 0x0104 || * version < 0x0102) {

+		TRACE("XM error: wrong format version\n");

+		free(sigdata);

+		return NULL;

+	}

+

+	/*

+		------------------

+		---   Header   ---

+		------------------

+	*/

+

+	/* header size */

+	header_size = dumbfile_igetl(f);

+	if (header_size < (4 + 2*8 + 1) || header_size > 0x114) {

+		TRACE("XM error: unexpected header size\n");

+		free(sigdata);

+		return NULL;

+	}

+

+	sigdata->song_message = NULL;

+	sigdata->order = NULL;

+	sigdata->instrument = NULL;

+	sigdata->sample = NULL;

+	sigdata->pattern = NULL;

+	sigdata->midi = NULL;

+	sigdata->checkpoint = NULL;

+

+	sigdata->n_samples        = 0;

+	sigdata->n_orders         = dumbfile_igetw(f);

+	sigdata->restart_position = dumbfile_igetw(f);

+	n_channels                = dumbfile_igetw(f); /* max 32 but we'll be lenient */

+	sigdata->n_pchannels      = n_channels;

+	sigdata->n_patterns       = dumbfile_igetw(f);

+	sigdata->n_instruments    = dumbfile_igetw(f); /* max 128 */ /* XXX upped to 256 */

+	flags                     = dumbfile_igetw(f);

+	sigdata->speed            = dumbfile_igetw(f);

+	if (sigdata->speed == 0) sigdata->speed = 6; // Should we? What about tempo?

+	sigdata->tempo            = dumbfile_igetw(f);

+

+	/* sanity checks */

+	// XXX

+	i = header_size - 4 - 2 * 8; /* Maximum number of orders expected */

+	if (dumbfile_error(f) || sigdata->n_orders <= 0 || sigdata->n_orders > i || sigdata->n_patterns > 256 || sigdata->n_instruments > 256 || n_channels > DUMB_IT_N_CHANNELS) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	//if (sigdata->restart_position >= sigdata->n_orders)

+		//sigdata->restart_position = 0;

+

+	/* order table */

+	sigdata->order = malloc(sigdata->n_orders*sizeof(*sigdata->order));

+	if (!sigdata->order) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+	dumbfile_getnc(sigdata->order, sigdata->n_orders, f);

+	dumbfile_skip(f, i - sigdata->n_orders);

+

+	if (dumbfile_error(f)) {

+		_dumb_it_unload_sigdata(sigdata);

+		return NULL;

+	}

+

+	if ( * version > 0x103 ) {

+		/*

+			--------------------

+			---   Patterns   ---

+			--------------------

+		*/

+

+		sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));

+		if (!sigdata->pattern) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		for (i = 0; i < sigdata->n_patterns; i++)

+			sigdata->pattern[i].entry = NULL;

+

+		{

+			unsigned char *buffer = malloc(1280 * n_channels); /* 256 rows * 5 bytes */

+			if (!buffer) {

+				_dumb_it_unload_sigdata(sigdata);

+				return NULL;

+			}

+			for (i = 0; i < sigdata->n_patterns; i++) {

+				if (it_xm_read_pattern(&sigdata->pattern[i], f, n_channels, buffer, * version) != 0) {

+					free(buffer);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+			}

+			free(buffer);

+		}

+

+		/*

+		-----------------------------------

+		---   Instruments and Samples   ---

+		-----------------------------------

+		*/

+

+		sigdata->instrument = malloc(sigdata->n_instruments * sizeof(*sigdata->instrument));

+		if (!sigdata->instrument) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+

+		/* With XM, samples are not global, they're part of an instrument. In a

+		* file, each instrument is stored with its samples. Because of this, I

+		* don't know how to find how many samples are present in the file. Thus

+		* I have to do n_instruments reallocation on sigdata->sample.

+		* Looking at FT2, it doesn't seem possible to have more than 16 samples

+		* per instrument (even though n_samples is stored as 2 bytes). So maybe

+		* we could allocate a 128*16 array of samples, and shrink it back to the

+		* correct size when we know it?

+		* Alternatively, I could allocate samples by blocks of N (still O(n)),

+		* or double the number of allocated samples when I need more (O(log n)).

+		*/

+		total_samples = 0;

+		sigdata->sample = NULL;

+

+		for (i = 0; i < sigdata->n_instruments; i++) {

+			XM_INSTRUMENT_EXTRA extra;

+

+			if (it_xm_read_instrument(&sigdata->instrument[i], &extra, f) < 0) {

+				// XXX

+				if ( ! i )

+				{

+					TRACE("XM error: instrument %d\n", i+1);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+				else

+				{

+					sigdata->n_instruments = i;

+					break;

+				}

+			}

+

+			if (extra.n_samples) {

+				unsigned char roguebytes[XM_MAX_SAMPLES_PER_INSTRUMENT];

+

+				/* adjust instrument sample map (make indices absolute) */

+				for (j = 0; j < 96; j++)

+					sigdata->instrument[i].map_sample[j] += total_samples;

+

+				sigdata->sample = safe_realloc(sigdata->sample, sizeof(*sigdata->sample)*(total_samples+extra.n_samples));

+				if (!sigdata->sample) {

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+				for (j = total_samples; j < total_samples+extra.n_samples; j++)

+					sigdata->sample[j].data = NULL;

+

+				/* read instrument's samples */

+				for (j = 0; j < extra.n_samples; j++) {

+					IT_SAMPLE *sample = &sigdata->sample[total_samples+j];

+					int b = it_xm_read_sample_header(sample, f);

+					if (b < 0) {

+						_dumb_it_unload_sigdata(sigdata);

+						return NULL;

+					}

+					roguebytes[j] = b;

+					// Any reason why these can't be set inside it_xm_read_sample_header()?

+					sample->vibrato_speed = extra.vibrato_speed;

+					sample->vibrato_depth = extra.vibrato_depth;

+					sample->vibrato_rate = extra.vibrato_sweep;

+					/* Rate and sweep don't match, but the difference is

+					* accounted for in itrender.c.

+				 */

+					sample->vibrato_waveform = xm_convert_vibrato[extra.vibrato_type];

+					sample->max_resampling_quality = -1;

+				}

+				for (j = 0; j < extra.n_samples; j++) {

+					if (it_xm_read_sample_data(&sigdata->sample[total_samples+j], roguebytes[j], f) != 0) {

+						_dumb_it_unload_sigdata(sigdata);

+						return NULL;

+					}

+				}

+				total_samples += extra.n_samples;

+			}

+		}

+

+		sigdata->n_samples = total_samples;

+	} else {

+		// ahboy! old layout!

+		// first instruments and sample headers, then patterns, then sample data!

+

+		/*

+		-----------------------------------

+		---   Instruments and Samples   ---

+		-----------------------------------

+		*/

+

+		unsigned char * roguebytes = malloc( sigdata->n_instruments * XM_MAX_SAMPLES_PER_INSTRUMENT );

+		if (!roguebytes) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+

+		sigdata->instrument = malloc(sigdata->n_instruments * sizeof(*sigdata->instrument));

+		if (!sigdata->instrument) {

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+

+		total_samples = 0;

+		sigdata->sample = NULL;

+

+		for (i = 0; i < sigdata->n_instruments; i++) {

+			XM_INSTRUMENT_EXTRA extra;

+

+			if (it_xm_read_instrument(&sigdata->instrument[i], &extra, f) < 0) {

+				TRACE("XM error: instrument %d\n", i+1);

+				free(roguebytes);

+				_dumb_it_unload_sigdata(sigdata);

+				return NULL;

+			}

+

+			if (extra.n_samples) {

+				/* adjust instrument sample map (make indices absolute) */

+				for (j = 0; j < 96; j++)

+					sigdata->instrument[i].map_sample[j] += total_samples;

+

+				sigdata->sample = safe_realloc(sigdata->sample, sizeof(*sigdata->sample)*(total_samples+extra.n_samples));

+				if (!sigdata->sample) {

+					free(roguebytes);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+				for (j = total_samples; j < total_samples+extra.n_samples; j++)

+					sigdata->sample[j].data = NULL;

+

+				/* read instrument's samples */

+				for (j = 0; j < extra.n_samples; j++) {

+					IT_SAMPLE *sample = &sigdata->sample[total_samples+j];

+					int b = it_xm_read_sample_header(sample, f);

+					if (b < 0) {

+						free(roguebytes);

+						_dumb_it_unload_sigdata(sigdata);

+						return NULL;

+					}

+					roguebytes[total_samples+j] = b;

+					// Any reason why these can't be set inside it_xm_read_sample_header()?

+					sample->vibrato_speed = extra.vibrato_speed;

+					sample->vibrato_depth = extra.vibrato_depth;

+					sample->vibrato_rate = extra.vibrato_sweep;

+					/* Rate and sweep don't match, but the difference is

+					* accounted for in itrender.c.

+				 */

+					sample->vibrato_waveform = xm_convert_vibrato[extra.vibrato_type];

+					sample->max_resampling_quality = -1;

+				}

+				total_samples += extra.n_samples;

+			}

+		}

+

+		sigdata->n_samples = total_samples;

+

+		/*

+			--------------------

+			---   Patterns   ---

+			--------------------

+		*/

+

+		sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));

+		if (!sigdata->pattern) {

+			free(roguebytes);

+			_dumb_it_unload_sigdata(sigdata);

+			return NULL;

+		}

+		for (i = 0; i < sigdata->n_patterns; i++)

+			sigdata->pattern[i].entry = NULL;

+

+		{

+			unsigned char *buffer = malloc(1280 * n_channels); /* 256 rows * 5 bytes */

+			if (!buffer) {

+				free(roguebytes);

+				_dumb_it_unload_sigdata(sigdata);

+				return NULL;

+			}

+			for (i = 0; i < sigdata->n_patterns; i++) {

+				if (it_xm_read_pattern(&sigdata->pattern[i], f, n_channels, buffer, * version) != 0) {

+					free(buffer);

+					free(roguebytes);

+					_dumb_it_unload_sigdata(sigdata);

+					return NULL;

+				}

+			}

+			free(buffer);

+		}

+

+		// and now we load the sample data

+		for (j = 0; j < total_samples; j++) {

+			if (it_xm_read_sample_data(&sigdata->sample[j], roguebytes[j], f) != 0) {

+				free(roguebytes);

+				_dumb_it_unload_sigdata(sigdata);

+				return NULL;

+			}

+		}

+

+		free(roguebytes);

+	}

+

+

+	sigdata->flags = IT_WAS_AN_XM | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_STEREO | IT_USE_INSTRUMENTS;

+	// Are we OK with IT_COMPATIBLE_GXX off?

+	//

+	// When specifying note + instr + tone portamento, and an old note is still playing (even after note off):

+	// - If Compatible Gxx is on, the new note will be triggered only if the instrument _changes_.

+	// - If Compatible Gxx is off, the new note will always be triggered, provided the instrument is specified.

+	// - FT2 seems to do the latter (unconfirmed).

+

+	// Err, wait. XM playback has its own code. The change made to the IT

+	// playbackc code didn't affect XM playback. Forget this then. There's

+	// still a bug in XM playback though, and it'll need some investigation...

+	// tomorrow...

+

+	// UPDATE: IT_COMPATIBLE_GXX is required to be on, so that tone porta has

+	// separate memory from portamento.

+

+	if (flags & XM_LINEAR_FREQUENCY)

+		sigdata->flags |= IT_LINEAR_SLIDES;

+

+	sigdata->global_volume = 128;

+	sigdata->mixing_volume = 48;

+	sigdata->pan_separation = 128;

+

+	memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);

+	memset(sigdata->channel_pan, 32, DUMB_IT_N_CHANNELS);

+

+	_dumb_it_fix_invalid_orders(sigdata);

+

+	return sigdata;

+}

+

+

+

+#if 0 // no fucking way, dude!

+

+/* The length returned is the time required to play from the beginning of the

+ * file to the last row of the last order (which is when the player will

+ * loop). Depending on the song, the sound might stop sooner.

+ * Due to fixed point roundoffs, I think this is only reliable to the second.

+ * Full precision could be achieved by using a double during the computation,

+ * or maybe a LONG_LONG.

+ */

+long it_compute_length(const DUMB_IT_SIGDATA *sigdata)

+{

+	IT_PATTERN *pattern;

+	int tempo, speed;

+	int loop_start[IT_N_CHANNELS];

+	char loop_count[IT_N_CHANNELS];

+	int order, entry;

+	int row_first_entry = 0;

+	int jump, jump_dest;

+	int delay, fine_delay;

+	int i;

+	long t;

+

+	if (!sigdata)

+		return 0;

+

+	tempo = sigdata->tempo;

+	speed = sigdata->speed;

+	order = entry = 0;

+	jump = jump_dest = 0;

+	t = 0;

+

+	/* for each PATTERN */

+	for (order = 0; order < sigdata->n_orders; order++) {

+

+		if (sigdata->order[order] == IT_ORDER_END) break;

+		if (sigdata->order[order] == IT_ORDER_SKIP) continue;

+

+		for (i = 0; i < IT_N_CHANNELS; i++)

+			loop_count[i] = -1;

+

+		pattern = &sigdata->pattern[ sigdata->order[order] ];

+		entry = 0;

+		if (jump == IT_BREAK_TO_ROW) {

+			int row = 0;

+			while (row < jump_dest)

+				if (pattern->entry[entry++].channel >= IT_N_CHANNELS)

+					row++;

+		}

+

+		/* for each ROW */

+		while (entry < pattern->n_entries) {

+			row_first_entry = entry;

+			delay = fine_delay = 0;

+			jump = 0;

+

+			/* for each note NOTE */

+			while (entry < pattern->n_entries && pattern->entry[entry].channel < IT_N_CHANNELS) {

+				int value   = pattern->entry[entry].effectvalue;

+				int channel = pattern->entry[entry].channel;

+

+				switch (pattern->entry[entry].effect) {

+

+					case IT_SET_SPEED: speed = value; break;

+

+					case IT_JUMP_TO_ORDER:

+						if (value <= order) /* infinite loop */

+							return 0;

+						jump = IT_JUMP_TO_ORDER;

+						jump_dest = value;

+						break;

+

+					case IT_BREAK_TO_ROW:

+						jump = IT_BREAK_TO_ROW;

+						jump_dest = value;

+						break;

+

+					case IT_S:

+						switch (HIGH(value)) {

+							case IT_S_PATTERN_DELAY:      delay      = LOW(value); break;

+							case IT_S_FINE_PATTERN_DELAY: fine_delay = LOW(value); break;

+							case IT_S_PATTERN_LOOP:

+								if (LOW(value) == 0) {

+									loop_start[channel] = row_first_entry;

+								} else {

+									if (loop_count[channel] == -1)

+										loop_count[channel] = LOW(value);

+

+									if (loop_count[channel]) {

+										jump = IT_S_PATTERN_LOOP;

+										jump_dest = loop_start[channel];

+									}

+									loop_count[channel]--;

+								}

+								break;

+						}

+						break;

+

+					case IT_SET_SONG_TEMPO:

+						switch (HIGH(value)) { /* slides happen every non-row frames */

+							case 0:  tempo = tempo - LOW(value)*(speed-1); break;

+							case 1:  tempo = tempo + LOW(value)*(speed-1); break;

+							default: tempo = value;

+						}

+						tempo = MID(32, tempo, 255);

+						break;

+				}

+

+				entry++;

+			}

+

+			/* end of ROW */

+			entry++;

+			t += TICK_TIME_DIVIDEND * (speed*(1+delay) + fine_delay) / tempo;

+

+			if (jump == IT_JUMP_TO_ORDER) {

+				order = jump_dest - 1;

+				break;

+			} else if (jump == IT_BREAK_TO_ROW)

+				break;

+			else if (jump == IT_S_PATTERN_LOOP)

+				entry = jump_dest - 1;

+		}

+

+		/* end of PATTERN */

+	}

+

+	return t;

+}

+

+#endif /* 0 */

+

+

+static char hexdigit(int in)

+{

+	if (in < 10) return in + '0';

+	else return in + 'A' - 10;

+}

+

+DUH *dumb_read_xm_quick(DUMBFILE *f)

+{

+	sigdata_t *sigdata;

+	int ver;

+

+	DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;

+

+	sigdata = it_xm_load_sigdata(f, &ver);

+

+	if (!sigdata)

+		return NULL;

+

+	{

+		char version[16];

+		const char *tag[2][2];

+		tag[0][0] = "TITLE";

+		tag[0][1] = ((DUMB_IT_SIGDATA *)sigdata)->name;

+		tag[1][0] = "FORMAT";

+		version[0] = 'X';

+		version[1] = 'M';

+		version[2] = ' ';

+		version[3] = 'v';

+		version[4] = hexdigit( ( ver >> 8 ) & 15 );

+		version[5] = '.';

+		version[6] = hexdigit( ( ver >> 4 ) & 15 );

+		version[7] = hexdigit( ver & 15 );

+		version[8] = 0;

+		tag[1][1] = ( const char * ) & version;

+		return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/readxm2.c b/plugins/dumb/dumb-kode54/src/it/readxm2.c
new file mode 100644
index 00000000..c79f753f
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/readxm2.c
@@ -0,0 +1,29 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * readxm2.c - Function to read a Fast Tracker II     / / \  \

+ *             module from an open file and do an    | <  /   \_

+ *             initial run-through.                  |  \/ /\   /

+ *                                                    \_  /  > /

+ * Split off from readxm.c by entheh.                   | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include "dumb.h"

+

+

+

+DUH *dumb_read_xm(DUMBFILE *f)

+{

+	DUH *duh = dumb_read_xm_quick(f);

+	dumb_it_do_initial_runthrough(duh);

+	return duh;

+}

diff --git a/plugins/dumb/dumb-kode54/src/it/xmeffect.c b/plugins/dumb/dumb-kode54/src/it/xmeffect.c
new file mode 100644
index 00000000..2187a0b3
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/it/xmeffect.c
@@ -0,0 +1,243 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * xmeffect.c - Code for converting MOD/XM            / / \  \

+ *              effects to IT effects.               | <  /   \_

+ *                                                   |  \/ /\   /

+ * By Julien Cugniere. Ripped out of readxm.c         \_  /  > /

+ * by entheh.                                           | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+#include "internal/it.h"

+

+#if 0

+unsigned char **_dumb_malloc2(int w, int h)

+{

+	unsigned char **line =  malloc(h * sizeof(*line));

+	int i;

+	if (!line) return NULL;

+

+	line[0] = malloc(w * h * sizeof(*line[0]));

+	if (!line[0]) {

+		free(line);

+		return NULL;

+	}

+

+	for (i = 1; i < h; i++)

+		line[i] = line[i-1] + w;

+

+	memset(line[0], 0, w*h);

+

+	return line;

+}

+

+

+

+void _dumb_free2(unsigned char **line)

+{

+	if (line) {

+		if (line[0])

+			free(line[0]);

+		free(line);

+	}

+}

+

+

+

+/* Effects having a memory. 2 means that the two parts of the effectvalue

+ * should be handled separately.

+ */

+static const char xm_has_memory[] = {

+/*	0  1  2  3  4  5  6  7  8  9  A  B  C  D (E) F  G  H        K  L           P     R     T          (X) */

+	0, 1, 1, 1, 2, 1, 1, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0,

+

+/*  E0 E1 E2 E3 E4 E5 E6 E7    E9 EA EB EC ED EE         X1 X2 */

+	0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0,   0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

+};

+#endif

+

+

+

+/* Effects marked with 'special' are handled specifically in itrender.c */

+void _dumb_it_xm_convert_effect(int effect, int value, IT_ENTRY *entry, int mod)

+{

+const int log = 0;

+

+	if ((!effect && !value) || (effect >= XM_N_EFFECTS))

+		return;

+

+if (log) printf("%c%02X", (effect<10)?('0'+effect):('A'+effect-10), value);

+

+	/* Linearisation of the effect number... */

+	if (effect == XM_E) {

+		effect = EBASE + HIGH(value);

+		value = LOW(value);

+	} else if (effect == XM_X) {

+		effect = XBASE + HIGH(value);

+		value = LOW(value);

+	}

+

+if (log) printf(" - %2d %02X", effect, value);

+

+#if 0 // This should be handled in itrender.c!

+	/* update effect memory */

+	switch (xm_has_memory[effect]) {

+		case 1:

+			if (!value)

+				value = memory[entry->channel][effect];

+			else

+				memory[entry->channel][effect] = value;

+			break;

+

+		case 2:

+			if (!HIGH(value))

+				SET_HIGH(value, HIGH(memory[entry->channel][effect]));

+			else

+				SET_HIGH(memory[entry->channel][effect], HIGH(value));

+

+			if (!LOW(value))

+				SET_LOW(value, LOW(memory[entry->channel][effect]));

+			else

+				SET_LOW(memory[entry->channel][effect], LOW(value));

+			break;

+	}

+#endif

+

+	/* convert effect */

+	entry->mask |= IT_ENTRY_EFFECT;

+	switch (effect) {

+

+		case XM_APPREGIO:           effect = IT_ARPEGGIO;           break;

+		case XM_VIBRATO:            effect = IT_VIBRATO;            break;

+		case XM_TONE_PORTAMENTO:    effect = IT_TONE_PORTAMENTO;    break;

+		case XM_TREMOLO:            effect = IT_TREMOLO;            break;

+		case XM_SET_PANNING:        effect = IT_SET_PANNING;        break;

+		case XM_SAMPLE_OFFSET:      effect = IT_SET_SAMPLE_OFFSET;  break;

+		case XM_POSITION_JUMP:      effect = IT_JUMP_TO_ORDER;      break;

+		case XM_MULTI_RETRIG:       effect = IT_RETRIGGER_NOTE;     break;

+		case XM_TREMOR:             effect = IT_TREMOR;             break;

+		case XM_PORTAMENTO_UP:      effect = IT_XM_PORTAMENTO_UP;   break;

+		case XM_PORTAMENTO_DOWN:    effect = IT_XM_PORTAMENTO_DOWN; break;

+		case XM_SET_CHANNEL_VOLUME: effect = IT_SET_CHANNEL_VOLUME; break; /* special */

+		case XM_VOLSLIDE_TONEPORTA: effect = IT_VOLSLIDE_TONEPORTA; break; /* special */

+		case XM_VOLSLIDE_VIBRATO:   effect = IT_VOLSLIDE_VIBRATO;   break; /* special */

+

+		case XM_PATTERN_BREAK:

+			effect = IT_BREAK_TO_ROW;

+			value = BCD_TO_NORMAL(value);

+			if (value > 63) value = 0; /* FT2, maybe ProTracker? */

+			break;

+

+		case XM_VOLUME_SLIDE: /* special */

+			effect = IT_VOLUME_SLIDE;

+			value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value));

+			break;

+

+		case XM_PANNING_SLIDE:

+			effect = IT_PANNING_SLIDE;

+			//value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value));

+			value = HIGH(value) ? EFFECT_VALUE(0, HIGH(value)) : EFFECT_VALUE(LOW(value), 0);

+			break;

+

+		case XM_GLOBAL_VOLUME_SLIDE: /* special */

+			effect = IT_GLOBAL_VOLUME_SLIDE;

+			value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value));

+			break;

+

+		case XM_SET_TEMPO_BPM:

+			if (mod) effect = (value <= 0x20) ? (IT_SET_SPEED) : (IT_SET_SONG_TEMPO);

+			else effect = (value < 0x20) ? (IT_SET_SPEED) : (IT_SET_SONG_TEMPO);

+			break;

+

+		case XM_SET_GLOBAL_VOLUME:

+			effect = IT_SET_GLOBAL_VOLUME;

+			value *= 2;

+			break;

+

+		case XM_KEY_OFF:

+			effect = IT_XM_KEY_OFF;

+			break;

+

+		case XM_SET_ENVELOPE_POSITION:

+			effect = IT_XM_SET_ENVELOPE_POSITION;

+			break;

+

+		case EBASE+XM_E_SET_FILTER:            effect = SBASE+IT_S_SET_FILTER;            break;

+		case EBASE+XM_E_SET_GLISSANDO_CONTROL: effect = SBASE+IT_S_SET_GLISSANDO_CONTROL; break; /** TODO */

+		case EBASE+XM_E_SET_FINETUNE:          effect = SBASE+IT_S_FINETUNE;              break;

+		case EBASE+XM_E_SET_LOOP:              effect = SBASE+IT_S_PATTERN_LOOP;          break;

+		case EBASE+XM_E_NOTE_CUT:              effect = SBASE+IT_S_DELAYED_NOTE_CUT;      break;

+		case EBASE+XM_E_NOTE_DELAY:            effect = SBASE+IT_S_NOTE_DELAY;            break;

+		case EBASE+XM_E_PATTERN_DELAY:         effect = SBASE+IT_S_PATTERN_DELAY;         break;

+		case EBASE+XM_E_SET_PANNING:           effect = SBASE+IT_S_SET_PAN;               break;

+		case EBASE+XM_E_FINE_VOLSLIDE_UP:      effect = IT_XM_FINE_VOLSLIDE_UP;           break;

+		case EBASE+XM_E_FINE_VOLSLIDE_DOWN:    effect = IT_XM_FINE_VOLSLIDE_DOWN;         break;

+

+		case EBASE + XM_E_FINE_PORTA_UP:

+			effect = IT_PORTAMENTO_UP;

+			value = EFFECT_VALUE(0xF, value);

+			break;

+

+		case EBASE + XM_E_FINE_PORTA_DOWN:

+			effect = IT_PORTAMENTO_DOWN;

+			value = EFFECT_VALUE(0xF, value);

+			break;

+

+		case EBASE + XM_E_RETRIG_NOTE:

+			effect = IT_XM_RETRIGGER_NOTE;

+			value = EFFECT_VALUE(0, value);

+			break;

+

+		case EBASE + XM_E_SET_VIBRATO_CONTROL:

+			effect = SBASE+IT_S_SET_VIBRATO_WAVEFORM;

+			value &= ~4;

+			break;

+

+		case EBASE + XM_E_SET_TREMOLO_CONTROL:

+			effect = SBASE+IT_S_SET_TREMOLO_WAVEFORM;

+			value &= ~4;

+			break;

+

+		case XBASE + XM_X_EXTRAFINE_PORTA_UP:

+			effect = IT_PORTAMENTO_UP;

+			value = EFFECT_VALUE(0xE, value);

+			break;

+

+		case XBASE + XM_X_EXTRAFINE_PORTA_DOWN:

+			effect = IT_PORTAMENTO_DOWN;

+			value = EFFECT_VALUE(0xE, value);

+			break;

+

+		default:

+			/* user effect (often used in demos for synchronisation) */

+			entry->mask &= ~IT_ENTRY_EFFECT;

+	}

+

+if (log) printf(" - %2d %02X", effect, value);

+

+	/* Inverse linearisation... */

+	if (effect >= SBASE && effect < SBASE+16) {

+		value = EFFECT_VALUE(effect-SBASE, value);

+		effect = IT_S;

+	}

+

+if (log) printf(" - %c%02X\n", 'A'+effect-1, value);

+

+	entry->effect = effect;

+	entry->effectvalue = value;

+}

diff --git a/plugins/dumb/dumb-kode54/src/sigtypes/combine.c b/plugins/dumb/dumb-kode54/src/sigtypes/combine.c
new file mode 100644
index 00000000..497f085c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/sigtypes/combine.c
@@ -0,0 +1,243 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * combine.c - The combining (COMB) signal type.      / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ * This takes multiple monaural signals and             | \ / /

+ * combines them into a single multichannel             |  ' /

+ * signal. It assumes the correct number of              \__/

+ * channels is passed. An ASSERT() is in place

+ * to check the number of channels when you

+ * compile with -DDEBUGMODE. As an exception, if one channel is passed the

+ * signals are all mixed together.

+ */

+

+#include <stdlib.h>

+

+#include "dumb.h"

+

+

+

+#define SIGTYPE_COMBINING DUMB_ID('C','O','M','B')

+

+

+

+typedef struct COMBINING_SIGNAL

+{

+	int n_signals;

+	int sig[ZERO_SIZE];

+}

+COMBINING_SIGNAL;

+

+

+

+typedef struct COMBINING_SAMPINFO

+{

+	int n_signals;

+	int downmix;

+	DUH_SIGNAL_SAMPINFO *csampinfo[ZERO_SIZE];

+}

+COMBINING_SAMPINFO;

+

+

+

+static void *combining_load_signal(DUH *duh, DUMBFILE *file)

+{

+	COMBINING_SIGNAL *signal;

+	int n_signals;

+

+	(void)duh;

+

+	n_signals = dumbfile_getc(file);

+

+	/* No point in combining only one signal! */

+	if (dumbfile_error(file) || n_signals <= 1)

+		return NULL;

+

+	signal = malloc(sizeof(*signal) + n_signals * sizeof(*signal->sig));

+	if (!signal)

+		return NULL;

+

+	signal->n_signals = n_signals;

+

+	{

+		int n;

+		for (n = 0; n < signal->n_signals; n++) {

+			signal->sig[n] = dumbfile_igetl(file);

+			if (dumbfile_error(file)) {

+				free(signal);

+				return NULL;

+			}

+		}

+	}

+

+	return signal;

+}

+

+

+

+static void *combining_start_samples(DUH *duh, void *signal, int n_channels, long pos)

+{

+#define signal ((COMBINING_SIGNAL *)signal)

+

+	COMBINING_SAMPINFO *sampinfo;

+

+	sampinfo = malloc(sizeof(*sampinfo) + signal->n_signals * sizeof(*sampinfo->csampinfo));

+	if (!sampinfo)

+		return NULL;

+

+	sampinfo->n_signals = signal->n_signals;

+	if (n_channels == 1)

+		sampinfo->downmix = 1;

+	else if (n_channels == signal->n_signals)

+		sampinfo->downmix = 0;

+	else {

+		TRACE("Combining signal discrepancy: %d signals, %d channels.\n", signal->n_signals, n_channels);

+		free(sampinfo);

+		return NULL;

+	}

+

+	{

+		int worthwhile = 0;

+

+		{

+			int n;

+			for (n = 0; n < signal->n_signals; n++) {

+				sampinfo->csampinfo[n] = duh_signal_start_samples(duh, signal->sig[n], 1, pos);

+				if (sampinfo->csampinfo[n])

+					worthwhile = 1;

+			}

+		}

+

+		if (!worthwhile) {

+			free(sampinfo);

+			return NULL;

+		}

+	}

+

+	return sampinfo;

+

+#undef signal

+}

+

+

+

+static long combining_render_samples(

+	void *sampinfo,

+	float volume, float delta,

+	long size, sample_t **samples

+)

+{

+#define sampinfo ((COMBINING_SAMPINFO *)sampinfo)

+

+	long max_size;

+

+	int n;

+

+	if (sampinfo->downmix)

+		volume /= sampinfo->n_signals;

+

+	max_size = duh_signal_render_samples(sampinfo->csampinfo[0], volume, delta, size, samples);

+

+	if (sampinfo->downmix) {

+

+		long s;

+		long sz;

+

+		sample_t *sampbuf = malloc(size * sizeof(sample_t));

+

+		if (!sampbuf)

+			return 0;

+

+		for (n = 1; n < sampinfo->n_signals; n++) {

+			sz = duh_signal_render_samples(sampinfo->csampinfo[n], volume, delta, size, &sampbuf);

+			if (sz > max_size) {

+				for (s = max_size; s < sz; s++)

+					samples[0][s] = sampbuf[s];

+				sz = max_size;

+				max_size = s;

+			}

+			for (s = 0; s < sz; s++)

+				samples[0][s] += sampbuf[s];

+		}

+

+		free(sampbuf);

+

+	} else {

+

+		long *sz = malloc(size * sizeof(*sz));

+		long s;

+

+		if (!sz)

+			return 0;

+

+		sz[0] = max_size;

+

+		for (n = 1; n < sampinfo->n_signals; n++) {

+			sz[n] = duh_signal_render_samples(sampinfo->csampinfo[n], volume, delta, size, samples + n);

+			if (sz[n] > max_size)

+				max_size = sz[n];

+		}

+

+		for (n = 0; n < sampinfo->n_signals; n++)

+			for (s = sz[n]; s < max_size; s++)

+				samples[n][s] = 0;

+

+		free(sz);

+

+	}

+

+	return max_size;

+

+#undef sampinfo

+}

+

+

+

+static void combining_end_samples(void *sampinfo)

+{

+#define sampinfo ((COMBINING_SAMPINFO *)sampinfo)

+

+	int n;

+

+	for (n = 0; n < sampinfo->n_signals; n++)

+		duh_signal_end_samples(sampinfo->csampinfo[n]);

+

+	free(sampinfo);

+

+#undef sampinfo

+}

+

+

+

+static void combining_unload_signal(void *signal)

+{

+	free(signal);

+}

+

+

+

+static DUH_SIGTYPE_DESC sigtype_combining = {

+	SIGTYPE_COMBINING,

+	&combining_load_signal,

+	&combining_start_samples,

+	NULL,

+	&combining_render_samples,

+	&combining_end_samples,

+	&combining_unload_signal

+};

+

+

+void dumb_register_sigtype_combining(void)

+{

+	dumb_register_sigtype(&sigtype_combining);

+}

diff --git a/plugins/dumb/dumb-kode54/src/sigtypes/sample.c b/plugins/dumb/dumb-kode54/src/sigtypes/sample.c
new file mode 100644
index 00000000..4695de91
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/sigtypes/sample.c
@@ -0,0 +1,340 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * sample.c - The sample (SAMP) signal type.          / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ * This only supports monaural samples. For             | \ / /

+ * multiple channels, use multiple samples and          |  ' /

+ * a combining signal (COMB).                            \__/

+ */

+

+/* NOTE: filters need not be credited yet, as they will be moved elsewhere. */

+/** WARNING don't forget to move these filters somewhere */

+

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+

+

+/** WARNING move these things somewhere useful, for DUH writing - this applies to other signal types too */

+#define SIGTYPE_SAMPLE DUMB_ID('S','A','M','P')

+

+

+

+#define SAMPFLAG_16BIT    1 /* sample in file is 16 bit, rather than 8 bit */

+#define SAMPFLAG_LOOP     2 /* loop indefinitely */

+#define SAMPFLAG_XLOOP    4 /* loop x times; only relevant if LOOP not set */

+#define SAMPFLAG_PINGPONG 8 /* loop back and forth, if LOOP or XLOOP set */

+

+

+/* SAMPPARAM_N_LOOPS: add 'value' iterations to the loop. 'value' is assumed

+ * to be positive.

+ */

+#define SAMPPARAM_N_LOOPS 0

+

+

+

+typedef struct SAMPLE_SIGDATA

+{

+	long size;

+	int flags;

+	long loop_start;

+	long loop_end;

+	sample_t *samples;

+}

+SAMPLE_SIGDATA;

+

+

+

+typedef struct SAMPLE_SIGRENDERER

+{

+	SAMPLE_SIGDATA *sigdata;

+	int n_channels;

+	DUMB_RESAMPLER r;

+	int n_loops;

+}

+SAMPLE_SIGRENDERER;

+

+

+

+static sigdata_t *sample_load_sigdata(DUH *duh, DUMBFILE *file)

+{

+	SAMPLE_SIGDATA *sigdata;

+	long size;

+	long n;

+	int flags;

+

+	(void)duh;

+

+	size = dumbfile_igetl(file);

+

+	if (dumbfile_error(file) || size <= 0)

+		return NULL;

+

+	flags = dumbfile_getc(file);

+	if (flags < 0)

+		return NULL;

+

+	sigdata = malloc(sizeof(*sigdata));

+	if (!sigdata)

+		return NULL;

+

+	sigdata->samples = malloc(size * sizeof(sample_t));

+	if (!sigdata->samples) {

+		free(sigdata);

+		return NULL;

+	}

+

+	sigdata->size = size;

+	sigdata->flags = flags;

+

+	if (sigdata->flags & (SAMPFLAG_LOOP | SAMPFLAG_XLOOP)) {

+		sigdata->loop_start = dumbfile_igetl(file);

+

+		if (dumbfile_error(file) || (unsigned long)sigdata->loop_start >= (unsigned long)size) {

+			free(sigdata->samples);

+			free(sigdata);

+			return NULL;

+		}

+

+		if (sigdata->flags & SAMPFLAG_LOOP)

+			sigdata->loop_end = size;

+		else {

+			sigdata->loop_end = dumbfile_igetl(file);

+

+			if (dumbfile_error(file) || sigdata->loop_end <= sigdata->loop_start || sigdata->loop_end > size) {

+				free(sigdata->samples);

+				free(sigdata);

+				return NULL;

+			}

+		}

+	} else {

+		sigdata->loop_start = 0;

+		sigdata->loop_end = size;

+	}

+

+	if (sigdata->flags & SAMPFLAG_16BIT) {

+		for (n = 0; n < size; n++) {

+			int m = dumbfile_igetw(file);

+			if (m < 0) {

+				free(sigdata->samples);

+				free(sigdata);

+				return NULL;

+			}

+			sigdata->samples[n] = (int)(signed short)m << 8;

+		}

+	} else {

+		for (n = 0; n < size; n++) {

+			int m = dumbfile_getc(file);

+			if (m < 0) {

+				free(sigdata->samples);

+				free(sigdata);

+				return NULL;

+			}

+			sigdata->samples[n] = (int)(signed char)m << 16;

+		}

+	}

+

+	return sigdata;

+}

+

+

+

+static void sample_pickup(DUMB_RESAMPLER *r, void *data)

+{

+	SAMPLE_SIGRENDERER *sigrenderer = data;

+

+	if (!(sigrenderer->sigdata->flags & (SAMPFLAG_LOOP | SAMPFLAG_XLOOP))) {

+		r->dir = 0;

+		return;

+	}

+

+	if (!(sigrenderer->sigdata->flags & SAMPFLAG_LOOP) && sigrenderer->n_loops == 0) {

+		r->dir = 0;

+		return;

+	}

+

+	if (sigrenderer->sigdata->flags & SAMPFLAG_PINGPONG) {

+		if (r->dir < 0) {

+			r->pos = (r->start << 1) - 1 - r->pos;

+			r->subpos ^= 65535;

+			r->dir = 1;

+		} else {

+			r->pos = (r->end << 1) - 1 - r->pos;

+			r->subpos ^= 65535;

+			r->dir = -1;

+		}

+	} else

+		r->pos -= r->end - r->start;

+

+	if (!(sigrenderer->sigdata->flags & SAMPFLAG_LOOP)) {

+		if (sigrenderer->n_loops > 0) {

+			sigrenderer->n_loops--;

+			if (sigrenderer->n_loops == 0) {

+				r->start = 0;

+				r->end = sigrenderer->sigdata->size;

+			}

+		}

+	}

+}

+

+

+

+static sigrenderer_t *sample_start_sigrenderer(DUH *duh, sigdata_t *data, int n_channels, long pos)

+{

+	SAMPLE_SIGDATA *sigdata = data;

+	SAMPLE_SIGRENDERER *sigrenderer;

+

+	(void)duh;

+

+	sigrenderer = malloc(sizeof(*sigrenderer));

+	if (!sigrenderer) return NULL;

+

+	sigrenderer->sigdata = data;

+	sigrenderer->n_channels = n_channels;

+	dumb_reset_resampler(&sigrenderer->r, sigdata->samples, pos, 0, sigdata->size);

+	sigrenderer->r.pickup = &sample_pickup;

+	sigrenderer->r.pickup_data = sigrenderer;

+	sigrenderer->n_loops = 0;

+

+	return sigrenderer;

+}

+

+

+

+#if 0

+/* The name says it all ;-) */

+static void sample_cheap_low_pass_filter(sample *src, long size, float max_freq) {

+

+	long i;

+	float fact = max_freq / 44100.0f;

+

+	for (i = 0; i < size-1; i++) {

+		float d = src[i+1] - src[i];

+		if (d > fact)

+			src[i+1] += fact - d;

+		else if (d < -fact)

+			src[i+1] += -d - fact;

+	}

+

+	return;

+}

+

+

+

+/* Dithering with noise shaping filter. Set shape = 0 for no shaping. */

+static void sample_dither_filter(float *src, long size, float shape) {

+	float r1 = 0, r2 = 0;

+	float s1 = 0, s2 = 0; /* Feedback buffer */

+	float o = 0.5f / 255;

+	float tmp;

+	int i;

+

+	for (i = 0; i < size; i++) {

+		r2 = r1;

+		r1 = rand() / (float)RAND_MAX;

+

+		tmp = src[i] + shape * (s1 + s1 - s2);

+		src[i] = tmp + o * (r1 - r2);

+		src[i] = MID(-1.0f, src[i], 1.0f);

+

+		s2 = s1;

+		s1 = tmp - src[i];

+	}

+	return;

+}

+#endif

+

+

+

+static void sample_sigrenderer_set_sigparam(sigrenderer_t *data, unsigned char id, long value)

+{

+	SAMPLE_SIGRENDERER *sigrenderer = data;

+

+	if (id == SAMPPARAM_N_LOOPS) {

+		if ((sigrenderer->sigdata->flags & (SAMPFLAG_LOOP | SAMPFLAG_XLOOP)) == SAMPFLAG_XLOOP) {

+			sigrenderer->n_loops += value;

+			sigrenderer->r.start = sigrenderer->n_loops ? sigrenderer->sigdata->loop_start : 0;

+			sigrenderer->r.end = sigrenderer->n_loops ? sigrenderer->sigdata->loop_end : sigrenderer->sigdata->size;

+		}

+	}

+}

+

+

+

+static long sample_sigrenderer_get_samples(

+	sigrenderer_t *data,

+	float volume, float delta,

+	long size, sample_t **samples

+)

+{

+	SAMPLE_SIGRENDERER *sigrenderer = data;

+

+	DUMB_RESAMPLER initial_r = sigrenderer->r;

+

+	long s = dumb_resample(&sigrenderer->r, samples[0], size, volume, delta);

+

+	int n;

+	for (n = 1; n < sigrenderer->n_channels; n++) {

+		sigrenderer->r = initial_r;

+		dumb_resample(&sigrenderer->r, samples[n], size, volume, delta);

+	}

+

+	return s;

+}

+

+

+

+static void sample_sigrenderer_get_current_sample(sigrenderer_t *data, float volume, sample_t *samples)

+{

+	SAMPLE_SIGRENDERER *sigrenderer = data;

+	int n;

+	for (n = 0; n < sigrenderer->n_channels; n++)

+		samples[n] = dumb_resample_get_current_sample(&sigrenderer->r, volume);

+}

+

+

+

+static void sample_end_sigrenderer(sigrenderer_t *sigrenderer)

+{

+	free(sigrenderer);

+}

+

+

+

+static void sample_unload_sigdata(sigdata_t *data)

+{

+	SAMPLE_SIGDATA *sigdata = data;

+	free(sigdata->samples);

+	free(data);

+}

+

+

+

+static DUH_SIGTYPE_DESC sigtype_sample = {

+	SIGTYPE_SAMPLE,

+	&sample_load_sigdata,

+	&sample_start_sigrenderer,

+	&sample_sigrenderer_set_sigparam,

+	&sample_sigrenderer_get_samples,

+	&sample_sigrenderer_get_current_sample,

+	&sample_end_sigrenderer,

+	&sample_unload_sigdata

+};

+

+

+

+void dumb_register_sigtype_sample(void)

+{

+	dumb_register_sigtype(&sigtype_sample);

+}

diff --git a/plugins/dumb/dumb-kode54/src/sigtypes/sequence.c b/plugins/dumb/dumb-kode54/src/sigtypes/sequence.c
new file mode 100644
index 00000000..cfade4d6
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/sigtypes/sequence.c
@@ -0,0 +1,592 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * sequence.c - The sequence (SEQU) signal type.      / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <math.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include "dumb.h"

+

+

+

+#define SIGTYPE_SEQUENCE DUMB_ID('S','E','Q','U')

+

+

+

+/* We have 256 intervals per semitone, 12 * 256 per octave

+   2 ** (1 / (12 * 256)) = 1.000225659305069791926712241547647863626

+

+   pow(DUMB_PITCH_BASE, x) = 1.5

+   x = log2(1.5) / log2(DUMB_PITCH_BASE)

+   x = log2(1.5) * 12 * 256

+   x = 1797.004802

+   cf.

+   x = 7 * 256 = 1792

+

+   so, for the perfect fifth temperament, use an interval of 1797.

+*/

+

+

+

+/* Sequencing format

+ * -----------------

+ *

+ * NOTE: A LOT OF THIS IS NOW REDUNDANT. PLEASE REFER TO duhspecs.txt.

+ *

+ * When a signal is initiated, it claims a reference number. If any other

+ * currently playing signal has the same number, that signal becomes

+ * anonymous and inaccessible; that is, if multiple signals were initiated

+ * with the same reference, the reference belongs to the most recent.

+ *

+ * Signals can be stopped, or have their pitch, volume or parameters changed,

+ * using the reference number. A signal may stop prematurely if it runs out

+ * of data, in which case the reference number becomes void, and operations

+ * on it will be ignored. Such a situation will not flag any kind of warning,

+ * since it may be the result of inaccuracies when resampling.

+ *

+ * The sequence consists of a series of commands. All commands begin with a

+ * long int, which is the time to wait after the last command (or the

+ * beginning of the sequence) before executing this command. 65536 represents

+ * one second. A time of -1 (or in fact any negative time) terminates the

+ * sequence, but any currently playing signals will continue until they run

+ * out. Make sure no non-terminating signals are playing when the sequence

+ * ends!

+ *

+ * The time, if nonnegative, is followed by one byte indicating the type of

+ * command. This byte can have the following values:

+ *

+ * SEQUENCE_START_SIGNAL

+ *   unsigned char ref; - Reference. Need more than 256? Use two sequences,

+ *                        and get your brain seen to.

+ *   int sig; - The index of the signal to initiate.

+ *   long pos; - The position at which to start. 65536 represents one second.

+ *   unsigned short volume; - Volume. 65535 represents the maximum volume, so

+ *                            you will want to go lower than this if you are

+ *                            playing more than one signal at once.

+ *   signed short pitch; - Pitch. 0 represents a frequency of 65536 Hz. Scale

+ *                         is logarithmic. Add 256 to increase pitch by one

+ *                         semitone in the even temperament, or add 12*256 to

+ *                         increase pitch by one octave in any temperament

+ *                         (i.e. double the frequency).

+ *

+ * SEQUENCE_SET_VOLUME

+ *   unsigned char ref;

+ *   unsigned short volume;

+ *

+ * SEQUENCE_SET_PITCH

+ *   unsigned char ref;

+ *   signed short pitch;

+ *

+ * SEQUENCE_SET_PARAMETER

+ *   unsigned char ref;

+ *   unsigned char id;

+ *   long value;

+ *   - see the description of the set_parameter function pointer for

+ *     information on 'id' and 'value'.

+ *

+ * SEQUENCE_STOP_SIGNAL

+ *   unsigned char ref;

+ */

+

+

+

+#define SEQUENCE_START_SIGNAL  0

+#define SEQUENCE_SET_VOLUME    1

+#define SEQUENCE_SET_PITCH     2

+#define SEQUENCE_SET_PARAMETER 3

+#define SEQUENCE_STOP_SIGNAL   4

+

+

+

+typedef struct SEQUENCE_PLAYING

+{

+	struct SEQUENCE_PLAYING *next;

+

+	DUH_SIGNAL_SAMPINFO *sampinfo;

+

+	int ref;

+

+	int pitch;

+	int volume;

+}

+SEQUENCE_PLAYING;

+

+

+

+typedef struct SEQUENCE_SAMPINFO

+{

+	DUH *duh;

+

+	int n_channels;

+

+	unsigned char *signal;

+

+	long time_left;

+	int sub_time_left;

+

+	SEQUENCE_PLAYING *playing;

+}

+SEQUENCE_SAMPINFO;

+

+

+

+#define sequence_c(signal) ((int)*((*(signal))++))

+

+

+static int sequence_w(unsigned char **signal)

+{

+	int v = (*signal)[0] | ((*signal)[1] << 8);

+	*signal += 2;

+	return v;

+}

+

+

+static long sequence_l(unsigned char **signal)

+{

+	long v = (*signal)[0] | ((*signal)[1] << 8) | ((*signal)[2] << 16) | ((*signal)[3] << 24);

+	*signal += 4;

+	return v;

+}

+

+

+static long sequence_cl(unsigned char **signal)

+{

+	long v = sequence_c(signal);

+	if (v & 0x80) {

+		v &= 0x7F;

+		v |= sequence_c(signal) << 7;

+		if (v & 0x4000) {

+			v &= 0x3FFF;

+			v |= sequence_c(signal) << 14;

+			if (v & 0x200000) {

+				v &= 0x1FFFFF;

+				v |= sequence_c(signal) << 21;

+				if (v & 0x10000000) {

+					v &= 0x0FFFFFFF;

+					v |= sequence_c(signal) << 28;

+				}

+			}

+		}

+	}

+	return v;

+}

+

+

+

+static void *sequence_load_signal(DUH *duh, DUMBFILE *file)

+{

+	long size;

+	unsigned char *signal;

+

+	(void)duh;

+

+	size = dumbfile_igetl(file);

+	if (dumbfile_error(file) || size <= 0)

+		return NULL;

+

+	signal = malloc(size);

+	if (!signal)

+		return NULL;

+

+	if (dumbfile_getnc((char *)signal, size, file) < size) {

+		free(signal);

+		return NULL;

+	}

+

+	return signal;

+}

+

+

+

+static long render(

+	SEQUENCE_SAMPINFO *sampinfo,

+	float volume, float delta,

+	long pos, long size, sample_t **samples

+)

+{

+	sample_t **splptr;

+

+	SEQUENCE_PLAYING **playing_p = &sampinfo->playing;

+

+	long max_size = 0;

+	long part_size;

+

+	int n;

+	long i;

+

+	for (n = 0; n < sampinfo->n_channels; n++)

+		memset(samples[n] + pos, 0, size * sizeof(sample_t));

+

+	splptr = malloc(sampinfo->n_channels * sizeof(*splptr));

+	if (!splptr)

+		return 0;

+

+	splptr[0] = malloc(sampinfo->n_channels * size * sizeof(sample_t));

+	if (!splptr[0]) {

+		free(splptr);

+		return 0;

+	}

+

+	for (n = 1; n < sampinfo->n_channels; n++)

+		splptr[n] = splptr[n - 1] + size;

+

+	while (*playing_p) {

+		SEQUENCE_PLAYING *playing = *playing_p;

+

+		part_size = duh_signal_render_samples(

+			playing->sampinfo,

+			volume * (float)playing->volume * (1.0f / 65535.0f),

+			(float)(pow(DUMB_PITCH_BASE, playing->pitch) * delta),

+			size, splptr

+		);

+

+		for (n = 0; n < sampinfo->n_channels; n++)

+			for (i = 0; i < part_size; i++)

+				samples[n][pos+i] += splptr[n][i];

+

+		if (part_size > max_size)

+			max_size = part_size;

+

+		if (part_size < size) {

+			*playing_p = playing->next;

+			duh_signal_end_samples(playing->sampinfo);

+			free(playing);

+		} else

+			playing_p = &playing->next;

+	}

+

+	free(splptr[0]);

+	free(splptr);

+

+	return max_size;

+}

+

+

+

+/* 'offset' is added to the position at which the signal should start. It is

+ * currently assumed to be positive, and is currently only used when seeking

+ * forwards in the sequence.

+ */

+static void sequence_command(SEQUENCE_SAMPINFO *sampinfo, long offset)

+{

+	int command = sequence_c(&sampinfo->signal);

+

+	if (command == SEQUENCE_START_SIGNAL) {

+

+		int ref = sequence_c(&sampinfo->signal);

+		int sig = sequence_cl(&sampinfo->signal);

+		long pos = sequence_cl(&sampinfo->signal);

+		int volume = sequence_w(&sampinfo->signal);

+		int pitch = (int)(signed short)sequence_w(&sampinfo->signal);

+

+		SEQUENCE_PLAYING *playing = sampinfo->playing;

+

+		while (playing) {

+			if (playing->ref == ref)

+				playing->ref = -1;

+			playing = playing->next;

+		}

+

+		playing = malloc(sizeof(SEQUENCE_PLAYING));

+

+		if (playing) {

+			playing->sampinfo = duh_signal_start_samples(sampinfo->duh, sig, sampinfo->n_channels, pos + offset);

+

+			if (playing->sampinfo) {

+				playing->ref = ref;

+				playing->pitch = pitch;

+				playing->volume = volume;

+

+				playing->next = sampinfo->playing;

+				sampinfo->playing = playing;

+			} else

+				free(playing);

+		}

+

+	} else if (command == SEQUENCE_SET_VOLUME) {

+

+		int ref = sequence_c(&sampinfo->signal);

+		int volume = sequence_w(&sampinfo->signal);

+

+		SEQUENCE_PLAYING *playing = sampinfo->playing;

+

+		while (playing) {

+			if (playing->ref == ref) {

+				playing->volume = volume;

+				break;

+			}

+			playing = playing->next;

+		}

+

+	} else if (command == SEQUENCE_SET_PITCH) {

+

+		int ref = sequence_c(&sampinfo->signal);

+		int pitch = (int)(signed short)sequence_w(&sampinfo->signal);

+

+		SEQUENCE_PLAYING *playing = sampinfo->playing;

+

+		while (playing) {

+			if (playing->ref == ref) {

+				playing->pitch = pitch;

+				break;

+			}

+			playing = playing->next;

+		}

+

+	} else if (command == SEQUENCE_SET_PARAMETER) {

+

+		int ref = sequence_c(&sampinfo->signal);

+		unsigned char id = sequence_c(&sampinfo->signal);

+		long value = sequence_l(&sampinfo->signal);

+

+		SEQUENCE_PLAYING *playing = sampinfo->playing;

+

+		while (playing) {

+			if (playing->ref == ref) {

+				duh_signal_set_parameter(playing->sampinfo, id, value);

+				break;

+			}

+			playing = playing->next;

+		}

+

+	} else if (command == SEQUENCE_STOP_SIGNAL) {

+

+		int ref = sequence_c(&sampinfo->signal);

+

+		SEQUENCE_PLAYING **playing_p = &sampinfo->playing;

+

+		while (*playing_p) {

+			SEQUENCE_PLAYING *playing = *playing_p;

+

+			if (playing->ref == ref) {

+				duh_signal_end_samples(playing->sampinfo);

+				*playing_p = playing->next;

+				free(playing);

+				break;

+			}

+

+			playing_p = &playing->next;

+		}

+

+	} else {

+

+		TRACE("Error in sequence: unknown command %d.\n", command);

+		sampinfo->signal = NULL;

+

+	}

+}

+

+

+

+static void *sequence_start_samples(DUH *duh, void *signal, int n_channels, long pos)

+{

+	SEQUENCE_SAMPINFO *sampinfo;

+	long time = sequence_cl((unsigned char **)&signal);

+

+	if (time < 0)

+		return NULL;

+

+	sampinfo = malloc(sizeof(SEQUENCE_SAMPINFO));

+	if (!sampinfo)

+		return NULL;

+

+	sampinfo->duh = duh;

+	sampinfo->n_channels = n_channels;

+	sampinfo->signal = signal;

+	sampinfo->playing = NULL;

+

+	/* Seek to 'pos'. */

+	while (time < pos) {

+		pos -= time;

+

+		sequence_command(sampinfo, pos);

+

+		time = sequence_cl(&sampinfo->signal);

+

+		if (time < 0) {

+			sampinfo->signal = NULL;

+			return sampinfo;

+		}

+	}

+

+	sampinfo->time_left = time - pos;

+	sampinfo->sub_time_left = 0;

+

+	return sampinfo;

+}

+

+

+

+static long sequence_render_samples(

+	void *sampinfo,

+	float volume, float delta,

+	long size, sample_t **samples

+)

+{

+

+#define sampinfo ((SEQUENCE_SAMPINFO *)sampinfo)

+

+	long pos = 0;

+

+	int dt = (int)(delta * 65536.0f + 0.5f);

+

+	long todo;

+	LONG_LONG t;

+

+	while (sampinfo->signal) {

+		todo = (long)((((LONG_LONG)sampinfo->time_left << 16) | sampinfo->sub_time_left) / dt);

+

+		if (todo >= size)

+			break;

+

+		if (todo) {

+			render(sampinfo, volume, delta, pos, todo, samples);

+

+			pos += todo;

+			size -= todo;

+

+		todo = (long)((((LONG_LONG)sampinfo->time_left << 16) | sampinfo->sub_time_left) / dt);

+			t = sampinfo->sub_time_left - (LONG_LONG)todo * dt;

+			sampinfo->sub_time_left = (long)t & 65535;

+			sampinfo->time_left += (long)(t >> 16);

+		}

+

+		sequence_command(sampinfo, 0);

+

+		todo = sequence_cl(&sampinfo->signal);

+

+		if (todo >= 0)

+			sampinfo->time_left += todo;

+		else

+			sampinfo->signal = NULL;

+	}

+

+	if (sampinfo->signal) {

+		render(sampinfo, volume, delta, pos, size, samples);

+

+		pos += size;

+

+		t = sampinfo->sub_time_left - (LONG_LONG)size * dt;

+		sampinfo->sub_time_left = (long)t & 65535;

+		sampinfo->time_left += (long)(t >> 16);

+	} else

+		pos += render(sampinfo, volume, delta, pos, size, samples);

+

+	return pos;

+

+

+/** WARNING - remove this... */

+#if 0

+	float size_unified = size * delta;

+

+	int n;

+

+	sample_t **samples2 = malloc(sampinfo->n_channels * sizeof(*samples2));

+	memcpy(samples2, samples, sampinfo->n_channels * sizeof(*samples2));

+

+	while (sampinfo->signal && sampinfo->time < size_unified) {

+

+		{

+			long sz = (long)(sampinfo->time / delta);

+

+			if (sz)

+				render(sampinfo, volume, delta, sz, samples2);

+

+			for (n = 0; n < sampinfo->n_channels; n++)

+				samples2[n] += sz;

+

+			size -= sz;

+			pos += sz;

+

+			sampinfo->time -= sz * delta;

+		}

+

+		sequence_command(sampinfo, 0);

+

+		{

+			long time = sequence_cl(&sampinfo->signal);

+

+			if (time >= 0)

+				sampinfo->time += (float)time;

+			else

+				sampinfo->signal = NULL;

+		}

+

+		size_unified = size * delta;

+	}

+

+	if (sampinfo->signal) {

+		render(sampinfo, volume, delta, size, samples2);

+		sampinfo->time -= size_unified;

+		pos += size;

+	} else

+		pos += render(sampinfo, volume, delta, size, samples2);

+

+	free(samples2);

+

+	return pos;

+#endif

+

+#undef sampinfo

+

+}

+

+

+

+static void sequence_end_samples(void *sampinfo)

+{

+	SEQUENCE_PLAYING *playing = ((SEQUENCE_SAMPINFO *)sampinfo)->playing;

+

+	while (playing) {

+		SEQUENCE_PLAYING *next = playing->next;

+

+		duh_signal_end_samples(playing->sampinfo);

+		free(playing);

+

+		playing = next;

+	}

+

+	free(sampinfo);

+}

+

+

+

+static void sequence_unload_signal(void *signal)

+{

+	free(signal);

+}

+

+

+

+static DUH_SIGTYPE_DESC sigtype_sequence = {

+	SIGTYPE_SEQUENCE,

+	&sequence_load_signal,

+	&sequence_start_samples,

+	NULL,

+	&sequence_render_samples,

+	&sequence_end_samples,

+	&sequence_unload_signal

+};

+

+

+

+void dumb_register_sigtype_sequence(void)

+{

+	dumb_register_sigtype(&sigtype_sequence);

+}

diff --git a/plugins/dumb/dumb-kode54/src/sigtypes/sterpan.c b/plugins/dumb/dumb-kode54/src/sigtypes/sterpan.c
new file mode 100644
index 00000000..22fe5d28
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/sigtypes/sterpan.c
@@ -0,0 +1,206 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * sterpan.c - The stereo pan (SPAN) signal type.     / / \  \

+ *                                                   | <  /   \_

+ * By entheh.                                        |  \/ /\   /

+ *                                                    \_  /  > /

+ * This takes a single monaural signal and              | \ / /

+ * expands it to two channels, applying a               |  ' /

+ * stereo pan in the process. The stereo pan             \__/

+ * is generated by delaying and damping the

+ * channel opposite the sound source. If only

+ * one channel is requested of this signal, it will simply chain to the other

+ * signal.

+ *

+ * In order for the delay to work properly, this must be played at 65536 Hz.

+ * The pitch at which you want the sample to play can be passed in parameter

+ * #1. Parameter #0 specifies the panning position, -256 to 256.

+ *

+ * NOTE: THIS IS NOT HOW IT WORKS AT THE MOMENT. AT THE MOMENT, THIS ROUTINE

+ * SIMPLY VARIES THE VOLUMES.

+ */

+

+#include <stdlib.h>

+

+#include "dumb.h"

+

+

+

+#define SIGTYPE_STEREOPAN DUMB_ID('S','P','A','N')

+

+

+

+#define SPANPARAM_PAN 0

+

+

+

+typedef struct STEREOPAN_SIGNAL

+{

+	int sig;

+}

+STEREOPAN_SIGNAL;

+

+

+

+typedef struct STEREOPAN_SAMPINFO

+{

+	float pan;

+	int stereo;

+	DUH_SIGNAL_SAMPINFO *csampinfo;

+}

+STEREOPAN_SAMPINFO;

+

+

+

+static void *stereopan_load_signal(DUH *duh, DUMBFILE *file)

+{

+	STEREOPAN_SIGNAL *signal;

+

+	(void)duh;

+

+	signal = malloc(sizeof(*signal));

+

+	if (!signal)

+		return NULL;

+

+	signal->sig = dumbfile_igetl(file);

+

+	if (dumbfile_error(file)) {

+		free(signal);

+		return NULL;

+	}

+

+	return signal;

+}

+

+

+

+static void *stereopan_start_samples(DUH *duh, void *signal, int n_channels, long pos)

+{

+	STEREOPAN_SAMPINFO *sampinfo;

+

+#define signal ((STEREOPAN_SIGNAL *)signal)

+

+	if ((unsigned int)(n_channels - 1) >= 2) {

+		TRACE("Stereo pan signal requiring 1 or 2 channels called with %d channels.\n", n_channels);

+		return NULL;

+	}

+

+	sampinfo = malloc(sizeof(*sampinfo));

+	if (!sampinfo)

+		return NULL;

+

+	sampinfo->pan = 0;

+

+	sampinfo->stereo = n_channels - 1;

+

+	sampinfo->csampinfo = duh_signal_start_samples(duh, signal->sig, 1, pos);

+	if (!sampinfo->csampinfo) {

+		free(sampinfo);

+		return NULL;

+	}

+

+#undef signal

+

+	return sampinfo;

+}

+

+

+

+static void stereopan_set_parameter(void *sampinfo, unsigned char id, long value)

+{

+#define sampinfo ((STEREOPAN_SAMPINFO *)sampinfo)

+

+	if (id == SPANPARAM_PAN && value >= -256 && value <= 256)

+		sampinfo->pan = value * (1.0f / 256.0f);

+

+#undef sampinfo

+}

+

+

+

+static long stereopan_render_samples(

+	void *sampinfo,

+	float volume, float delta,

+	long size, sample_t **samples

+)

+{

+#define sampinfo ((STEREOPAN_SAMPINFO *)sampinfo)

+

+	if (!sampinfo->stereo)

+		return duh_signal_render_samples(sampinfo->csampinfo, volume, delta, size, samples);

+

+	if (sampinfo->pan >= 0) {

+		long sz = duh_signal_render_samples(sampinfo->csampinfo, volume * (1.0f + sampinfo->pan), delta, size, samples + 1);

+		long s;

+		int vol;

+

+		volume = (1.0f - sampinfo->pan) / (1.0f + sampinfo->pan);

+		vol = (int)(volume * 65536 + 0.5);

+

+		for (s = 0; s < sz; s++)

+			samples[0][s] = (samples[1][s] * vol) >> 16;

+

+		return sz;

+	} else {

+		long sz = duh_signal_render_samples(sampinfo->csampinfo, volume * (1.0f - sampinfo->pan), delta, size, samples);

+		long s;

+		int vol;

+

+		volume = (1.0f + sampinfo->pan) / (1.0f - sampinfo->pan);

+		vol = (int)(volume * 65536 + 0.5);

+

+		for (s = 0; s < sz; s++)

+			samples[1][s] = (samples[0][s] * vol) >> 16;

+

+		return sz;

+	}

+

+#undef sampinfo

+}

+

+

+

+static void stereopan_end_samples(void *sampinfo)

+{

+#define sampinfo ((STEREOPAN_SAMPINFO *)sampinfo)

+

+	duh_signal_end_samples(sampinfo->csampinfo);

+	free(sampinfo);

+

+#undef sampinfo

+}

+

+

+

+static void stereopan_unload_signal(void *signal)

+{

+	free(signal);

+}

+

+

+

+static DUH_SIGTYPE_DESC sigtype_stereopan = {

+	SIGTYPE_STEREOPAN,

+	&stereopan_load_signal,

+	&stereopan_start_samples,

+	&stereopan_set_parameter,

+	&stereopan_render_samples,

+	&stereopan_end_samples,

+	&stereopan_unload_signal

+};

+

+

+

+void dumb_register_sigtype_stereopan(void)

+{

+	dumb_register_sigtype(&sigtype_stereopan);

+}

diff --git a/plugins/dumb/dumb-kode54/src/tools/it/load_it.cpp b/plugins/dumb/dumb-kode54/src/tools/it/load_it.cpp
new file mode 100644
index 00000000..ed88e706
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/tools/it/load_it.cpp
@@ -0,0 +1,824 @@
+#ifdef FORTIFY

+#include "fortify.h"

+#endif

+#include <stdio.h>

+#ifdef MSS

+#include "mss.h"

+#endif

+

+#include <string.h>

+

+#include "allegro.h"

+#include "modulus.h"

+#include "typedef.hpp"

+

+int	detect_it(char *f) {

+	int	sig;

+	PACKFILE *fn = pack_fopen(f, "rb");

+	

+	if (fn == NULL)

+		return FALSE;

+

+	sig	= pack_mgetl(fn);

+	if (sig	!= AL_ID('I','M','P','M')) {

+		pack_fclose(fn);

+		return FALSE;

+	}

+	pack_fclose(fn);

+

+	return TRUE;

+}

+

+MODULUS	*create_it() {

+	MODULUS	*m = (MODULUS*)malloc(sizeof(MODULUS));

+	if (!m)

+		return NULL;

+	memset(m, 0, sizeof(MODULUS));

+	return m;

+}

+

+void destroy_it(MODULUS	*j)	{

+

+	if (song->Music	== j)

+		stop_it();

+

+	//remove patterns:

+	for	(int i=0; i<j->NumPatterns;	i++) {

+		free(j->Pattern[i].Note);

+	}

+	if (j->Pattern)

+		free(j->Pattern);

+	//remove instruments;

+   	if (j->Instrument)

+		free(j->Instrument);

+	//remove samples;

+	for	(int i=0; i<j->NumSamples; i++)	{

+		destroy_sample(j->Sample[i].Sample);		

+	}

+	if (j->Sample)

+		free(j->Sample);

+	//remove orders:

+	if (j->Order)

+		free(j->Order);

+	//remove channels:

+	for	(int i=0; i<64;	i++) {

+		if (j->Channel[i].VChannel)	{

+			MODULUS_VCHANNEL *vchn = song->Music->Channel[i].VChannel;

+			MODULUS_VCHANNEL *prev = NULL;

+	

+			if (!vchn)

+				continue;

+		

+			for	(;;) {

+				deallocate_voice(vchn->voice);

+					

+				prev = vchn;

+				vchn = vchn->next;

+				free(prev);

+

+				if (!vchn)

+					break;

+			}

+		}	 

+	}

+	free(j);

+}

+

+//#define DEBUG_IT_SIZE

+

+int	get_module_size(MODULUS	*j)	{

+	int	a, b, c, d = 0,	e;

+	a =	sizeof(MODULUS)	+ j->NumOrders;

+	b =	j->NumInstruments *	sizeof(MODULUS_INSTRUMENT);

+	c =	j->NumSamples *	sizeof(MODULUS_SAMPLE);

+	

+	for	(int i=0; i<j->NumSamples; i++)

+		d += j->Sample[i].SampleLength * (j->Sample[i].Flag	& 2	? sizeof(short)	: 1) * (j->Sample[i].Flag &	4 ?	2: 1);

+		

+	e =	4 +	sizeof(MODULUS_PATTERN)	* j->NumPatterns;

+	

+	for	(int i=0; i<j->NumPatterns;	i++)

+		e += j->Pattern[i].NumNotes	* sizeof(MODULUS_NOTE);

+	#ifdef DEBUG_IT_SIZE

+	printf("Base: %i, Instruments(%i): %i, Samples(%i): %i, Data: %i, Patterns(%i): %i\n", a, j->NumInstruments, b,	j->NumSamples, c, d, j->NumPatterns, e);

+	#endif

+

+	return a+b+c+d+e;

+}

+

+#define	MAX_IT_CHN 64

+

+//#define DEBUG_HEADER

+//#define DEBUG_INSTRUMENTS

+//#define DEBUG_SAMPLES

+//#define DEBUG_PATTERNS

+

+static dword *sourcebuf	= NULL;

+static dword *sourcepos	= NULL;

+static byte	rembits	= 0;

+

+int	readblock(PACKFILE *f) {

+	long size;

+	int	c =	pack_igetw(f);

+	if (c == -1)

+		return 0;

+	size = c;

+

+	sourcebuf =	(dword*)malloc(size+4);

+	if (!sourcebuf)

+		return 0;

+		

+	c =	pack_fread(sourcebuf, size,	f);

+	if (c <	1) {

+		free(sourcebuf);

+		sourcebuf =	NULL;

+		return 0;		 

+	}

+	sourcepos =	sourcebuf;

+	rembits	= 32;

+	return 1;

+}

+

+void freeblock() {

+	if (sourcebuf)

+		free(sourcebuf);

+	sourcebuf =	NULL;	 

+}

+

+dword readbits(char	b) {

+	dword val;

+	if (b <= rembits) {

+		val	= *sourcepos & ((1 << b) - 1);

+		*sourcepos >>= b;

+		rembits	-= b;

+	}

+	else {

+		dword nbits	= b	- rembits;

+		val	= *sourcepos;

+		sourcepos++;

+		val	|= ((*sourcepos	& ((1 << nbits)	- 1)) << rembits);

+		*sourcepos >>= nbits;

+		rembits	= 32 - nbits;

+	}

+	return val;

+}

+

+void decompress8(PACKFILE *f, void *data, int len, int tver) {

+	char *destbuf =	(char*)data;

+	char *destpos =	destbuf;

+	int	blocklen, blockpos;

+	byte bitwidth;

+	word val;

+	char d1, d2;

+

+	memset(destbuf,	0, len);

+

+	while (len>0) {

+		//Read a block of compressed data:

+		if (!readblock(f))

+			return;

+		//Set up a few variables

+		blocklen = (len	< 0x8000) ?	len	: 0x8000; //Max block length is 0x8000 bytes

+		blockpos = 0;

+		bitwidth = 9;

+		d1 = d2	= 0;

+		//Start the decompression:

+		while (blockpos	< blocklen)	{

+			//Read a value:

+			val	= readbits(bitwidth);

+			//Check for bit width change:

+			

+			if (bitwidth < 7) {	//Method 1:

+				if (val	== (1 << (bitwidth - 1))) {

+					val	= readbits(3) +	1;

+					bitwidth = (val	< bitwidth)	? val :	val	+ 1;

+					continue;

+				}

+			}

+			else if	(bitwidth <	9) { //Method 2

+				byte border	= (0xFF	>> (9 -	bitwidth)) - 4;

+

+				if (val	> border &&	val	<= (border + 8)) {

+					val	-= border;

+					bitwidth = (val	< bitwidth)	? val :	val	+ 1;

+					continue;

+				}

+			}

+			else if	(bitwidth == 9)	{ //Method 3

+				if (val	& 0x100) {

+					bitwidth = (val	+ 1) & 0xFF;

+					continue;

+				}

+			}

+			else { //Illegal width, abort ?

+				freeblock();

+				return;

+			}

+

+			//Expand the value to signed byte:

+			char v;	//The sample value:

+			if (bitwidth < 8) {

+				byte shift = 8 - bitwidth;

+				v =	(val <<	shift);

+				v >>= shift;

+			}

+			else

+				v =	(char)val;

+				

+			//And integrate the sample value

+			//(It always has to end with integration doesn't it ? ;-)

+			d1 += v;

+			d2 += d1;

+

+			//Store !

+			*destpos = ((tver == 0x215)	? d2 : d1);

+			destpos++;

+			blockpos++;

+		}

+		freeblock();

+		len	-= blocklen;

+	}

+	return;

+}

+

+void decompress16(PACKFILE *f, void	*data, int len,	int	tver) {

+	//make the output buffer:

+	short *destbuf = (short*)data;

+	short *destpos = destbuf;

+	int	blocklen, blockpos;

+	byte bitwidth;

+	long val;

+	short d1, d2;

+

+	memset(destbuf,	0, len);

+

+	while (len>0) {

+		//Read a block of compressed data:

+		if (!readblock(f))

+			return;

+		//Set up a few variables

+		blocklen = (len	< 0x4000) ?	len	: 0x4000; // Max block length is 0x4000 bytes

+		blockpos = 0;

+		bitwidth = 17;

+		d1 = d2	= 0;

+		//Start the decompression:

+		while (blockpos	< blocklen)	{

+			val	= readbits(bitwidth);

+			//Check for bit width change:

+			

+			if (bitwidth < 7) {	//Method 1:

+				if (val	== (1 << (bitwidth - 1))) {

+					val	= readbits(4) +	1;

+					bitwidth = (val	< bitwidth)	? val :	val	+ 1;

+					continue;

+				}

+			}

+			else if	(bitwidth <	17)	{ //Method 2

+				word border	= (0xFFFF >> (17 - bitwidth)) -	8;

+

+				if (val	> border &&	val	<= (border + 16)) {

+					val	-= border;

+					bitwidth = val < bitwidth ?	val	: val +	1;

+					continue;

+				}

+			}

+			else if	(bitwidth == 17) { //Method 3

+				if (val	& 0x10000) {

+					bitwidth = (val	+ 1) & 0xFF;

+					continue;

+				}

+			}

+			else { //Illegal width, abort ?

+				freeblock();

+				return;

+			}

+

+			//Expand the value to signed byte:

+			short v; //The sample value:

+			if (bitwidth < 16) {

+				byte shift = 16	- bitwidth;

+				v =	(val <<	shift);

+				v >>= shift;

+			}

+			else

+				v =	(short)val;

+				

+			//And integrate the sample value

+			//(It always has to end with integration doesn't it ? ;-)

+			d1 += v;

+			d2 += d1;

+

+			//Store !

+			*destpos = ((tver == 0x215)	? d2 : d1);

+			destpos++;

+			blockpos++;

+		}

+		freeblock();

+	   	len	-= blocklen;

+	}

+	return;

+}

+

+MODULUS	*load_it(char *file) {

+	PACKFILE *f;

+	MODULUS	*j = create_it();

+	int	tver, tver2, flag, msglen, msgoffs;

+	int	*insoffs = NULL, *samoffs = NULL, *patoffs = NULL;

+	

+	if (!j)

+		return NULL;

+

+	if (!detect_it(file))

+		return NULL;

+

+	f =	pack_fopen(file, "rb");

+

+	if (!f)	{

+		#ifdef DEBUG_HEADER

+			printf("Error Opening!\n");

+		#endif

+		return NULL;

+	}

+

+	pack_fseek(f, 30);

+	pack_igetw(f); //I have no idea...

+	

+	j->NumOrders = pack_igetw(f);

+	j->NumInstruments =	pack_igetw(f);

+	j->NumSamples =	pack_igetw(f);

+	j->NumPatterns = pack_igetw(f);

+

+	#ifdef DEBUG_HEADER

+	printf("Loading IT: %i Orders %i Instruments, %i Samples, %i Patterns\n", j->NumOrders,	j->NumInstruments, j->NumSamples, j->NumPatterns);

+	#endif

+	

+	tver = pack_igetw(f);

+	j->Version = tver2 = pack_igetw(f);

+

+	#ifdef DEBUG_HEADER

+	printf("Tracker ver: %X, %X\n",	tver, tver2);

+	#endif

+

+	j->Flags = pack_igetw(f);

+	flag = pack_igetw(f);

+

+	j->GlobalVolume	= pack_getc(f);

+	j->MixVolume = pack_getc(f);

+	j->Speed = pack_getc(f);

+	j->Tempo = pack_getc(f);

+	j->PanningSeperation = pack_getc(f);

+

+	#ifdef DEBUG_HEADER

+	printf("Global Volume: %i, Mixing Volume: %i, Speed: %i, Tempo: %i, PanSep: %i\n", j->GlobalVolume,	j->MixVolume, j->Speed,	j->Tempo, j->PanningSeperation);

+	#endif

+

+	pack_getc(f);	//Damn....I need more info on this.

+

+	msglen = pack_igetw(f);

+	msgoffs	= pack_igetl(f);

+

+	pack_fseek(f, 4);

+

+	#ifdef DEBUG_HEADER

+	printf("Channel Pan:");

+	#endif

+

+	for	(int i=0; i<MAX_IT_CHN;	i++) {

+		j->Channel[i].Pan =	pack_getc(f);

+		#ifdef DEBUG_HEADER

+		printf(" %i", j->Channel[i].Pan);

+		#endif

+	}

+	#ifdef DEBUG_HEADER

+	printf("\nChannel Vol:");

+	#endif

+	for	(int i=0; i<MAX_IT_CHN;	i++) {

+		j->Channel[i].Volume = pack_getc(f);

+		#ifdef DEBUG_HEADER

+		printf(" %i", j->Channel[i].Volume);

+		#endif

+	}

+	#ifdef DEBUG_HEADER

+	printf("\n");

+	#endif

+		

+	j->Order = (unsigned char *)malloc(j->NumOrders);

+	pack_fread(j->Order, j->NumOrders, f);

+

+	if (j->NumInstruments)

+		insoffs = (int*)malloc(4 * j->NumInstruments);

+	if (j->NumSamples)

+		samoffs = (int*)malloc(4 * j->NumSamples);

+	if (j->NumPatterns)

+		patoffs	= (int*)malloc(4 * j->NumPatterns);

+

+	pack_fread(insoffs,	4 * j->NumInstruments, f);

+	pack_fread(samoffs, 4 * j->NumSamples, f);

+	pack_fread(patoffs,	4 * j->NumPatterns, f);

+

+	if (flag&1)	{ //Song message attached

+		//Ignore.

+	}

+	if (flag & 4) {	//skip something:

+		short u;

+		char dummy[8];

+		u =	pack_igetw(f);

+		for	(int i=0; i<u; u++)

+			pack_fread(dummy, 8, f);

+	}

+	if (flag & 8) {	//MIDI commands ???

+		char dummy[33];

+		for	(int i=0; i<9+16+128; i++)

+			pack_fread(dummy, 32, f);

+

+	}

+

+	if (j->NumInstruments)

+		j->Instrument =	(MODULUS_INSTRUMENT*)malloc(sizeof(MODULUS_INSTRUMENT) * j->NumInstruments);

+	#ifdef DEBUG_INSTRUMENTS

+	if (!j->Instrument)

+		printf("No Mem for Instruments!\n");

+	#endif

+

+	

+	for	(int i=0; i<j->NumInstruments; i++)	{

+		pack_fclose(f);

+		f =	pack_fopen(file, "rb");

+		#ifdef DEBUG_INSTRUMENTS

+		if (!f)

+			printf("Error Opening!\n");

+		#endif

+		pack_fseek(f, insoffs[i] + 17);

+

+		j->Instrument[i].NewNoteAction = pack_getc(f);

+		j->Instrument[i].DuplicateCheckType	= pack_getc(f);

+		j->Instrument[i].DuplicateCheckAction =	pack_getc(f);

+		j->Instrument[i].FadeOut = pack_igetw(f);

+		j->Instrument[i].PitchPanSeperation	= pack_getc(f);

+		j->Instrument[i].PitchPanCenter	= pack_getc(f);

+		j->Instrument[i].GlobalVolume =	pack_getc(f);

+		j->Instrument[i].DefaultPan	= pack_getc(f);

+		#ifdef DEBUG_INSTRUMENTS

+		printf("I%02i @ 0x%X, NNA %i, DCT %i, DCA %i, FO %i, PPS %i, PPC %i, GVol %i, DPan %i\n", i, insoffs[i], j->Instrument[i].NewNoteAction, j->Instrument[i].DuplicateCheckType, j->Instrument[i].DuplicateCheckAction, j->Instrument[i].FadeOut, j->Instrument[i].PitchPanSeperation,	j->Instrument[i].PitchPanCenter, j->Instrument[i].GlobalVolume,	j->Instrument[i].DefaultPan);

+		#endif

+

+		pack_fseek(f, 38);

+

+		for	(int k=0; k<120; k++) {

+			j->Instrument[i].NoteNote[k] = pack_getc(f);

+			j->Instrument[i].NoteSample[k] = pack_getc(f) -	1;

+		}

+

+		j->Instrument[i].VolumeEnvelope.Flag = pack_getc(f);

+		j->Instrument[i].VolumeEnvelope.NumNodes = pack_getc(f);

+		j->Instrument[i].VolumeEnvelope.LoopBegin =	pack_getc(f);

+		j->Instrument[i].VolumeEnvelope.LoopEnd	= pack_getc(f);

+		j->Instrument[i].VolumeEnvelope.SustainLoopBegin = pack_getc(f);

+		j->Instrument[i].VolumeEnvelope.SustainLoopEnd = pack_getc(f);

+		for	(int k=0; k<j->Instrument[i].VolumeEnvelope.NumNodes; k++) {

+			j->Instrument[i].VolumeEnvelope.NodeY[k] = pack_getc(f);

+			j->Instrument[i].VolumeEnvelope.NodeTick[k]	= pack_igetw(f);

+		}

+		pack_fseek(f, 75 - j->Instrument[i].VolumeEnvelope.NumNodes	* 3);

+		

+		j->Instrument[i].PanningEnvelope.Flag =	pack_getc(f);

+		j->Instrument[i].PanningEnvelope.NumNodes =	pack_getc(f);

+		j->Instrument[i].PanningEnvelope.LoopBegin = pack_getc(f);

+		j->Instrument[i].PanningEnvelope.LoopEnd = pack_getc(f);

+		j->Instrument[i].PanningEnvelope.SustainLoopBegin =	pack_getc(f);

+		j->Instrument[i].PanningEnvelope.SustainLoopEnd	= pack_getc(f);

+		for	(int k=0; k<j->Instrument[i].PanningEnvelope.NumNodes; k++)	{

+			j->Instrument[i].PanningEnvelope.NodeY[k] =	pack_getc(f);

+			j->Instrument[i].PanningEnvelope.NodeTick[k] = pack_igetw(f);

+		}

+		pack_fseek(f, 75 - j->Instrument[i].PanningEnvelope.NumNodes * 3);

+		

+		j->Instrument[i].PitchEnvelope.Flag	= pack_getc(f);

+		j->Instrument[i].PitchEnvelope.NumNodes	= pack_getc(f);

+		j->Instrument[i].PitchEnvelope.LoopBegin = pack_getc(f);

+		j->Instrument[i].PitchEnvelope.LoopEnd = pack_getc(f);

+		j->Instrument[i].PitchEnvelope.SustainLoopBegin	= pack_getc(f);

+		j->Instrument[i].PitchEnvelope.SustainLoopEnd =	pack_getc(f);

+		for	(int k=0; k<j->Instrument[i].PitchEnvelope.NumNodes; k++) {

+			j->Instrument[i].PitchEnvelope.NodeY[k]	= pack_getc(f);

+			j->Instrument[i].PitchEnvelope.NodeTick[k] = pack_igetw(f);

+		}

+	}

+

+	if (j->NumSamples)

+		j->Sample =	(MODULUS_SAMPLE*)malloc(sizeof(MODULUS_SAMPLE) * j->NumSamples);

+

+	#ifdef DEBUG_SAMPLES

+	if (!j->Sample)

+		printf("No Mem for Samples!\n");

+	#endif

+			

+	for	(int i=0; i<j->NumSamples; i++)	{

+		int	sam_samptr,	convert;

+	

+		pack_fclose(f);

+		f =	pack_fopen(file, "rb");

+		#ifdef DEBUG_SAMPLES

+		if (!f)

+			printf("Error opening!\n");

+		#endif

+		

+		pack_fseek(f, samoffs[i] + 17);

+

+		j->Sample[i].GlobalVolume =	pack_getc(f);

+		j->Sample[i].Flag =	pack_getc(f);

+		j->Sample[i].Volume	= pack_getc(f);

+

+		#ifdef DEBUG_SAMPLES

+		printf("S%02i @ 0x%X, Vol: %i/%i, Flag: %i", i,	samoffs[i],	j->Sample[i].GlobalVolume, j->Sample[i].Volume,	j->Sample[i].Flag);

+		#endif

+		

+		pack_fseek(f, 26);

+		

+		convert	= pack_getc(f);

+		pack_getc(f); //Panning ?

+

+		j->Sample[i].SampleLength =	pack_igetl(f);

+		j->Sample[i].LoopBegin = pack_igetl(f);

+		j->Sample[i].LoopEnd = pack_igetl(f);

+		j->Sample[i].C5Speed = pack_igetl(f);

+		j->Sample[i].SustainLoopBegin =	pack_igetl(f);

+		j->Sample[i].SustainLoopEnd	= pack_igetl(f);

+

+		#ifdef DEBUG_SAMPLES

+		printf(", SLen: %i, LpB: %i, LpE: %i, C5S: %i\n", j->Sample[i].SampleLength, j->Sample[i].LoopBegin, j->Sample[i].LoopEnd, j->Sample[i].C5Speed);

+		#endif

+

+		sam_samptr = pack_igetl(f);

+		

+		j->Sample[i].VibratoSpeed =	pack_getc(f);

+		j->Sample[i].VibratoDepth =	pack_getc(f);

+		j->Sample[i].VibratoRate = pack_getc(f);

+		j->Sample[i].VibratoWaveForm = pack_getc(f);

+

+		#ifdef DEBUG_SAMPLES

+		printf("SusLpB: %i, SusLpE: %i, VibSp: %i, VibDep: %i, VibWav: %i, VibRat: %i\n", j->Sample[i].SustainLoopBegin, j->Sample[i].SustainLoopEnd, j->Sample[i].VibratoSpeed, j->Sample[i].VibratoDepth,	j->Sample[i].VibratoWaveForm, j->Sample[i].VibratoRate);

+		#endif

+

+		if (j->Sample[i].Flag &	1 == 0)

+			continue;

+		

+		pack_fclose(f);

+		f =	pack_fopen(file, "rb");

+		pack_fseek(f, sam_samptr);

+

+		int	len	= j->Sample[i].SampleLength	* (j->Sample[i].Flag & 2 ? sizeof(short) : 1) *	(j->Sample[i].Flag & 4 ? 2:	1);

+

+		#ifdef DEBUG_SAMPLES

+		printf("Len: %i, Size: %i KB\n", j->Sample[i].SampleLength,	len/1024);

+		#endif

+

+		SAMPLE *sam	= create_sample(j->Sample[i].Flag &	2 ?	16 : 8,	j->Sample[i].Flag &	4 ?	TRUE : FALSE, j->Sample[i].C5Speed,	j->Sample[i].SampleLength);

+		

+		if (j->Sample[i].Flag &	8) { // If the sample is packed, then we must unpack it

+			if (j->Sample[i].Flag &	2)

+				decompress16(f,	sam->data, j->Sample[i].SampleLength, tver2);

+			else

+				decompress8(f, sam->data, j->Sample[i].SampleLength, tver2);

+		} else {

+			pack_fread(sam->data, len, f);

+		}

+		

+		if (j->Sample[i].Flag &	SAMPLE_USELOOP)	{

+			sam->loop_start	= j->Sample[i].LoopBegin;

+			sam->loop_end =	j->Sample[i].LoopEnd;

+		}

+

+		j->Sample[i].Sample	= sam;

+		

+		void *dat =	sam->data;

+

+		if (convert	& 2) { //Change the byte order for 16-bit samples:

+			if (sam->bits == 16) {

+				for	(int k=0; k<len; k+=2) {

+					int	l =	((char*)dat)[k];

+					((char*)dat)[k]	= ((char*)dat)[k+1];

+					((char*)dat)[k+1] =	l;

+					

+				}

+			}

+			else {

+				for	(int k=0; k<len; k+=2) {

+					int	l =	((char*)dat)[k];

+					((char*)dat)[k]	= ((char*)dat)[k+1];

+					((char*)dat)[k+1] =	l;

+					

+				}

+			}

+		}

+		if (convert	& 1) { //Convert to unsigned

+	   		if (sam->bits == 8)	{

+	   			for	(int k=0; k<len; k++) {

+		   			((char*)dat)[k]	^= 0x80;

+		   		}

+	   		}

+	   		else {

+	   			for	(int k=0; k<(len>>1); k++) {

+		   			((short*)dat)[k] ^=	0x8000;

+		   		}

+			}			 

+		}

+	}

+

+	if (j->NumPatterns)

+		j->Pattern = (MODULUS_PATTERN*)malloc(sizeof(MODULUS_PATTERN) *	j->NumPatterns);

+	unsigned char *buf = (unsigned char*)alloca(65536);

+	unsigned char *cmask = (unsigned char*)alloca(64),

+		*cnote = (unsigned char*)alloca(64),

+		*cinstrument = (unsigned char*)alloca(64),

+		*cvol =	(unsigned char*)alloca(64),

+		*ccom =	(unsigned char*)alloca(64),

+		*ccomval = (unsigned char*)alloca(64);

+	

+	for	(int i=0; i<j->NumPatterns;	i++) {

+		int	numnotes = 0, len, pos = 0,	mask = 0, chn =	0;

+

+		memset(cmask, 0, 64);

+		memset(cnote, 0, 64);

+		memset(cinstrument,	0, 64);

+		memset(cvol, 0,	64);

+		memset(ccom, 0,	64);

+		memset(ccomval,	0, 64);

+	

+		pack_fclose(f);

+		f =	pack_fopen(file, "rb");

+		pack_fseek(f, patoffs[i]);

+		

+		len	= pack_igetw(f);

+		j->Pattern[i].NumRows =	pack_igetw(f);

+

+		pack_fseek(f, 4);

+		pack_fread(buf,	len, f);

+

+		while (pos < len) {

+			int	b =	buf[pos];

+			pos++;

+			if (!b)	{ //If end of row:

+				numnotes++;

+				continue;

+			}

+			chn	= (b - 1) &	63;

+

+			if (b &	128) {

+				mask = buf[pos];

+				pos++;

+				cmask[chn] = mask;

+			}

+			else

+				mask = cmask[chn];

+				

+			if (mask)

+				numnotes++;

+			if (mask & 1)

+				pos++;

+			if (mask & 2)

+				pos++;

+			if (mask & 4)

+				pos++;

+			if (mask & 8)

+				pos+=2;	//Guessing here

+		}

+		j->Pattern[i].NumNotes = numnotes;

+		j->Pattern[i].Note = (MODULUS_NOTE*)malloc(sizeof(MODULUS_NOTE)	* numnotes);

+		memset(j->Pattern[i].Note, 0, sizeof(MODULUS_NOTE) * numnotes);

+		

+		pos	= 0;

+		memset(cmask, 0, 64);

+		mask = 0;

+		numnotes = 0;

+		while (pos < len) {

+			int	b =	buf[pos];

+			#ifdef DEBUG_PATTERNS

+			printf("NumNote: %i ", numnotes);

+			#endif

+			

+			pos++;			  

+			if (!b)	{ //If end of row:

+				j->Pattern[i].Note[numnotes].Channel = -1;

+				numnotes++;

+				#ifdef DEBUG_PATTERNS

+				printf("Channel: -1\n");

+				#endif

+				continue;

+			}

+			chn	= (b - 1) &	63;

+

+			if (b &	128) {

+				mask = buf[pos];

+				pos++;

+				cmask[chn] = mask;

+			}

+			else

+				mask = cmask[chn];

+			#ifdef DEBUG_PATTERNS

+			printf("Channel: %i Mask: %i ",	chn, mask);

+			#endif

+				

+			if (mask)

+				j->Pattern[i].Note[numnotes].Channel = chn;

+

+			if (mask & 1) {

+				j->Pattern[i].Note[numnotes].Note =	buf[pos];

+				j->Pattern[i].Note[numnotes].Mask |= 1;

+				cnote[chn] = buf[pos];				  

+				#ifdef DEBUG_PATTERNS

+				printf("Note: %i ",	buf[pos]);

+				#endif

+				pos++;

+			}

+			if (mask & 2) {

+				j->Pattern[i].Note[numnotes].Instrument	= buf[pos];

+				j->Pattern[i].Note[numnotes].Mask |= 2;

+				cinstrument[chn] = buf[pos];

+				#ifdef DEBUG_PATTERNS

+				printf("Inst: %i ",	buf[pos]);

+				#endif

+				pos++;

+			}

+			if (mask & 4) {

+				if (buf[pos] <=	64 || (buf[pos]	>= 128 && buf[pos] <= 192))

+					if (buf[pos] <=	64)	{

+						j->Pattern[i].Note[numnotes].Volume	= buf[pos];

+						j->Pattern[i].Note[numnotes].Mask |= 4;

+					}

+					else {

+						j->Pattern[i].Note[numnotes].Panning = buf[pos]	- 128;

+						j->Pattern[i].Note[numnotes].Mask |= 8;

+					}

+				#ifdef DEBUG_PATTERNS

+				printf("Vol: %i ", buf[pos]);

+				#endif

+				cvol[chn] =	buf[pos];

+				pos++;

+			}

+			if (mask & 8) {

+				j->Pattern[i].Note[numnotes].Command = buf[pos];

+				j->Pattern[i].Note[numnotes].CommandValue =	buf[pos+1];

+				j->Pattern[i].Note[numnotes].Mask |= 16;

+				ccom[chn] =	buf[pos];

+				ccomval[chn] = buf[pos+1];

+				#ifdef DEBUG_PATTERNS

+				printf("Com: %i CommArg: %i ", buf[pos], buf[pos+1]);

+				#endif

+				pos+=2;

+			}

+			if (mask & 16) {

+				j->Pattern[i].Note[numnotes].Note =	cnote[chn];

+				j->Pattern[i].Note[numnotes].Mask |= 1;

+				#ifdef DEBUG_PATTERNS

+				printf("LNote: %i ", cnote[chn]);

+				#endif

+			}

+			if (mask & 32) {

+				j->Pattern[i].Note[numnotes].Instrument	= cinstrument[chn];

+				j->Pattern[i].Note[numnotes].Mask |= 2;

+				#ifdef DEBUG_PATTERNS

+				printf("LInst: %i ", cinstrument[chn]);

+				#endif

+			}

+			if (mask & 64) {

+				if (cvol[chn] <= 64	|| (cvol[chn] >= 128 &&	cvol[chn] <= 192))

+					if (cvol[chn] <= 64) {

+						j->Pattern[i].Note[numnotes].Volume	= cvol[chn];

+						j->Pattern[i].Note[numnotes].Mask |= 4;

+					}

+					else {

+						j->Pattern[i].Note[numnotes].Panning = cvol[chn] - 128;

+						j->Pattern[i].Note[numnotes].Mask |= 8;

+					}

+				#ifdef DEBUG_PATTERNS

+				printf("LVol: %i ",	cvol[chn]);

+				#endif

+			}			 

+			if (mask & 128)	{

+				j->Pattern[i].Note[numnotes].Command = ccom[chn];

+				j->Pattern[i].Note[numnotes].CommandValue =	ccomval[chn];

+				j->Pattern[i].Note[numnotes].Mask |= 16;

+				#ifdef DEBUG_PATTERNS

+				printf("LCom: %i LComArg: %i ",	ccom[chn], ccomval[chn]);

+				#endif

+			}

+			#ifdef DEBUG_PATTERNS

+			printf("\n");

+			#endif

+			if (mask)

+				numnotes++;

+			#ifdef DEBUG_PATTERNS

+			rest(1000);

+			#endif

+		}

+	}

+	if (insoffs)

+		free(insoffs);

+	if (samoffs)

+		free(samoffs);

+	if (patoffs)

+		free(patoffs);

+

+	return j;

+}

diff --git a/plugins/dumb/dumb-kode54/src/tools/it/modulus.h b/plugins/dumb/dumb-kode54/src/tools/it/modulus.h
new file mode 100644
index 00000000..b17d6ff6
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/tools/it/modulus.h
@@ -0,0 +1,193 @@
+

+#define MUSIC_IT AL_ID('I','M','P','M')

+

+typedef struct MODULUS_MUSIC_INFO {

+	char Name[29];

+    int Type;

+} MODULUS_MUSIC_INFO;

+

+#define ENVELOPE_ON 1

+#define ENVELOPE_LOOP_ON 2

+#define ENVELOPE_SUSTAINLOOP 4

+

+typedef struct MODULUS_ENVELOPE {

+	unsigned char Flag,

+    	NumNodes,

+        LoopBegin, LoopEnd, SustainLoopBegin, SustainLoopEnd; //in nodes.

+    char NodeY[25];

+    short NodeTick[25];

+} MODULUS_ENVELOPE;

+

+typedef struct MODULUS_VENVELOPE {

+    char CurNode;

+    unsigned char CurTick;

+	char End;

+    //float CVolume;

+    MODULUS_ENVELOPE *Envelope;

+} MODULUS_VENVELOPE;

+

+#define NNA_NOTECUT      1

+#define NNA_NOTECONTINUE 2

+#define NNA_NOTEOFF      3

+#define NNA_NOTEFADE     4

+

+#define DCT_OFF 0

+#define DCT_NOTE 1

+#define DCT_SAMPLE 2

+#define DCT_INSTRUMENT 3

+

+#define DCA_CUT 0

+#define DCA_NOTEOFF 1

+#define DCA_NOTEFADE 2

+

+typedef struct MOULUS_INSTRUMENT {

+	unsigned char Flag;

+    char VolumeLoopNodeStart, VolumeLoopNodeEnd;

+    char SustainLoopNodeStart, SustainLoopNodeEnd;

+    char DuplicateCheckType;

+    char DuplicateCheckAction;

+    char NewNoteAction;

+    int FadeOut;

+

+    unsigned char PitchPanSeperation, //0->64, Bit7: Don't use

+    	PitchPanCenter; //Note, from C-0 to B-9

+    unsigned char GlobalVolume, //0->128

+    	DefaultPan; //0->64, Bit7: Don't use

+    

+

+    unsigned char NoteSample[120];

+    unsigned char NoteNote[120];

+

+    MODULUS_ENVELOPE VolumeEnvelope, PanningEnvelope, PitchEnvelope;

+} MODULUS_INSTRUMENT;

+

+#define SAMPLE_HASSAMPLE       1

+#define SAMPLE_16BIT           2

+#define SAMPLE_STEREO          4

+#define SAMPLE_USELOOP        16

+#define SAMPLE_USESUSTAINLOOP 32

+#define SAMPLE_PINGPONGLOOP   64

+#define SAMPLE_PINGPONGSUSTAINLOOP 128

+

+#define VIBRATO_SINE 0

+#define VIBRATO_RAMPDOWN 1

+#define VIBRATO_SQUARE 2

+#define VIBRATO_RANDOM 3

+

+typedef struct MODULUS_SAMPLE {

+	unsigned char GlobalVolume; //0->64

+    unsigned char Flag;

+    unsigned char Volume;

+    int SampleLength; //in samples, not bytes !

+    int LoopBegin, LoopEnd; //in samples

+    int SustainLoopBegin, SustainLoopEnd;

+    int C5Speed; //Number of bytes/sec for C-5

+

+    SAMPLE *Sample;

+

+    char VibratoSpeed; //0->64

+    char VibratoDepth; //0->64

+    char VibratoWaveForm;

+    char VibratoRate; //0->64

+} MODULUS_SAMPLE;

+

+typedef struct MODULUS_NOTE {

+	char Mask; //If Bit0: Note, Bit1: Instrument, Bit2: Volume, Bit3: Panning, Bit4: Command

+	char Channel; //if -1, then end of row.    

+    unsigned char Note;

+    char Instrument;

+    unsigned char Volume, Panning;

+    unsigned char Command, CommandValue;

+} MODULUS_NOTE;

+

+typedef struct MODULUS_PATTERN {

+	int NumRows;

+    int NumNotes;

+    MODULUS_NOTE *Note;

+} MODULUS_PATTERN;

+

+typedef struct MODULUS_VCHANNEL {

+	MODULUS_SAMPLE *Sample;  //NULL is unused

+    char voice;

+    char ChannelVolume;

+    char NoteOn;

+    char NNA;

+    short FadeOutCount, FadeOut;

+    float MixVolume, MixPan;

+    MODULUS_VENVELOPE *VVolumeEnvelope, *VPanningEnvelope, *VPitchEnvelope;

+    MODULUS_VCHANNEL *next, *prev;

+} MODULUS_VCHANNEL;

+

+typedef struct MODULUS_CHANNEL {

+	unsigned char Volume; //0->64

+    unsigned char Pan;    //0->32->64, 100 = surround, Bit7: Disable

+    char LastNote, LastInstrument, LastSample;    

+    MODULUS_VCHANNEL *VChannel;

+} MODULUS_CHANNEL;

+

+#define FLAG_STEREO         1

+#define FLAG_USEINSTRUMENTS 4

+#define FLAG_LINEARSLIDES   8

+#define FLAG_OLDEFFECT     16

+

+typedef struct MODULUS {

+	MODULUS_INSTRUMENT *Instrument;

+    MODULUS_SAMPLE *Sample;

+    MODULUS_PATTERN *Pattern;

+

+	int NumOrders;

+    int NumInstruments;

+    int NumSamples;

+    int NumPatterns;

+    int Flags;

+    short Version;

+    char GlobalVolume;

+    char MixVolume;

+    unsigned char Speed, Tempo;

+    char PanningSeperation;

+

+    unsigned char *Order;

+

+    MODULUS_CHANNEL Channel[64];

+

+} MODULUS;

+

+#define COMMAND_SET_SONG_SPEED        1

+#define COMMAND_JUMP_TO_ORDER         2

+#define COMMAND_PATTERN_BREAK_TO_ROW  3

+#define COMMAND_SET_CHANNEL_VOLUME   13

+#define COMMAND_SET_SONG_TEMPO       20

+#define COMMAND_SET_GLOBAL_VOLUME    22

+

+typedef struct MODULUS_PLAY {

+	MODULUS *Music;

+    int Loop, Tick;

+    int CurOrder, CurPattern, CurPos;

+    int Command, CommandVal0, CommandVal1, CommandVal2;

+    int pos;

+} MODULUS_PLAY;

+extern MODULUS_PLAY *song;

+

+extern int IT_Play_Method;

+

+MODULUS *load_it(char*);

+int get_module_size(MODULUS *);

+

+int play_it(MODULUS *j, int loop);

+void install_modulus();

+void set_mix_volume(int i);

+

+void stop_it();

+int is_music_done();

+void destroy_it(MODULUS *j);

+

+//Should be internal:

+extern MODULUS_PLAY *song;

+extern int note_freq[120];

+

+extern void MOD_Interrupt(...);

+extern int MOD_Poller(void*);

+

+#define IT_TIMER 0

+#define IT_POLL  1

+

diff --git a/plugins/dumb/dumb-kode54/src/tools/it/typedef.hpp b/plugins/dumb/dumb-kode54/src/tools/it/typedef.hpp
new file mode 100644
index 00000000..6d4eefee
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/src/tools/it/typedef.hpp
@@ -0,0 +1,3 @@
+typedef unsigned char byte;

+typedef unsigned short word;

+typedef unsigned int dword;

diff --git a/plugins/dumb/dumb-kode54/studio/font0.bmp b/plugins/dumb/dumb-kode54/studio/font0.bmp
new file mode 100644
index 00000000..5aff7cbc
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/font0.bmp
diff --git a/plugins/dumb/dumb-kode54/studio/font1.bmp b/plugins/dumb/dumb-kode54/studio/font1.bmp
new file mode 100644
index 00000000..7336d42b
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/font1.bmp
diff --git a/plugins/dumb/dumb-kode54/studio/font2.bmp b/plugins/dumb/dumb-kode54/studio/font2.bmp
new file mode 100644
index 00000000..5c0906cc
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/font2.bmp
diff --git a/plugins/dumb/dumb-kode54/studio/include/dumbdesk.h b/plugins/dumb/dumb-kode54/studio/include/dumbdesk.h
new file mode 100644
index 00000000..f8320f1c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/include/dumbdesk.h
@@ -0,0 +1,44 @@
+#ifndef INCLUDED_DUMBDESK_H

+#define INCLUDED_DUMBDESK_H

+

+

+#include "dumbgui.h"

+#include "dumbmenu.h"

+

+

+typedef struct DESKGUI

+{

+	struct DESKGUI *next;

+

+	GUI *gui;

+

+	const char *name;

+}

+DESKGUI;

+

+

+typedef struct GUI_DESKTOP_PARAM

+{

+	const char *title;

+	GUI_MENU_PARAM *menu_bar;

+}

+GUI_DESKTOP_PARAM;

+

+

+#define DESKTOP_CHANGED_TITLE GUI_OTHER

+#define DESKTOP_CHANGED_REST (GUI_OTHER << 1)

+#define DESKTOP_CHANGED_ALL (DESKTOP_CHANGED_TITLE | DESKTOP_CHANGED_REST)

+

+typedef struct GUI_DESKTOP_DATA

+{

+	const char *title;

+	GUI_MENU_PARAM *menu_bar;

+	DESKGUI *deskgui;

+}

+GUI_DESKTOP_DATA;

+

+

+extern GUI_COMMANDS gui_desktop_commands;

+

+

+#endif /* INCLUDED_DUMBDESK_H */

diff --git a/plugins/dumb/dumb-kode54/studio/include/dumbgui.h b/plugins/dumb/dumb-kode54/studio/include/dumbgui.h
new file mode 100644
index 00000000..f6cc2bc7
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/include/dumbgui.h
@@ -0,0 +1,82 @@
+#ifndef INCLUDED_DUMBGUI_H

+#define INCLUDED_DUMBGUI_H

+

+

+/* GUI_FINISHED_WITH: Set this in your update, key or mouse function when you

+ *                    don't need the object any more. It will be destroyed

+ *                    before redrawing or any subsequent updates take place.

+ * GUI_OTHER:         Any powers of two greater than or equal to this are

+ *                    free for use by objects for specific purposes.

+ */

+#define GUI_FINISHED_WITH 1

+#define GUI_OTHER         2

+

+

+typedef struct GUI GUI;

+

+

+/* GUI_CREATE:    Create a GUI object.

+ * GUI_DESTROY:   Destroy the GUI object.

+ * GUI_KEY:       Respond to a key.

+ * GUI_UPDATE:    Process any real-time activity.

+ * GUI_DRAW:      Draw any parts of the GUI that have changed. This may be

+ *                called more than once with different clipping rectangles,

+ *                so don't clear any flags here.

+ * GUI_DRAWN:     Clear any redraw flags.

+ * GUI_CHANGED_*: Set flags to redraw parts of the object as necessary for

+ *                the change that has occurred.

+ */

+typedef void (*GUI_CREATE)(GUI *gui, void *param);

+typedef void (*GUI_DESTROY)(GUI *gui);

+typedef void (*GUI_KEY)(GUI *gui, int k);

+typedef void (*GUI_UPDATE)(GUI *gui);

+typedef void (*GUI_DRAW)(GUI *gui);

+typedef void (*GUI_DRAWN)(GUI *gui);

+typedef void (*GUI_CHANGED_ALL)(GUI *gui);

+typedef void (*GUI_CHANGED_ACTIVE)(GUI *gui);

+

+

+typedef struct GUI_COMMANDS

+{

+	GUI_CREATE create;

+	GUI_DESTROY destroy;

+	GUI_KEY key;

+	GUI_UPDATE update;

+	GUI_DRAW draw;

+	GUI_DRAWN drawn;

+	GUI_CHANGED_ALL changed_all;

+	GUI_CHANGED_ACTIVE changed_active;

+}

+GUI_COMMANDS;

+

+

+struct GUI

+{

+	GUI_COMMANDS *com;

+

+	GUI *parent;

+

+	int x, y, w, h;

+	int flags;

+

+	void *data;

+};

+

+

+extern GUI *gui_active;

+

+void gui_set_active(GUI *gui);

+

+GUI *gui_create(GUI_COMMANDS *com, GUI *parent, int x, int y, int w, int h, void *param);

+void gui_destroy(GUI *gui);

+void gui_key(GUI *gui, int k);

+void gui_update(GUI *gui);

+void gui_draw(GUI *gui);

+void gui_draw_void(void *gui);

+void gui_drawn(GUI *gui);

+void gui_changed_all(GUI *gui);

+void gui_changed_active(GUI *gui);

+

+

+#endif /* INCLUDED_DUMBGUI_H */

+

diff --git a/plugins/dumb/dumb-kode54/studio/include/dumbmenu.h b/plugins/dumb/dumb-kode54/studio/include/dumbmenu.h
new file mode 100644
index 00000000..c28dcda1
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/include/dumbmenu.h
@@ -0,0 +1,44 @@
+#ifndef INCLUDED_DUMBMENU_H

+#define INCLUDED_DUMBMENU_H

+

+

+#include "dumbgui.h"

+

+

+typedef void (*GUI_MENU_ACTIVATOR)(void *param);

+

+

+typedef struct GUI_MENU_ENTRY

+{

+	char *text; /* If the first char is '\t', draw an arrow on the right. */

+	GUI_MENU_ACTIVATOR activator;

+	void *param;

+}

+GUI_MENU_ENTRY;

+

+

+typedef struct GUI_MENU_PARAM

+{

+	int n_entries;

+	GUI_MENU_ENTRY *entry;

+}

+GUI_MENU_PARAM;

+

+

+#define GUI_MENU_REDRAW_ALL GUI_OTHER

+

+typedef struct GUI_MENU_DATA

+{

+	GUI_MENU_PARAM *menu;

+	int sel;

+	int lastsel; /* When this is different from 'sel', rows 'lastsel' and 'sel' need redrawing. */

+}

+GUI_MENU_DATA;

+

+

+extern GUI_COMMANDS gui_menu_commands;

+

+void gui_menu_get_size(GUI_MENU_PARAM *menu, int *w, int *h);

+

+

+#endif /* INCLUDED_DUMBMENU_H */

diff --git a/plugins/dumb/dumb-kode54/studio/include/guiproc.h b/plugins/dumb/dumb-kode54/studio/include/guiproc.h
new file mode 100644
index 00000000..ab3d8d71
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/include/guiproc.h
@@ -0,0 +1,52 @@
+#ifndef INCLUDED_GUIPROC_H

+#define INCLUDED_GUIPROC_H

+

+

+#define THE_SIZE 2

+

+

+#if THE_SIZE == 2

+

+#define BEVEL_SIZE 3

+#define BORDER_SIZE 3

+#define TITLE_HEIGHT 21

+

+#define THE_FONT FONT2

+

+#elif THE_SIZE == 1

+

+#define BEVEL_SIZE 2

+#define BORDER_SIZE 2

+#define TITLE_HEIGHT 13

+

+#define THE_FONT FONT1

+

+#else

+

+#define BEVEL_SIZE 1

+#define BORDER_SIZE 1

+#define TITLE_HEIGHT 7

+

+#define THE_FONT FONT0

+

+#endif

+

+

+#define HIGHLIGHT 15

+#define MIDTONE 7

+#define SHADOW 8

+#define TITLE_BG_FOCUS 9

+#define TITLE_FG_FOCUS 14

+#define TITLE_BG 8

+#define TITLE_FG 7

+#define MENU_BG_FOCUS 1

+#define MENU_FG_FOCUS 15

+#define MENU_BG MIDTONE

+#define MENU_FG 0

+#define DESKTOP 4

+

+

+void draw_bevel(int l, int t, int r, int b, int tl, int m, int br);

+

+

+#endif /* INCLUDED_GUIPROC_H */

diff --git a/plugins/dumb/dumb-kode54/studio/include/guitop.h b/plugins/dumb/dumb-kode54/studio/include/guitop.h
new file mode 100644
index 00000000..25557122
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/include/guitop.h
@@ -0,0 +1,17 @@
+#ifndef INCLUDED_GUITOP_H

+#define INCLUDED_GUITOP_H

+

+

+#include "dumbdesk.h"

+

+extern int the_time;

+

+extern volatile int true_time;

+

+

+void run_desktop(GUI_DESKTOP_PARAM *param);

+

+void initialise_guitop(void);

+

+

+#endif /* INCLUDED_GUITOP_H */

diff --git a/plugins/dumb/dumb-kode54/studio/include/main.h b/plugins/dumb/dumb-kode54/studio/include/main.h
new file mode 100644
index 00000000..968fe5d6
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/include/main.h
@@ -0,0 +1,10 @@
+#ifndef INCLUDED_MAIN_H

+#define INCLUDED_MAIN_H

+

+

+extern DATAFILE *dat;

+

+#include "datafile.h"

+

+

+#endif /* INCLUDED_MAIN_H */

diff --git a/plugins/dumb/dumb-kode54/studio/include/options.h b/plugins/dumb/dumb-kode54/studio/include/options.h
new file mode 100644
index 00000000..a62d48c5
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/include/options.h
@@ -0,0 +1,34 @@
+#ifndef INCLUDED_OPTIONS_H

+#define INCLUDED_OPTIONS_H

+

+

+typedef struct OPTIONS

+{

+	int gfx_w, gfx_h;

+}

+OPTIONS;

+

+

+OPTIONS opt;

+

+

+#ifdef ALLEGRO_DOS

+

+#define DEF_GFX_W 320

+#define DEF_GFX_H 200

+#define DEF_GFX_STR "320x200"

+

+#else

+

+#define DEF_GFX_W 640

+#define DEF_GFX_H 480

+#define DEF_GFX_STR "640x480"

+

+#endif

+

+

+void load_options(void);

+void save_options(void);

+

+

+#endif /* INCLUDED_OPTIONS_H */

diff --git a/plugins/dumb/dumb-kode54/studio/include/subclip.h b/plugins/dumb/dumb-kode54/studio/include/subclip.h
new file mode 100644
index 00000000..5a5f8210
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/include/subclip.h
@@ -0,0 +1,8 @@
+#ifndef INCLUDED_SUBCLIP_H

+#define INCLUDED_SUBCLIP_H

+

+

+void subclip(int l, int t, int r, int b, void (*proc)(void *data), void *data);

+

+

+#endif /* INCLUDED_SUBCLIP_H */

diff --git a/plugins/dumb/dumb-kode54/studio/makedat b/plugins/dumb/dumb-kode54/studio/makedat
new file mode 100644
index 00000000..7932ff91
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/makedat
@@ -0,0 +1,13 @@
+# Makefile for building the datafile

+# NOT FOR RELEASE

+# Usage: make -f makedat

+

+include/datafile.h: studio.dat

+	dat -h $@ $<

+

+studio.dat: font0.bmp font1.bmp font2.bmp

+	rm -f $@

+	dat -t FONT -a $@ font0.bmp; dat $@ FONT0_BMP NAME=FONT0

+	dat -t FONT -a $@ font1.bmp; dat $@ FONT1_BMP NAME=FONT1

+	dat -t FONT -a $@ font2.bmp; dat $@ FONT2_BMP NAME=FONT2

+	dat -c2 $@

diff --git a/plugins/dumb/dumb-kode54/studio/src/dumbdesk.c b/plugins/dumb/dumb-kode54/studio/src/dumbdesk.c
new file mode 100644
index 00000000..61a3cd0e
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/src/dumbdesk.c
@@ -0,0 +1,271 @@
+#include <stdlib.h>

+#include <allegro.h>

+

+#include "main.h"

+#include "subclip.h"

+#include "dumbgui.h"

+#include "guiproc.h"

+#include "dumbdesk.h"

+#include "options.h"

+

+

+

+static void gui_desktop_create(GUI *gui, void *param)

+{

+	GUI_DESKTOP_PARAM *desktop = param;

+

+	GUI_DESKTOP_DATA *data = gui->data = malloc(sizeof(*data));

+

+	if (!data)

+		return;

+

+	data->title = desktop->title;

+	data->menu_bar = desktop->menu_bar;

+	data->deskgui = NULL;

+}

+

+

+

+static void gui_desktop_destroy(GUI *gui)

+{

+	GUI_DESKTOP_DATA *data = gui->data;

+

+	DESKGUI *deskgui = data->deskgui;

+

+	while (deskgui) {

+		DESKGUI *next = deskgui->next;

+		gui_destroy(deskgui->gui);

+		free(deskgui);

+		deskgui = next;

+	}

+

+	free(data);

+}

+

+

+

+static void gui_desktop_key(GUI *gui, int k)

+{

+	switch (k >> 8) {

+		case KEY_N:

+			{

+				GUI_DESKTOP_PARAM param2 = {"well.duh", NULL};

+				GUI_DESKTOP_DATA *data = gui->data;

+				DESKGUI *next = data->deskgui;

+				data->deskgui = malloc(sizeof(*data->deskgui));

+				if (!data->deskgui) break;

+				data->deskgui->gui = gui_create(

+					&gui_desktop_commands,

+					gui,

+					10 + rand() % 50, 30 + rand() % 50, 50 + rand() % 600, 50 + rand() % 350,

+					&param2

+				);

+				if (!data->deskgui->gui) {

+					free(data->deskgui);

+					break;

+				}

+				data->deskgui->name = param2.title;

+				data->deskgui->next = next;

+				gui_set_active(data->deskgui->gui);

+			}

+	}

+}

+

+

+

+static void gui_desktop_update(GUI *gui)

+{

+	GUI_DESKTOP_DATA *data = gui->data;

+

+	DESKGUI *deskgui = data->deskgui;

+

+	while (deskgui) {

+		gui_update(deskgui->gui);

+		deskgui = deskgui->next;

+	}

+}

+

+

+

+static void draw_desktop_itself(void *g)

+{

+	GUI *gui = g;

+	GUI_DESKTOP_DATA *data = gui->data;

+

+	if (data->deskgui) {

+

+		/* Unlink child GUI. */

+		DESKGUI *deskgui = data->deskgui;

+		GUI *subgui = deskgui->gui;

+

+		data->deskgui = deskgui->next;

+

+		/* Child GUI outer bevel */

+		draw_bevel(

+			subgui->x - BORDER_SIZE - BEVEL_SIZE,

+			subgui->y - BORDER_SIZE - BEVEL_SIZE,

+			subgui->x + subgui->w + BORDER_SIZE + BEVEL_SIZE - 1,

+			subgui->y + subgui->h + BORDER_SIZE + BEVEL_SIZE - 1,

+			HIGHLIGHT, MIDTONE, SHADOW

+		);

+

+		/* Child GUI border */

+		rectfill(screen, subgui->x - BORDER_SIZE, subgui->y - BORDER_SIZE, subgui->x + subgui->w + BORDER_SIZE - 1, subgui->y - 1, MIDTONE);

+		rectfill(screen, subgui->x - BORDER_SIZE, subgui->y, subgui->x - 1, subgui->y + subgui->h - 1, MIDTONE);

+		rectfill(screen, subgui->x + subgui->w, subgui->y, subgui->x + subgui->w + BORDER_SIZE - 1, subgui->y + subgui->h - 1, MIDTONE);

+		rectfill(screen, subgui->x - BORDER_SIZE, subgui->y + subgui->h, subgui->x + subgui->w + BORDER_SIZE - 1, subgui->y + subgui->h + BORDER_SIZE - 1, MIDTONE);

+

+		/* Child GUI */

+		subclip(subgui->x, subgui->y, subgui->x + subgui->w, subgui->y + subgui->h,

+			&gui_draw_void, subgui);

+

+		/* Draw self, and other child GUIs, around this child GUI. */

+		subclip(0, 0, opt.gfx_w, subgui->y - BORDER_SIZE - BEVEL_SIZE, &draw_desktop_itself, gui);

+		subclip(0, subgui->y - BORDER_SIZE - BEVEL_SIZE, subgui->x - BORDER_SIZE - BEVEL_SIZE, subgui->y + subgui->h + BORDER_SIZE + BEVEL_SIZE, &draw_desktop_itself, gui);

+		subclip(subgui->x + subgui->w + BORDER_SIZE + BEVEL_SIZE, subgui->y - BORDER_SIZE - BEVEL_SIZE, opt.gfx_w, subgui->y + subgui->h + BORDER_SIZE + BEVEL_SIZE, &draw_desktop_itself, gui);

+		subclip(0, subgui->y + subgui->h + BORDER_SIZE + BEVEL_SIZE, opt.gfx_w, opt.gfx_h, &draw_desktop_itself, gui);

+

+		/* Link child GUI back in. */

+		data->deskgui = deskgui;

+

+		return;

+	}

+

+	if (gui->flags & DESKTOP_CHANGED_REST)

+		/* Desktop area */

+		clear_to_color(screen, DESKTOP);

+}

+

+

+

+static int desktop_x;

+static int desktop_y;

+static GUI *desktop_gui;

+

+

+

+static void draw_desktop_title_bar(void *t)

+{

+	const char *title = t;

+	clear_to_color(screen, desktop_gui == gui_active ? TITLE_BG_FOCUS : TITLE_BG);

+	textout(screen, dat[THE_FONT].dat, title, desktop_x, desktop_y, desktop_gui == gui_active ? TITLE_FG_FOCUS : TITLE_FG);

+}

+

+

+

+static void draw_menu_bar(void *data)

+{

+	GUI_MENU_PARAM *menu_bar = data;

+

+	clear_to_color(screen, MENU_BG);

+

+	if (menu_bar) {

+		int i;

+		GUI_MENU_ENTRY *entry = menu_bar->entry;

+		for (i = 0; i < menu_bar->n_entries; i++) {

+			// If the first char is '\t', draw an arrow on the right.

+			textout(screen, dat[THE_FONT].dat, entry->text,

+				desktop_x + BORDER_SIZE, desktop_y + BORDER_SIZE, MENU_FG);

+			desktop_x += BORDER_SIZE + text_length(dat[THE_FONT].dat, entry->text) + BORDER_SIZE;

+			entry++;

+		}

+	} // else hide the damn thing?

+}

+

+

+

+static void gui_desktop_draw(GUI *gui)

+{

+	GUI_DESKTOP_DATA *data = gui->data;

+

+	subclip(

+		gui->x + BEVEL_SIZE,

+		gui->y + TITLE_HEIGHT + TITLE_HEIGHT + BEVEL_SIZE,

+		gui->x + gui->w - BEVEL_SIZE,

+		gui->y + gui->h - BEVEL_SIZE,

+		&draw_desktop_itself, gui

+	);

+

+	if (gui->flags & DESKTOP_CHANGED_TITLE) {

+		/* Title bar */

+		desktop_x = gui->x + BORDER_SIZE;

+		desktop_y = gui->y + BORDER_SIZE;

+		desktop_gui = gui;

+

+		subclip(gui->x, gui->y, gui->x + gui->w, gui->y + TITLE_HEIGHT,

+			&draw_desktop_title_bar, (void *)data->title);

+	}

+

+	if (gui->flags & DESKTOP_CHANGED_REST) {

+		/* Separation between title bar and inner bevel */

+		//rectfill(screen, gui->x, gui->y + TITLE_HEIGHT, gui->x + gui->w - 1, gui->y + TITLE_HEIGHT + BORDER_SIZE - 1, MIDTONE);

+

+		/* Menu bar */

+		desktop_x = gui->x;

+		desktop_y = gui->y + TITLE_HEIGHT;

+

+		subclip(

+			gui->x, gui->y + TITLE_HEIGHT,

+			gui->x + gui->w, gui->y + TITLE_HEIGHT + TITLE_HEIGHT,

+			&draw_menu_bar, data->menu_bar

+		);

+

+		/* Inner bevel */

+		draw_bevel(gui->x, gui->y + TITLE_HEIGHT + TITLE_HEIGHT, gui->x + gui->w - 1, gui->y + gui->h - 1, SHADOW, MIDTONE, HIGHLIGHT);

+	}

+}

+

+

+

+static void gui_desktop_drawn(GUI *gui)

+{

+	GUI_DESKTOP_DATA *data = gui->data;

+

+	if (data->deskgui) {

+		/* Mark child GUIs as drawn. */

+		DESKGUI *deskgui = data->deskgui;

+		while (deskgui) {

+			gui_drawn(deskgui->gui);

+			deskgui = deskgui->next;

+		}

+	}

+

+	/* Mark self as drawn. */

+	gui->flags &= ~DESKTOP_CHANGED_ALL;

+}

+

+

+

+static void gui_desktop_changed_all(GUI *gui)

+{

+	gui->flags |= DESKTOP_CHANGED_ALL;

+

+	{

+		GUI_DESKTOP_DATA *data = gui->data;

+		DESKGUI *deskgui = data->deskgui;

+		while (deskgui) {

+			gui_changed_all(deskgui->gui);

+			deskgui = deskgui->next;

+		}

+	}

+}

+

+

+

+static void gui_desktop_changed_active(GUI *gui)

+{

+	gui->flags |= DESKTOP_CHANGED_TITLE;

+}

+

+

+

+GUI_COMMANDS gui_desktop_commands = {

+	&gui_desktop_create,

+	&gui_desktop_destroy,

+	&gui_desktop_key,

+	&gui_desktop_update,

+	&gui_desktop_draw,

+	&gui_desktop_drawn,

+	&gui_desktop_changed_all,

+	&gui_desktop_changed_active

+};

diff --git a/plugins/dumb/dumb-kode54/studio/src/dumbgui.c b/plugins/dumb/dumb-kode54/studio/src/dumbgui.c
new file mode 100644
index 00000000..4927a09c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/src/dumbgui.c
@@ -0,0 +1,120 @@
+#include <stdlib.h>

+

+#include "dumbgui.h"

+

+

+

+GUI *gui_active;

+

+

+

+void gui_set_active(GUI *gui)

+{

+	gui_changed_active(gui_active);

+	gui_active = gui;

+	gui_changed_active(gui_active);

+}

+

+

+

+GUI *gui_create(GUI_COMMANDS *com, GUI *parent, int x, int y, int w, int h, void *param)

+{

+	GUI *gui = malloc(sizeof(*gui));

+

+	if (!gui)

+		return NULL;

+

+	gui->com = com;

+

+	gui->parent = parent;

+

+	gui->x = x;

+	gui->y = y;

+	gui->w = w;

+	gui->h = h;

+

+	gui->flags = 0;

+

+	if (com->create) {

+		(*com->create)(gui, param);

+

+		if (!gui->data) {

+			free(gui);

+			return NULL;

+		}

+	} else

+		gui->data = NULL;

+

+	gui_changed_all(gui);

+

+	return gui;

+}

+

+

+

+void gui_destroy(GUI *gui)

+{

+	if (gui) {

+		if (gui->com->destroy)

+			(*gui->com->destroy)(gui);

+

+		free(gui);

+	}

+}

+

+

+

+void gui_key(GUI *gui, int k)

+{

+	if (gui && gui->com->key)

+		(*gui->com->key)(gui, k);

+}

+

+

+

+void gui_update(GUI *gui)

+{

+	if (gui && gui->com->update)

+		(*gui->com->update)(gui);

+}

+

+

+

+void gui_draw(GUI *gui)

+{

+	if (gui && gui->com->draw)

+		(*gui->com->draw)(gui);

+}

+

+

+

+/* For use with subclip(). */

+void gui_draw_void(void *gui)

+{

+	gui_draw(gui);

+}

+

+

+

+void gui_drawn(GUI *gui)

+{

+	if (gui && gui->com->drawn)

+		(*gui->com->drawn)(gui);

+}

+

+

+

+void gui_changed_all(GUI *gui)

+{

+	if (gui && gui->com->changed_all)

+		(*gui->com->changed_all)(gui);

+}

+

+

+

+void gui_changed_active(GUI *gui)

+{

+	if (gui && gui->com->changed_active)

+		(*gui->com->changed_active)(gui);

+}

+

diff --git a/plugins/dumb/dumb-kode54/studio/src/dumbmenu.c b/plugins/dumb/dumb-kode54/studio/src/dumbmenu.c
new file mode 100644
index 00000000..609c70e2
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/src/dumbmenu.c
@@ -0,0 +1,191 @@
+#include <stdlib.h>

+#include <allegro.h>

+

+#include "main.h"

+#include "dumbgui.h"

+#include "guiproc.h"

+#include "subclip.h"

+#include "dumbmenu.h"

+

+

+

+static void gui_menu_create(GUI *gui, void *param)

+{

+	GUI_MENU_PARAM *menu = param;

+

+	GUI_MENU_DATA *data = gui->data = malloc(sizeof(*data));

+

+	if (!data)

+		return;

+

+	data->menu = menu;

+	data->sel = -1;

+	/* data->lastsel will be initialised by gui_menu_drawn(). */

+}

+

+

+

+static void gui_menu_destroy(GUI *gui)

+{

+	free(gui->data);

+}

+

+

+

+static void gui_menu_key(GUI *gui, int k)

+{

+	GUI_MENU_DATA *data = gui->data;

+

+	switch (k >> 8) {

+		case KEY_UP:

+		case KEY_8_PAD:

+			if (data->sel <= 0) data->sel = data->menu->n_entries;

+			data->sel--;

+			break;

+		case KEY_DOWN:

+		case KEY_2_PAD:

+			data->sel++;

+			if (data->sel >= data->menu->n_entries) data->sel = 0;

+			break;

+		case KEY_RIGHT:

+		case KEY_6_PAD:

+		case KEY_ENTER:

+			if (data->sel >= 0) {

+				GUI_MENU_ENTRY *entry = &data->menu->entry[data->sel];

+				if (k >> 8 != KEY_RIGHT || entry->text[0] == '\t')

+					(*entry->activator)(entry->param);

+			}

+			// To do: defer 'right' to parent menus, making sure it doesn't reopen the same submenu

+			break;

+		case KEY_ESC:

+			gui->flags |= GUI_FINISHED_WITH;

+			break;

+	}

+}

+

+

+

+static void gui_menu_update(GUI *gui)

+{

+	// Remove this function?

+	(void)gui;

+}

+

+

+

+typedef struct GUI_MENU_DRAW_ENTRY_DATA

+{

+	GUI *gui;

+	GUI_MENU_DATA *data;

+	int i, y;

+}

+GUI_MENU_DRAW_ENTRY_DATA;

+

+

+

+static void gui_menu_draw_entry_proc(void *data)

+{

+	GUI_MENU_DRAW_ENTRY_DATA *d = data;

+	char *text = d->data->menu->entry[d->i].text;

+

+	clear_to_color(screen, d->i == d->data->sel ? MENU_BG_FOCUS : MENU_BG);

+

+	if (text[0] == '\t') {

+		text++;

+		// Draw an arrow

+	}

+

+	textout(screen, dat[THE_FONT].dat, text, d->gui->x + BORDER_SIZE, d->y + BORDER_SIZE,

+		d->i == d->data->sel ? MENU_FG_FOCUS : MENU_FG);

+}

+

+

+

+static void gui_menu_draw(GUI *gui)

+{

+	GUI_MENU_DRAW_ENTRY_DATA d;

+	d.gui = gui;

+	d.data = gui->data;

+

+	if (gui->flags & GUI_MENU_REDRAW_ALL) {

+		// Redraw the whole menu

+		d.y = gui->y;

+		for (d.i = 0; d.i < d.data->menu->n_entries; d.i++) {

+			subclip(gui->x, d.y, gui->x + gui->w, d.y + TITLE_HEIGHT, &gui_menu_draw_entry_proc, &d);

+			d.y += TITLE_HEIGHT;

+		}

+	} else if (d.data->sel != d.data->lastsel) {

+		if (d.data->lastsel >= 0) {

+			// Redraw the 'lastsel' row

+			d.i = d.data->lastsel;

+			d.y = gui->y + d.i * TITLE_HEIGHT;

+			subclip(gui->x, d.y, gui->x + gui->w, d.y + TITLE_HEIGHT, &gui_menu_draw_entry_proc, &d);

+		}

+		if (d.data->sel >= 0) { // Necessary?

+			// Redraw the 'sel' row

+			d.i = d.data->sel;

+			d.y = gui->y + d.i * TITLE_HEIGHT;

+			subclip(gui->x, d.y, gui->x + gui->w, d.y + TITLE_HEIGHT, &gui_menu_draw_entry_proc, &d);

+		}

+	}

+}

+

+

+

+static void gui_menu_drawn(GUI *gui)

+{

+	GUI_MENU_DATA *data = gui->data;

+

+	gui->flags &= ~GUI_MENU_REDRAW_ALL;

+	data->lastsel = data->sel;

+}

+

+

+

+static void gui_menu_changed_all(GUI *gui)

+{

+	gui->flags |= GUI_MENU_REDRAW_ALL;

+}

+

+

+

+static void gui_menu_changed_active(GUI *gui)

+{

+	// Remove this function?

+	(void)gui;

+}

+

+

+

+GUI_COMMANDS gui_menu_commands = {

+	&gui_menu_create,

+	&gui_menu_destroy,

+	&gui_menu_key,

+	&gui_menu_update,

+	&gui_menu_draw,

+	&gui_menu_drawn,

+	&gui_menu_changed_all,

+	&gui_menu_changed_active

+};

+

+

+

+void gui_menu_get_size(GUI_MENU_PARAM *menu, int *w, int *h)

+{

+	int i;

+

+	*w = 2*BORDER_SIZE + TITLE_HEIGHT; /* A reasonable minimum width */

+	*h = 2*BORDER_SIZE;

+

+	for (i = 0; i < menu->n_entries; i++) {

+		char *text = menu->entry[i].text;

+		int wi = 2*BORDER_SIZE;

+		if (text[0] == '\t') {

+			text++;

+			wi += 10; // Fix this later

+		}

+		wi += text_length(dat[THE_FONT].dat, text);

+		if (wi > *w) *w = wi;

+		*h += TITLE_HEIGHT;

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/studio/src/guiproc.c b/plugins/dumb/dumb-kode54/studio/src/guiproc.c
new file mode 100644
index 00000000..6e53b323
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/src/guiproc.c
@@ -0,0 +1,16 @@
+#include <allegro.h>

+#include "guiproc.h"

+

+

+void draw_bevel(int l, int t, int r, int b, int tl, int m, int br)

+{

+	int n;

+	for (n = 0; n < BEVEL_SIZE; n++) {

+		hline(screen, l + n, t + n, r - 1 - n, tl);

+		putpixel(screen, r - n, t + n, m);

+		vline(screen, l + n, t + 1 + n, b - 1 - n, tl);

+		vline(screen, r - n, t + 1 + n, b - 1 - n, br);

+		putpixel(screen, l + n, b - n, m);

+		hline(screen, l + 1 + n, b - n, r - n, br);

+	}

+}

diff --git a/plugins/dumb/dumb-kode54/studio/src/guitop.c b/plugins/dumb/dumb-kode54/studio/src/guitop.c
new file mode 100644
index 00000000..be5cddf9
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/src/guitop.c
@@ -0,0 +1,131 @@
+#include <allegro.h>

+

+#include "options.h"

+#include "guitop.h"

+#include "guiproc.h"

+#include "dumbdesk.h"

+

+

+

+int the_time;

+

+volatile int true_time;

+static int max_time;

+

+

+

+static void timer_handler(void)

+{

+	if (true_time < max_time)

+		true_time++;

+}

+END_OF_STATIC_FUNCTION(timer_handler);

+

+

+

+#define MAX_SKIP 20

+

+

+

+/*

+Every GUI has a reference to its parent - except the top one.

+

+Main loop:

+   Test keyboard.

+      Esc makes parent GUI active.

+      Other keys go to active GUI, which can do as it pleases.

+   Test mouse.

+      Mouse clicks go to the top GUI.

+         The top GUI may pass them down recursively.

+            A GUI may be marked as mouse-active, for dragging.

+   Update top GUI.

+      Update functions are called recursively.

+         This can be used for animation for example.

+   If there's time, draw top GUI.

+      Draw functions only draw areas marked for redrawing.

+         Marked areas are unmarked once they have been drawn.

+      Draw functions are called recursively.

+         If a child has moved:

+            It will call its parent for the vacated areas.*

+

+The child will have been removed from the parent's list while

+it was drawn, so recursive cycles cannot occur.

+*/

+

+

+

+void run_desktop(GUI_DESKTOP_PARAM *param)

+{

+	GUI *gui = gui_create(

+		&gui_desktop_commands,

+		NULL,

+		0, 0, opt.gfx_w, opt.gfx_h,

+		param

+	);

+

+	if (!gui)

+		return;

+

+	gui_active = gui;

+

+	true_time = the_time = 0;

+	max_time = MAX_SKIP;

+

+	install_int_ex(timer_handler, BPS_TO_TIMER(100));

+

+	for (;;) {

+		gui_draw(gui);

+		gui_drawn(gui);

+

+		while (the_time >= true_time)

+			yield_timeslice();

+

+		while (the_time < true_time) {

+			the_time++;

+

+			/*

+			Test keyboard.

+				Esc makes parent GUI active.

+				Other keys go to active GUI, which can do as it pleases.

+			*/

+			while (keypressed()) {

+				int k = readkey();

+				if (k >> 8 == KEY_ESC) {

+					if (!gui_active->parent) {

+						remove_int(timer_handler);

+						return;

+					}

+					gui_set_active(gui_active->parent);

+				} else

+					gui_key(gui_active, k);

+			}

+

+			/*

+			Test mouse.

+				Mouse clicks go to the top GUI.

+					The top GUI may pass them down recursively.

+						A GUI may be marked as mouse-active, for dragging.

+			*/

+

+			/*

+			Update top GUI.

+				Update functions are called recursively.

+					This can be used for animation for example.

+			*/

+			gui_update(gui);

+		}

+

+		max_time = the_time + MAX_SKIP;

+	}

+

+	gui_destroy(gui);

+}

+

+

+

+void initialise_guitop(void)

+{

+	LOCK_FUNCTION(timer_handler);

+	LOCK_VARIABLE(true_time);

+	LOCK_VARIABLE(max_time);

+}

diff --git a/plugins/dumb/dumb-kode54/studio/src/main.c b/plugins/dumb/dumb-kode54/studio/src/main.c
new file mode 100644
index 00000000..577d40c6
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/src/main.c
@@ -0,0 +1,118 @@
+#include <stdlib.h>

+#include <errno.h>

+#include <allegro.h>

+#include "dumb.h"

+

+#include "options.h"

+#include "guitop.h"

+#include "dumbdesk.h"

+

+

+

+DATAFILE *dat;

+

+

+

+static int load_studio_datafile(void)

+{

+	char ef[256], df[256];

+

+	get_executable_name(ef, 256);

+	replace_filename(df, ef, "studio.dat", 256);

+

+	dat = load_datafile(df);

+

+	if (!dat)

+		return 1;

+

+	return 0;

+}

+

+

+

+static GUI_MENU_ENTRY main_menu_bar_entries[] = {

+	{"File", NULL, NULL},

+	{"Edit", NULL, NULL},

+	{"View", NULL, NULL}

+};

+

+static GUI_MENU_PARAM main_menu_bar = {3, main_menu_bar_entries};

+

+static GUI_DESKTOP_PARAM desktop_param = {"DUMB Studio v0.001", &main_menu_bar};

+

+

+

+int main(void)//(int argc, char *argv[])

+{

+	int old_gfx_w, old_gfx_h;

+	char old_allegro_error[ALLEGRO_ERROR_SIZE];

+

+	if (allegro_init())

+		return 1;

+

+	if (install_timer()) {

+		allegro_message("Unable to initialise timer\n");

+		return 1;

+	}

+

+	if (install_keyboard()) {

+		allegro_message("Unable to initialise keyboard\n");

+		return 1;

+	}

+

+	/*

+	if (install_dumb(&errno, &atexit)) {

+		allegro_message("Unable to initialise the DUMB library\n");

+		return 1;

+	}

+

+	register_sigtype_sample();

+	register_sigtype_combining();

+	register_sigtype_stereopan();

+	register_sigtype_sequence();

+	*/

+

+	initialise_guitop();

+

+	if (load_studio_datafile()) {

+		allegro_message("Unable to load studio.dat\n");

+		return 1;

+	}

+

+	load_options();

+

+	old_gfx_w = opt.gfx_w;

+	old_gfx_h = opt.gfx_h;

+

+	while (set_gfx_mode(GFX_AUTODETECT, opt.gfx_w, opt.gfx_h, 0, 0)) {

+		if (opt.gfx_w == DEF_GFX_W && opt.gfx_h == DEF_GFX_H) {

+			if (opt.gfx_w == old_gfx_w && opt.gfx_h == old_gfx_h) {

+				allegro_message(

+					"Unable to set graphics mode "DEF_GFX_STR"\n%s\n",

+					allegro_error

+				);

+			} else {

+				allegro_message(

+					"Unable to set graphics mode %dx%d\n%s\n"

+					"Unable to revert to graphics mode "DEF_GFX_STR"\n%s\n",

+					old_gfx_w, old_gfx_h,

+					old_allegro_error,

+					allegro_error

+				);

+			}

+			return 1;

+		}

+

+		opt.gfx_w = DEF_GFX_W;

+		opt.gfx_h = DEF_GFX_H;

+		ustrncpy(old_allegro_error, allegro_error, ALLEGRO_ERROR_SIZE);

+	}

+

+	text_mode(-1);

+

+	run_desktop(&desktop_param);

+

+	return 0;

+}

+END_OF_MAIN();

+

diff --git a/plugins/dumb/dumb-kode54/studio/src/options.c b/plugins/dumb/dumb-kode54/studio/src/options.c
new file mode 100644
index 00000000..e387db13
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/src/options.c
@@ -0,0 +1,31 @@
+#include <stdlib.h>

+#include <allegro.h>

+#include "options.h"

+

+

+

+void load_options(void)

+{

+	{

+		char ef[256], cf[256];

+

+		get_executable_name(ef, 256);

+		replace_filename(cf, ef, "studio.ini", 256);

+

+		set_config_file(cf);

+	}

+

+	opt.gfx_w = get_config_int("options", "gfx_w", DEF_GFX_W);

+	opt.gfx_h = get_config_int("options", "gfx_h", DEF_GFX_H);

+

+	atexit(&save_options);

+}

+

+

+

+void save_options(void)

+{

+	set_config_int("options", "gfx_w", opt.gfx_w);

+	set_config_int("options", "gfx_h", opt.gfx_h);

+}

+

diff --git a/plugins/dumb/dumb-kode54/studio/src/subclip.c b/plugins/dumb/dumb-kode54/studio/src/subclip.c
new file mode 100644
index 00000000..ef1a9137
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/studio/src/subclip.c
@@ -0,0 +1,33 @@
+#include <allegro.h>

+

+#include "subclip.h"

+

+

+

+void subclip(int l, int t, int r, int b, void (*proc)(void *data), void *data)

+{

+	int cl = screen->cl;

+	int ct = screen->ct;

+	int cr = screen->cr;

+	int cb = screen->cb;

+

+	if (l < cl) l = cl;

+	if (t < ct) t = ct;

+	if (r > cr) r = cr;

+	if (b > cb) b = cb;

+

+	if (r > l && b > t) {

+		screen->cl = l;

+		screen->ct = t;

+		screen->cr = r;

+		screen->cb = b;

+

+		(*proc)(data);

+

+		screen->cl = cl;

+		screen->ct = ct;

+		screen->cr = cr;

+		screen->cb = cb;

+	}

+}

+

diff --git a/plugins/dumb/dumb-kode54/todo.txt b/plugins/dumb/dumb-kode54/todo.txt
new file mode 100644
index 00000000..d624a8d4
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/todo.txt
@@ -0,0 +1,141 @@
+al_duh_get_volume()

+

+* [23:25:12] <Mahogny> I prefer an API datagram :)

+

+* Create a glossary of terms like 'render', 'sigrenderer', etc.?

+

+* Consider the order in which stuff appears in dumb.h, and dumb.txt?

+

+

+PROPOSED CHANGE OF TERMINOLOGY:

+

+Current situation:

+

+   A DUH comprises a number of "signals". A signal is an entity capable of

+   producing a stream of audio. When a signal is called upon to generate

+   sound, it may in turn call upon any other signals in the DUH and use the

+   sound from those in generating its own.

+

+   There are a number of "sigtypes", including 'SAMP' (a sample) and 'SEQU'

+   (a sequence). Every signal in a DUH must be of one of these known types.

+   Every sigtype is characterised by a four-byte identifier and the

+   following function prototypes:

+

+      typedef void signal_t;

+      typedef void sampinfo_t;

+

+      signal_t *load_signal(DUH *duh, DUMBFILE *file);

+      sampinfo_t *start_samples(DUH *duh, signal_t *signal, int n_channels, long pos);

+      void set_parameter(sampinfo_t *sampinfo, unsigned char id, long value);

+      long render_samples(sampinfo_t *sampinfo, float volume, float delta, long size, sample_t **samples);

+      void end_samples(sampinfo_t *sampinfo);

+      void unload_signal(signal_t *signal);

+

+   When a signal in a DUH needs to be loaded, DUMB's core first checks the

+   identifier. If it is unknown, load_duh() fails. Each known sigtype will

+   have pointers to the above functions, so DUMB's core will then call the

+   load_signal() function. This loads the "signal", which could consist of

+   sample data, or sequence data (like the patterns in a music module).

+   (There's ambiguity here; we use the word "signal" for the whole entity

+   and also for the specific data that distinguish it from other signals of

+   the same sigtype.)

+

+   Once a signal is in memory, it can be used to generate sound. Its

+   start_samples() function is called for that, and a "sampinfo" block is

+   returned; this will contain the current position and any necessary state

+   information. render_samples() generates sound, and end_samples() destroys

+   the sampinfo block.

+

+   DUMB's support for existing file formats is implemented as follows. First

+   a signal_t is constructed manually by reading the file. Then the special

+   make_duh() function is called. This creates a DUH struct with just one

+   signal in it, the one we just created. We provide all the above

+   functions, except load_signal(), since that has been bypassed. DUMB's

+   core now has our start_samples() etc. function for generating the sound,

+   and it has our unload_signal() function for getting the file out of

+   memory when we're done.

+

+   It is possible with some sigtypes to adjust their sound using

+   "parameters". set_parameter() is called for this. An example would be

+   changing the cut-off frequency for a signal that acts as a filter. I plan

+   to add a second version of this function that takes a pointer. This would

+   be used when manipulating DUHs in code; an example is when installing a

+   callback function for a music module file. It couldn't be used by a file

+   on disk.

+

+This terminology is far from intuitive. Here are some proposals:

+

+- The things DUHs are made of can still be called "signals".

+- The types of signal can still be called "sigtypes" ("signal types").

+- The signal-specific data can be called the "sigdata" ("signal data").

+- The sampinfo block can be renamed to a "sigrenderer" ("signal renderer").

+- The parameters can be called "sigparams" ("signal parameters").

+

+This way we have some consistency between different parts of the library;

+the API for rendering a DUH as a whole uses the term "renderer". We also

+have a full name and an abbreviation for each term.

+

+Any advances on this?

+

+---

+

+Todo/Wishlist:

+

+* MOD/XM loading - change the effect memory system; it isn't robust when it

+                   comes to remembering stuff from one pattern to the next.

+* --- IMPORTANT --- Put link to IT in docs: http://www.noisemusic.org/it/

+* --- IMPORTANT --- Twist the sample decompression algorithm around, since

+                    it was derived from a GPL'd algorithm. We don't want

+                    to have to put it under GPL! :) ... or, find out that it

+                    wasn't originally written under the GPL and then credit

+                    the bloke who wrote it :)

+* MMX resamplers and downsamplers

+* Ability to load *.it, *.xm directly into DUH structs (IT done)

+* Ability to embed IT compressed samples... no, it's copyrighted. Let's do

+    our own :)

+* Ability to embed ITs themselves (? not sure how useful that is)

+* Remove cit.c

+* Check all return values. I think the Winamp plug-in needs looking at...

+* resample.c - it seems x*y is safe if 0<=x<=65535 and -32768<=y<=32768 or

+               vice versa. Check this is true on all compilers. If so, make

+			   use of it to gain more accuracy.

+* DUMB_IDs should always be long or always be int...

+* Decide whether the load_signal function really needs the DUH parameter...

+* Allow for DUH modularity; different pieces share samples etc.

+

+* Fix makefile so it can manage without alld - or put note in the FAQ that

+  ppl must build alld

+* Arrange to detect file types by extension (probably not by content though)

+* Change aldmbd to aldmd in makefiles to maintain 8.3 compatibility

+* Put dumb_resampling_quality and dumb_it_max_to_mix in howto.txt

+* More info in howto.txt, in particular that install_sound() is needed...

+* Add a sanity check for restart_position?

+* Note in docs to let entheh know if you release a game using DUMB

+

+

+STUFF TO FIX FOR THE FIRST RELEASE

+==================================

+

+General

+-------

+* Naming is a bit confusing sometimes...

+* What to do about ASSERT() and TRACE() - they were hacked in when

+  the lib was split from Allegro, and they need replacing.

+* Add some constants to dumb.h (DUMB_VERSION_STR etc.)

+

+entheh

+------

+* Update docs, write more docs (a lot to do here!)

+* Go through, eliminate warnings, resolve some "/** WARNING" comments

+  (they used to be #warning but Bob complained :)

+* Program it to calculate the length of IT and S3M files (currently

+  always set to 10 minutes IIRC)

+

+Bob

+---

+* dumb_resample() now has a volume parameter, so there are some extra

+  floating-point multiply ops that could possibly be optimised.

+

+tjaden

+------

+* Test on Linux when it's all ready plz :)

diff --git a/plugins/dumb/dumb-kode54/tools/cit.c b/plugins/dumb/dumb-kode54/tools/cit.c
new file mode 100644
index 00000000..3bda6392
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/tools/cit.c
@@ -0,0 +1,2968 @@
+/* These #defines are TEMPORARY. They are used to write alternative code to

+ * handle ambiguities in the format specification. The correct code in each

+ * case will be determined most likely by experimentation.

+ */

+#define STEREO_SAMPLES_COUNT_AS_TWO

+#define INVALID_ORDERS_END_SONG

+#define SUSTAIN_LOOP_OVERRIDES_NORMAL_LOOP

+#define VOLUME_OUT_OF_RANGE_SETS_MAXIMUM

+

+

+

+#include <stdio.h>//temporary

+

+

+

+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * cit.c - IT Compiler                                / / \  \

+ *                                                   | <  /   \_

+ * Derived from an IT file loader by Bob.            |  \/ /\   /

+ *                                                    \_  /  > /

+ * Written by entheh. Barely works. A complete          | \ / /

+ * mess.                                                |  ' /

+ *                                                       \__/

+ */

+

+#include <string.h>

+#include <math.h>

+#include "allegro.h"

+

+

+

+#define MUSIC_IT AL_ID('I','M','P','M')

+

+

+

+typedef struct MODULE_MUSIC_INFO {

+	char Name[29];

+    int Type;

+} MODULE_MUSIC_INFO;

+

+#define ENVELOPE_ON 1

+#define ENVELOPE_LOOP_ON 2

+#define ENVELOPE_SUSTAINLOOP 4

+#define ENVELOPE_PITCH_IS_FILTER 128

+

+typedef struct MODULE_ENVELOPE {

+	unsigned char Flag,

+    	NumNodes,

+        LoopBegin, LoopEnd, SustainLoopBegin, SustainLoopEnd; //in nodes.

+    char NodeY[25];

+    short NodeTick[25];

+} MODULE_ENVELOPE;

+

+typedef struct MODULE_VENVELOPE {

+    unsigned char NextNode;

+    unsigned short CurTick;

+} MODULE_VENVELOPE;

+

+#define NNA_NOTECUT      0

+#define NNA_NOTECONTINUE 1

+#define NNA_NOTEOFF      2

+#define NNA_NOTEFADE     3

+

+#define DCT_OFF 0

+#define DCT_NOTE 1

+#define DCT_SAMPLE 2

+#define DCT_INSTRUMENT 3

+

+#define DCA_CUT 0

+#define DCA_NOTEOFF 1

+#define DCA_NOTEFADE 2

+

+typedef struct MODULE_INSTRUMENT {

+	//unsigned char Flag;

+    char VolumeLoopNodeStart, VolumeLoopNodeEnd;

+    char SustainLoopNodeStart, SustainLoopNodeEnd;

+    char DuplicateCheckType;

+    char DuplicateCheckAction;

+    char NewNoteAction;

+    int FadeOut;

+

+    unsigned char PitchPanSeparation, //0->64, Bit7: Don't use

+    	PitchPanCenter; //Note, from C-0 to B-9

+    unsigned char GlobalVolume, //0->128

+    	DefaultPan; //0->64, Bit7: Don't use

+	unsigned char RandomVolume, RandomPanning;

+

+	unsigned char FilterCutOff;

+	unsigned char FilterResonance;

+

+    unsigned char NoteSample[120];

+    unsigned char NoteNote[120];

+

+    MODULE_ENVELOPE VolumeEnvelope, PanningEnvelope, PitchEnvelope;

+} MODULE_INSTRUMENT;

+

+#define SAMPLE_HASSAMPLE       1

+#define SAMPLE_16BIT           2

+#define SAMPLE_STEREO          4

+#define SAMPLE_USELOOP        16

+#define SAMPLE_USESUSTAINLOOP 32

+#define SAMPLE_PINGPONGLOOP   64

+#define SAMPLE_PINGPONGSUSTAINLOOP 128

+

+#define VIBRATO_SINE 0

+#define VIBRATO_RAMPDOWN 1

+#define VIBRATO_SQUARE 2

+#define VIBRATO_RANDOM 3

+

+typedef struct MODULE_SAMPLE {

+	unsigned char GlobalVolume; //0->64

+    unsigned char Flag;

+    unsigned char DefaultVolume;

+	unsigned char DefaultPanning;

+    int SampleLength; //in samples, not bytes !

+    int LoopBegin, LoopEnd; //in samples

+    int SustainLoopBegin, SustainLoopEnd;

+    int C5Speed; //Number of bytes/sec for C-5

+

+    SAMPLE *Sample;

+

+    char VibratoSpeed; //0->64

+    char VibratoDepth; //0->64

+    char VibratoWaveForm;

+    char VibratoRate; //0->64

+} MODULE_SAMPLE;

+

+#define NOTEMASK_NOTE        1

+#define NOTEMASK_INSTRUMENT  2

+#define NOTEMASK_VOLPAN      4

+#define NOTEMASK_COMMAND     8

+

+#define NOTE_OFF 255

+#define NOTE_CUT 254

+

+typedef struct MODULE_NOTE {

+	char Mask;

+	char Channel; //if -1, then end of row.    

+    unsigned char Note;

+    char Instrument;

+    unsigned char VolPan;

+    unsigned char Command, CommandValue;

+} MODULE_NOTE;

+

+typedef struct MODULE_PATTERN {

+	int NumRows;

+    int NumNotes;

+    MODULE_NOTE *Note;

+} MODULE_PATTERN;

+

+#define VCHANNEL_PLAYING    1

+#define VCHANNEL_BACKGROUND 2

+#define VCHANNEL_FADING     4

+#define VCHANNEL_RETRIG     8

+

+struct MODULE_CHANNEL;

+

+typedef struct MODULE_VCHANNEL {

+	unsigned char Flag;

+	unsigned char Instrument;

+	unsigned char Note;

+	unsigned int Volume;

+	unsigned char Pan;

+	signed char PanSep;

+

+	MODULE_SAMPLE *sample;

+

+	int pitch; /* 0 corresponds to C-5, 256 is one semitone. */

+

+	MODULE_VENVELOPE VVolEnv;

+	int fadeoutcount;

+

+	/* WARNING: search for BLEARGH when adding to this struct. */

+/*

+	MODULE_SAMPLE *Sample;  //NULL is unused

+    char voice;

+    char ChannelVolume;

+    char NoteOn;

+    char NNA;

+    short FadeOutCount, FadeOut;

+    float MixVolume, MixPan;

+    MODULE_VENVELOPE *VVolumeEnvelope, *VPanningEnvelope, *VPitchEnvelope;

+    struct MODULE_VCHANNEL *next, *prev;

+*/

+	unsigned char NNA;

+

+	unsigned int DUHvol, DUHpan;

+

+	struct MODULE_CHANNEL *channel;

+} MODULE_VCHANNEL;

+

+#define CHANNEL_RETRIG 1

+

+typedef struct MODULE_CHANNEL {

+	unsigned int ID;

+	unsigned char Flag;

+	unsigned char Note;

+	unsigned char Instrument;

+	unsigned char Volume; //0->64

+    unsigned char Pan;    //0->32->64, 100 = surround, Bit7: Disable

+	signed char PanSep;

+

+	int pitch;

+

+	unsigned char ChannelVolume;

+

+	unsigned char lastvolslide;

+	unsigned char lastDKL, lastN, lastW, lastEF, lastG, lastT;

+	int portamento, toneporta;

+	signed char volslide;

+	signed char channelvolslide;

+

+	MODULE_SAMPLE *sample;

+

+    MODULE_VCHANNEL *VChannel;

+} MODULE_CHANNEL;

+

+#define FLAG_STEREO         1

+#define FLAG_USEINSTRUMENTS 4

+#define FLAG_LINEARSLIDES   8 /* If not set, use Amiga slides */

+#define FLAG_OLDEFFECT     16

+#define FLAG_COMPATIBLEGXX 32

+

+#define ORDER_END 255

+#define ORDER_SKIP 254

+

+typedef struct MODULE {

+	MODULE_INSTRUMENT *Instrument;

+    MODULE_SAMPLE *Sample;

+    MODULE_PATTERN *Pattern;

+

+	int NumOrders;

+    int NumInstruments;

+    int NumSamples;

+    int NumPatterns;

+    int Flags;

+    short Version;

+    unsigned char GlobalVolume;

+	signed char globalvolslide;

+    unsigned char MixVolume;

+    unsigned char Speed, Tempo, tick;

+	signed char temposlide;

+    unsigned char PanningSeparation;

+

+    unsigned char *Order;

+

+    MODULE_CHANNEL Channel[64];

+	MODULE_VCHANNEL VChannel[256];

+

+	int processorder;

+	int processrow;

+	int breakrow;

+	int rowcount;

+} MODULE;

+

+

+

+#define IT_SET_SPEED             1

+#define IT_JUMP_TO_ORDER         2

+#define IT_BREAK_TO_ROW          3

+#define IT_VOLUME_SLIDE          4

+#define IT_PORTAMENTO_DOWN       5

+#define IT_PORTAMENTO_UP         6

+#define IT_TONE_PORTAMENTO       7

+#define IT_VIBRATO               8

+#define IT_TREMOR                9

+#define IT_ARPEGGIO             10

+#define IT_VOLSLIDE_VIBRATO     11

+#define IT_VOLSLIDE_TONEPORTA   12

+#define IT_SET_CHANNEL_VOLUME   13

+#define IT_CHANNEL_VOLUME_SLIDE 14

+#define IT_SET_SAMPLE_OFFSET    15

+#define IT_PANNING_SLIDE        16

+#define IT_RETRIGGER_NOTE       17

+#define IT_TREMOLO              18

+#define IT_S                    19

+#define IT_SET_SONG_TEMPO       20

+#define IT_FINE_VIBRATO         21

+#define IT_SET_GLOBAL_VOLUME    22

+#define IT_GLOBAL_VOLUME_SLIDE  23

+#define IT_SET_PANNING          24

+#define IT_PANBRELLO            25

+#define IT_MIDI_MACRO           26 //see MIDI.TXT

+

+

+

+/* These represent the top nibble of the command value. */

+#define IT_S_SET_FILTER              0 /* Greyed out in IT... */

+#define IT_S_SET_GLISSANDO_CONTROL   1 /* Greyed out in IT... */

+#define IT_S_FINETUNE                2 /* Greyed out in IT... */

+#define IT_S_SET_VIBRATO_WAVEFORM    3

+#define IT_S_SET_TREMOLO_WAVEFORM    4

+#define IT_S_SET_PANBRELLO_WAVEFORM  5

+#define IT_S_FINE_PATTERN_DELAY      6

+#define IT_S7                        7

+#define IT_S_SET_PAN                 8

+#define IT_S_SET_SURROUND_SOUND      9

+#define IT_S_SET_HIGH_OFFSET        10

+#define IT_S_PATTERN_LOOP           11

+#define IT_S_DELAYED_NOTE_CUT       12

+#define IT_S_NOTE_DELAY             13

+#define IT_S_PATTERN_DELAY          14

+#define IT_S_SET_MIDI_MACRO         15

+

+/*

+S0x Set filter

+S1x Set glissando control

+S2x Set finetune

+

+

+S3x Set vibrato waveform to type x

+S4x Set tremelo waveform to type x

+S5x Set panbrello waveform to type x

+  Waveforms for commands S3x, S4x and S5x:

+    0: Sine wave

+    1: Ramp down

+    2: Square wave

+    3: Random wave

+S6x Pattern delay for x ticks

+S70 Past note cut

+S71 Past note off

+S72 Past note fade

+S73 Set NNA to note cut

+S74 Set NNA to continue

+S75 Set NNA to note off

+S76 Set NNA to note fade

+S77 Turn off volume envelope

+S78 Turn on volume envelope

+S79 Turn off panning envelope

+S7A Turn on panning envelope

+S7B Turn off pitch envelope

+S7C Turn on pitch envelope

+S8x Set panning position

+S91 Set surround sound

+SAy Set high value of sample offset yxx00h

+SB0 Set loopback point

+SBx Loop x times to loopback point

+SCx Note cut after x ticks

+SDx Note delay for x ticks

+SEx Pattern delay for x rows

+SFx Set parameterised MIDI Macro

+*/

+

+

+

+typedef struct MODULE_PLAY {

+	MODULE *Music;

+    int Loop, Tick;

+    int CurOrder, CurPattern, CurPos;

+    int Command, CommandVal0, CommandVal1, CommandVal2;

+    int pos;

+} MODULE_PLAY;

+extern MODULE_PLAY *song;

+

+extern int IT_Play_Method;

+

+MODULE *load_it(char*);

+//int get_module_size(MODULE *);

+

+int play_it(MODULE *j, int loop);

+void install_module();

+void set_mix_volume(int i);

+

+void stop_it();

+int is_music_done();

+void destroy_it(MODULE *j);

+

+//Should be internal:

+extern MODULE_PLAY *song;

+extern int note_freq[120];

+

+//extern void MOD_Interrupt(...);

+extern int MOD_Poller(void*);

+

+#define IT_TIMER 0

+#define IT_POLL  1

+

+/* typedef.hpp */

+

+typedef unsigned char byte;

+typedef unsigned short word;

+typedef unsigned int dword;

+

+/* load_it.cpp */

+

+/*

+int	detect_it(char *f) {

+	int	sig;

+	PACKFILE *fn = pack_fopen(f, F_READ);

+	

+	if (fn == NULL)

+		return FALSE;

+

+	sig	= pack_mgetl(fn);

+	if (sig	!= MUSIC_IT) {

+		pack_fclose(fn);

+		return FALSE;

+	}

+	pack_fclose(fn);

+

+	return TRUE;

+}

+*/

+

+

+

+MODULE *create_it() {

+	MODULE *m = (MODULE*)malloc(sizeof(MODULE));

+	if (!m)

+		return NULL;

+	memset(m, 0, sizeof(MODULE));

+	return m;

+}

+

+

+

+void destroy_it(MODULE *j) {

+

+	int i;

+

+	if (j) {

+		/* Remove patterns. */

+		if (j->Pattern) {

+			for (i = 0; i < j->NumPatterns; i++)

+				free(j->Pattern[i].Note);

+			free(j->Pattern);

+		}

+

+		/* Remove instruments. */

+		free(j->Instrument);

+

+		/* Remove samples. */

+		if (j->Sample) {

+			for (i = 0; i < j->NumSamples; i++)

+				destroy_sample(j->Sample[i].Sample);

+			free(j->Sample);

+		}

+

+		/* Remove orders. */

+		free(j->Order);

+

+		free(j);

+	}

+}

+

+

+

+//#define DEBUG_IT_SIZE

+

+/*

+int	get_module_size(MODULE	*j)	{

+	int	a, b, c, d = 0,	e;

+    int i;

+	a =	sizeof(MODULE) + j->NumOrders;

+	b =	j->NumInstruments * sizeof(MODULE_INSTRUMENT);

+	c =	j->NumSamples * sizeof(MODULE_SAMPLE);

+	

+	for	(i=0; i<j->NumSamples; i++)

+		d += j->Sample[i].SampleLength * (j->Sample[i].Flag	& 2	? sizeof(short)	: 1) * (j->Sample[i].Flag &	4 ?	2: 1);

+		

+	e =	4 +	sizeof(MODULE_PATTERN) * j->NumPatterns;

+	

+	for	(i=0; i<j->NumPatterns;	i++)

+		e += j->Pattern[i].NumNotes	* sizeof(MODULE_NOTE);

+	#ifdef DEBUG_IT_SIZE

+	fprintf(stderr, "Base: %i, Instruments(%i): %i, Samples(%i): %i, Data: %i, Patterns(%i): %i\n", a, j->NumInstruments, b,	j->NumSamples, c, d, j->NumPatterns, e);

+	#endif

+

+	return a+b+c+d+e;

+}

+*/

+

+

+

+#define	MAX_IT_CHN 64

+

+//#define DEBUG_HEADER

+//#define DEBUG_INSTRUMENTS

+//#define DEBUG_SAMPLES

+//#define DEBUG_PATTERNS

+

+static dword *sourcebuf	= NULL;

+static dword *sourcepos	= NULL;

+static byte	rembits	= 0;

+

+int	readblock(PACKFILE *f) {

+	long size;

+	int	c =	pack_igetw(f);

+	if (c == -1)

+		return 0;

+	size = c;

+

+	sourcebuf =	(dword*)malloc(size+4);

+	if (!sourcebuf)

+		return 0;

+		

+	c =	pack_fread(sourcebuf, size,	f);

+	if (c <	1) {

+		free(sourcebuf);

+		sourcebuf =	NULL;

+		return 0;		 

+	}

+	sourcepos =	sourcebuf;

+	rembits	= 32;

+	return 1;

+}

+

+void freeblock() {

+	if (sourcebuf)

+		free(sourcebuf);

+	sourcebuf =	NULL;	 

+}

+

+dword readbits(char	b) {

+	dword val;

+	if (b <= rembits) {

+		val	= *sourcepos & ((1 << b) - 1);

+		*sourcepos >>= b;

+		rembits	-= b;

+	}

+	else {

+		dword nbits	= b	- rembits;

+		val	= *sourcepos;

+		sourcepos++;

+		val	|= ((*sourcepos	& ((1 << nbits)	- 1)) << rembits);

+		*sourcepos >>= nbits;

+		rembits	= 32 - nbits;

+	}

+	return val;

+}

+

+void decompress8(PACKFILE *f, void *data, int len, int tver) {

+	char *destbuf =	(char*)data;

+	char *destpos =	destbuf;

+	int	blocklen, blockpos;

+	byte bitwidth;

+	word val;

+	char d1, d2;

+

+	memset(destbuf,	0, len);

+

+	while (len>0) {

+		//Read a block of compressed data:

+		if (!readblock(f))

+			return;

+		//Set up a few variables

+		blocklen = (len	< 0x8000) ?	len	: 0x8000; //Max block length is 0x8000 bytes

+		blockpos = 0;

+		bitwidth = 9;

+		d1 = d2	= 0;

+		//Start the decompression:

+		while (blockpos	< blocklen)	{

+			//Read a value:

+			val	= readbits(bitwidth);

+			//Check for bit width change:

+			

+			if (bitwidth < 7) {	//Method 1:

+				if (val	== (1 << (bitwidth - 1))) {

+					val	= readbits(3) +	1;

+					bitwidth = (val	< bitwidth)	? val :	val	+ 1;

+					continue;

+				}

+			}

+			else if	(bitwidth <	9) { //Method 2

+				byte border	= (0xFF	>> (9 -	bitwidth)) - 4;

+

+				if (val	> border &&	val	<= (border + 8)) {

+					val	-= border;

+					bitwidth = (val	< bitwidth)	? val :	val	+ 1;

+					continue;

+				}

+			}

+			else if	(bitwidth == 9)	{ //Method 3

+				if (val	& 0x100) {

+					bitwidth = (val	+ 1) & 0xFF;

+					continue;

+				}

+			}

+			else { //Illegal width, abort ?

+				freeblock();

+				return;

+			}

+

+			//Expand the value to signed byte:

+            {

+			char v;	//The sample value:

+			if (bitwidth < 8) {

+				byte shift = 8 - bitwidth;

+				v =	(val <<	shift);

+				v >>= shift;

+			}

+			else

+				v =	(char)val;

+				

+			//And integrate the sample value

+			//(It always has to end with integration doesn't it ? ;-)

+			d1 += v;

+			d2 += d1;

+            }

+

+			//Store !

+			*destpos = ((tver == 0x215)	? d2 : d1);

+			destpos++;

+			blockpos++;

+		}

+		freeblock();

+		len	-= blocklen;

+	}

+	return;

+}

+

+void decompress16(PACKFILE *f, void	*data, int len,	int	tver) {

+	//make the output buffer:

+	short *destbuf = (short*)data;

+	short *destpos = destbuf;

+	int	blocklen, blockpos;

+	byte bitwidth;

+	long val;

+	short d1, d2;

+

+	memset(destbuf,	0, len);

+

+	while (len>0) {

+		//Read a block of compressed data:

+		if (!readblock(f))

+			return;

+		//Set up a few variables

+		blocklen = (len	< 0x4000) ?	len	: 0x4000; // Max block length is 0x4000 bytes

+		blockpos = 0;

+		bitwidth = 17;

+		d1 = d2	= 0;

+		//Start the decompression:

+		while (blockpos	< blocklen)	{

+			val	= readbits(bitwidth);

+			//Check for bit width change:

+			

+			if (bitwidth < 7) {	//Method 1:

+				if (val	== (1 << (bitwidth - 1))) {

+					val	= readbits(4) +	1;

+					bitwidth = (val	< bitwidth)	? val :	val	+ 1;

+					continue;

+				}

+			}

+			else if	(bitwidth <	17)	{ //Method 2

+				word border	= (0xFFFF >> (17 - bitwidth)) -	8;

+

+				if (val	> border &&	val	<= (border + 16)) {

+					val	-= border;

+					bitwidth = val < bitwidth ?	val	: val +	1;

+					continue;

+				}

+			}

+			else if	(bitwidth == 17) { //Method 3

+				if (val	& 0x10000) {

+					bitwidth = (val	+ 1) & 0xFF;

+					continue;

+				}

+			}

+			else { //Illegal width, abort ?

+				freeblock();

+				return;

+			}

+

+			//Expand the value to signed byte:

+            {

+			short v; //The sample value:

+			if (bitwidth < 16) {

+				byte shift = 16	- bitwidth;

+				v =	(val <<	shift);

+				v >>= shift;

+			}

+			else

+				v =	(short)val;

+				

+			//And integrate the sample value

+			//(It always has to end with integration doesn't it ? ;-)

+			d1 += v;

+			d2 += d1;

+            }

+

+			//Store !

+			*destpos = ((tver == 0x215)	? d2 : d1);

+			destpos++;

+			blockpos++;

+		}

+		freeblock();

+	   	len	-= blocklen;

+	}

+	return;

+}

+

+

+

+void read_envelopes(PACKFILE *f, MODULE *j, int i)

+{

+	int k;

+

+	j->Instrument[i].VolumeEnvelope.Flag = pack_getc(f);

+	j->Instrument[i].VolumeEnvelope.NumNodes = pack_getc(f);

+	j->Instrument[i].VolumeEnvelope.LoopBegin =	pack_getc(f);

+	j->Instrument[i].VolumeEnvelope.LoopEnd	= pack_getc(f);

+	j->Instrument[i].VolumeEnvelope.SustainLoopBegin = pack_getc(f);

+	j->Instrument[i].VolumeEnvelope.SustainLoopEnd = pack_getc(f);

+	for (k = 0; k < j->Instrument[i].VolumeEnvelope.NumNodes; k++) {

+		j->Instrument[i].VolumeEnvelope.NodeY[k] = pack_getc(f);

+		j->Instrument[i].VolumeEnvelope.NodeTick[k]	= pack_igetw(f);

+	}

+	pack_fseek(f, 75 - j->Instrument[i].VolumeEnvelope.NumNodes	* 3);

+

+	j->Instrument[i].PanningEnvelope.Flag =	pack_getc(f);

+	j->Instrument[i].PanningEnvelope.NumNodes =	pack_getc(f);

+	j->Instrument[i].PanningEnvelope.LoopBegin = pack_getc(f);

+	j->Instrument[i].PanningEnvelope.LoopEnd = pack_getc(f);

+	j->Instrument[i].PanningEnvelope.SustainLoopBegin =	pack_getc(f);

+	j->Instrument[i].PanningEnvelope.SustainLoopEnd	= pack_getc(f);

+	for (k = 0; k < j->Instrument[i].PanningEnvelope.NumNodes; k++)	{

+		j->Instrument[i].PanningEnvelope.NodeY[k] =	pack_getc(f);

+		j->Instrument[i].PanningEnvelope.NodeTick[k] = pack_igetw(f);

+	}

+	pack_fseek(f, 75 - j->Instrument[i].PanningEnvelope.NumNodes * 3);

+

+	j->Instrument[i].PitchEnvelope.Flag	= pack_getc(f);

+	j->Instrument[i].PitchEnvelope.NumNodes	= pack_getc(f);

+	j->Instrument[i].PitchEnvelope.LoopBegin = pack_getc(f);

+	j->Instrument[i].PitchEnvelope.LoopEnd = pack_getc(f);

+	j->Instrument[i].PitchEnvelope.SustainLoopBegin	= pack_getc(f);

+	j->Instrument[i].PitchEnvelope.SustainLoopEnd =	pack_getc(f);

+	for (k = 0; k < j->Instrument[i].PitchEnvelope.NumNodes; k++) {

+		j->Instrument[i].PitchEnvelope.NodeY[k]	= pack_getc(f);

+		j->Instrument[i].PitchEnvelope.NodeTick[k] = pack_igetw(f);

+	}

+}

+

+

+

+MODULE *load_old_instrument(char *file, long offset, MODULE *j, int i)

+{

+	int k;

+	PACKFILE *f = pack_fopen(file, F_READ);

+

+	if (!f) {

+		#ifdef DEBUG_INSTRUMENTS

+		fprintf(stderr, "Error reopening!\n");

+		#endif

+		destroy_it(j);

+		return NULL;

+	}

+

+	pack_fseek(f, offset);

+

+	if (pack_mgetl(f) != AL_ID('I','M','P','I')) {

+		destroy_it(j);

+		return NULL;

+	}

+

+	/* Skip DOS Filename */

+	pack_fseek(f, 13);

+

+	j->Instrument[i].VolumeEnvelope.Flag = pack_getc(f);

+	j->Instrument[i].VolumeEnvelope.LoopBegin = pack_getc(f);

+	j->Instrument[i].VolumeEnvelope.LoopEnd = pack_getc(f);

+	j->Instrument[i].VolumeEnvelope.SustainLoopBegin = pack_getc(f);

+	j->Instrument[i].VolumeEnvelope.SustainLoopEnd = pack_getc(f);

+

+	/* Two unused bytes */

+	pack_fseek(f, 2);

+

+	/* OLD FadeOut:  Ranges between 0 and 64, but the fadeout "Count" is 512.

+	 * NEW FadeOut:  Ranges between 0 and 128, but the fadeout "Count" is 1024

+	 *

+	 * TODO: Find out what this means, and make adjustments accordingly.

+	 */

+	j->Instrument[i].FadeOut = pack_igetw(f) << 1;

+	j->Instrument[i].NewNoteAction = pack_getc(f);

+	j->Instrument[i].DuplicateCheckType = pack_getc(f);

+	j->Instrument[i].DuplicateCheckAction = DCA_CUT; /* This might be wrong! */

+

+	/* Skip Tracker Version and Number of Samples. These are only used in

+	 * separate instrument files. Also skip unused bytes and Instrument Name.

+ 	 */

+	pack_fseek(f, 36);

+

+	j->Instrument[i].PitchPanSeparation = 0;

+	j->Instrument[i].PitchPanCenter = 60;

+	j->Instrument[i].GlobalVolume = 128; /* Should this be 64 or something? */

+	j->Instrument[i].DefaultPan = 32; /* Should this be 128? */

+	j->Instrument[i].RandomVolume = 0;

+	j->Instrument[i].RandomPanning = 0;

+

+	for	(k = 0; k < 120; k++) {

+		j->Instrument[i].NoteNote[k] = pack_getc(f);

+		j->Instrument[i].NoteSample[k] = pack_getc(f);

+	}

+

+	/* Skip "Volume envelope (200 bytes)" - need to know better what this is

+	 * for though.

+	 */

+	pack_fseek(f, 200);

+

+	fprintf(stderr, "Inst %02d Env:", i);

+

+	for (j->Instrument[i].VolumeEnvelope.NumNodes = 0;

+		 j->Instrument[i].VolumeEnvelope.NumNodes < 25;

+		 j->Instrument[i].VolumeEnvelope.NumNodes++)

+	{

+		j->Instrument[i].VolumeEnvelope.NodeTick[k]	= pack_getc(f);

+		j->Instrument[i].VolumeEnvelope.NodeY[k] = pack_getc(f);

+

+		fprintf(stderr, " %d,%d",

+				j->Instrument[i].VolumeEnvelope.NodeTick[k],

+				j->Instrument[i].VolumeEnvelope.NodeY[k]);

+	}

+	pack_fseek(f, 50 - j->Instrument[i].VolumeEnvelope.NumNodes	* 2);

+

+	fprintf(stderr, "\n");

+

+	j->Instrument[i].FilterCutOff = 0;    //Are these the right values

+	j->Instrument[i].FilterResonance = 0; //to disable the filter?

+

+	j->Instrument[i].PanningEnvelope.Flag =	0;

+	j->Instrument[i].PanningEnvelope.NumNodes =	0;

+	j->Instrument[i].PanningEnvelope.LoopBegin = 0;

+	j->Instrument[i].PanningEnvelope.LoopEnd = 0;

+	j->Instrument[i].PanningEnvelope.SustainLoopBegin =	0;

+	j->Instrument[i].PanningEnvelope.SustainLoopEnd	= 0;

+

+	j->Instrument[i].PitchEnvelope.Flag	= 0;

+	j->Instrument[i].PitchEnvelope.NumNodes	= 0;

+	j->Instrument[i].PitchEnvelope.LoopBegin = 0;

+	j->Instrument[i].PitchEnvelope.LoopEnd = 0;

+	j->Instrument[i].PitchEnvelope.SustainLoopBegin	= 0;

+	j->Instrument[i].PitchEnvelope.SustainLoopEnd =	0;

+

+	pack_fclose(f);

+

+	if (errno) {

+		destroy_it(j);

+		return NULL;

+	}

+

+	return j;

+}

+

+

+

+MODULE *load_instrument(char *file, long offset, MODULE *j, int i)

+{

+	int k;

+	PACKFILE *f = pack_fopen(file, F_READ);

+

+	if (!f) {

+		#ifdef DEBUG_INSTRUMENTS

+		fprintf(stderr, "Error reopening!\n");

+		#endif

+		destroy_it(j);

+		return NULL;

+	}

+

+	pack_fseek(f, offset);

+

+	if (pack_mgetl(f) != AL_ID('I','M','P','I')) {

+		destroy_it(j);

+		return NULL;

+	}

+

+	/* Skip DOS Filename */

+	pack_fseek(f, 13);

+

+	j->Instrument[i].NewNoteAction = pack_getc(f);

+	j->Instrument[i].DuplicateCheckType = pack_getc(f);

+	j->Instrument[i].DuplicateCheckAction = pack_getc(f);

+	j->Instrument[i].FadeOut = pack_igetw(f);

+	j->Instrument[i].PitchPanSeparation = pack_getc(f);

+	j->Instrument[i].PitchPanCenter = pack_getc(f);

+	j->Instrument[i].GlobalVolume = pack_getc(f);

+	j->Instrument[i].DefaultPan = pack_getc(f);

+	j->Instrument[i].RandomVolume = pack_getc(f);

+	j->Instrument[i].RandomPanning = pack_getc(f);

+

+	#ifdef DEBUG_INSTRUMENTS

+	fprintf(stderr, "I%02i @ 0x%X, NNA %i, DCT %i, DCA %i, FO %i, "

+		"PPS %i, PPC %i, GVol %i, DPan %i, RV %i, RP %i\n",

+		i, insoffs[i],

+		j->Instrument[i].NewNoteAction,

+		j->Instrument[i].DuplicateCheckType,

+		j->Instrument[i].DuplicateCheckAction,

+		j->Instrument[i].FadeOut,

+		j->Instrument[i].PitchPanSeparation,

+		j->Instrument[i].PitchPanCenter,

+		j->Instrument[i].GlobalVolume,

+		j->Instrument[i].DefaultPan,

+		j->Instrument[i].RandomVolume,

+		j->Instrument[i].RandomPanning);

+	#endif

+

+	/* Skip Tracker Version and Number of Samples. These are only used in

+	 * separate instrument files. Also skip unused byte and Instrument Name.

+ 	 */

+	pack_fseek(f, 30);

+

+	j->Instrument[i].FilterCutOff = pack_getc(f);

+	j->Instrument[i].FilterResonance = pack_getc(f);

+

+	/* Skip MIDI Channel, Program and Bank */

+	pack_fseek(f, 4);

+

+	for	(k = 0; k < 120; k++) {

+		j->Instrument[i].NoteNote[k] = pack_getc(f);

+		j->Instrument[i].NoteSample[k] = pack_getc(f);

+	}

+

+	read_envelopes(f, j, i);

+

+	pack_fclose(f);

+

+	if (errno) {

+		destroy_it(j);

+		return NULL;

+	}

+

+	return j;

+}

+

+

+

+MODULE *load_it_sample(char *file, long offset, MODULE *j, int i)

+{

+	int	sam_samptr,	convert;

+	int len;

+	int k;

+	SAMPLE *sam;

+	void *dat;

+	

+	PACKFILE *f = pack_fopen(file, F_READ);

+	if (!f) {

+		#ifdef DEBUG_SAMPLES

+		fprintf(stderr, "Error opening!\n");

+		#endif

+		destroy_it(j);

+		return NULL;

+	}

+

+	pack_fseek(f, offset);

+

+	if (pack_mgetl(f) != AL_ID('I','M','P','S')) {

+		destroy_it(j);

+		return NULL;

+	}

+

+	/* Skip DOS Filename. */

+	pack_fseek(f, 13);

+

+	j->Sample[i].GlobalVolume =	pack_getc(f);

+	j->Sample[i].Flag =	pack_getc(f);

+	j->Sample[i].DefaultVolume = pack_getc(f);

+

+	#ifdef DEBUG_SAMPLES

+	fprintf(stderr, "S%02i @ 0x%X, Vol: %i/%i, Flag: %i", i, samoffs[i], j->Sample[i].GlobalVolume, j->Sample[i].Volume, j->Sample[i].Flag);

+	#endif

+

+	/* Skip Sample Name. */

+	pack_fseek(f, 26);

+

+	convert = pack_getc(f);

+	j->Sample[i].DefaultPanning = pack_getc(f);

+	j->Sample[i].SampleLength =	pack_igetl(f);

+	j->Sample[i].LoopBegin = pack_igetl(f);

+	j->Sample[i].LoopEnd = pack_igetl(f);

+	j->Sample[i].C5Speed = pack_igetl(f);

+	j->Sample[i].SustainLoopBegin =	pack_igetl(f);

+	j->Sample[i].SustainLoopEnd	= pack_igetl(f);

+

+	#ifdef DEBUG_SAMPLES

+	fprintf(stderr, ", SLen: %i, LpB: %i, LpE: %i, C5S: %i\n", j->Sample[i].SampleLength, j->Sample[i].LoopBegin, j->Sample[i].LoopEnd, j->Sample[i].C5Speed);

+	#endif

+

+	sam_samptr = pack_igetl(f);

+		

+	j->Sample[i].VibratoSpeed =	pack_getc(f);

+	j->Sample[i].VibratoDepth =	pack_getc(f);

+	j->Sample[i].VibratoRate = pack_getc(f);

+	j->Sample[i].VibratoWaveForm = pack_getc(f);

+

+	#ifdef DEBUG_SAMPLES

+	fprintf(stderr, "SusLpB: %i, SusLpE: %i, VibSp: %i, VibDep: %i, VibWav: %i, VibRat: %i\n", j->Sample[i].SustainLoopBegin, j->Sample[i].SustainLoopEnd, j->Sample[i].VibratoSpeed, j->Sample[i].VibratoDepth,	j->Sample[i].VibratoWaveForm, j->Sample[i].VibratoRate);

+	#endif

+

+	pack_fclose(f);

+

+	if (errno) {

+		destroy_it(j);

+		return NULL;

+	}

+

+	if (j->Sample[i].Flag & SAMPLE_HASSAMPLE) {

+		

+		f =	pack_fopen(file, F_READ);

+		pack_fseek(f, sam_samptr);

+

+		len	= j->Sample[i].SampleLength;

+		if (j->Sample[i].Flag & SAMPLE_16BIT) len <<= 1;

+#ifndef STEREO_SAMPLES_COUNT_AS_TWO

+		if (j->Sample[i].Flag & SAMPLE_STEREO) len <<= 1;

+#endif

+

+		#ifdef DEBUG_SAMPLES

+		fprintf(stderr, "Len: %i, Size: %i KB\n", j->Sample[i].SampleLength,	len/1024);

+		#endif

+

+		sam = create_sample(j->Sample[i].Flag & SAMPLE_16BIT ? 16 : 8,

+							j->Sample[i].Flag &	SAMPLE_STEREO ? 1 : 0,

+#ifdef STEREO_SAMPLES_COUNT_AS_TWO

+							j->Sample[i].C5Speed >> 1,

+#else

+							j->Sample[i].C5Speed,

+#endif

+							j->Sample[i].SampleLength);

+

+		if (j->Sample[i].Flag & 8) { // If the sample is packed, then we must unpack it

+

+			if (j->Sample[i].Flag & SAMPLE_16BIT)

+				decompress16(f,	sam->data, j->Sample[i].SampleLength, j->Version);

+			else

+				decompress8(f, sam->data, j->Sample[i].SampleLength, j->Version);

+

+		} else if ((j->Sample[i].Flag & SAMPLE_16BIT)) {

+			if (convert & 2)

+				for (k = 0; k < len; k += 2)

+					*(short *)((char *)sam->data + k) = pack_mgetw(f);

+			else

+				for (k = 0; k < len; k += 2)

+					*(short *)((char *)sam->data + k) = pack_igetw(f);

+		} else {

+			pack_fread(sam->data, len, f);

+		}

+		

+		if (j->Sample[i].Flag &	SAMPLE_USELOOP)	{

+			sam->loop_start	= j->Sample[i].LoopBegin;

+			sam->loop_end =	j->Sample[i].LoopEnd;

+		}

+

+		j->Sample[i].Sample	= sam;

+		

+		dat = sam->data;

+

+		if (convert & 1) {

+ 			/* Convert to unsigned. */

+   			if (sam->bits == 8)

+	   			for (k = 0; k < len; k++)

+		   			((char *)dat)[k] ^= 0x80;

+   			else

+   				for (k = 0; k < len; k += 2)

+		   			*(short *)((char *)dat + k) ^= 0x8000;

+		}

+

+		/* NOT SUPPORTED:

+		 *

+		 * convert &  4 - Samples stored as delta values

+		 * convert &  8 - Samples stored as byte delta values

+		 * convert & 16 - Samples stored as TX-Wave 12-bit values

+		 * convert & 32 - Left/Right/All Stereo prompt

+		 */

+

+		pack_fclose(f);

+

+		if (errno) {

+			destroy_it(j);

+			return NULL;

+		}

+	}

+

+	return j;

+}

+

+

+

+MODULE *load_pattern(char *file, long offset, MODULE *j, int i)

+{

+	unsigned char *buf;

+	unsigned char cmask[64],

+				  cnote[64],

+				  cinstrument[64],

+				  cvol[64],

+				  ccom[64],

+				  ccomval[64];

+	

+	int numnotes = 0, len, pos = 0, mask = 0, chn = 0;

+

+	PACKFILE *f;

+

+	if (offset == 0) {

+		/* Empty 64-row pattern. */

+

+		j->Pattern[i].NumRows = 64;

+		j->Pattern[i].NumNotes = 0;

+

+		return j;

+	}

+

+	f =	pack_fopen(file, F_READ);

+	if (!f) {

+		destroy_it(j);

+		return NULL;

+	}

+

+	buf = malloc(65536);

+

+	memset(cmask, 0, 64);

+	memset(cnote, 0, 64);

+	memset(cinstrument,	0, 64);

+	memset(cvol, 0,	64);

+	memset(ccom, 0,	64);

+	memset(ccomval,	0, 64);

+

+	pack_fseek(f, offset);

+

+	len = pack_igetw(f);

+	j->Pattern[i].NumRows = pack_igetw(f);

+

+	/* Skip four unused bytes. */

+	pack_fseek(f, 4);

+

+	pack_fread(buf, len, f);

+

+	while (pos < len) {

+

+		int	b =	buf[pos++];

+

+		if (!b)	{

+			/* End of row. */

+			numnotes++;

+			continue;

+		}

+

+		chn = (b - 1) & 63;

+

+		if (b & 128) {

+			mask = buf[pos];

+			pos++;

+			cmask[chn] = mask;

+		} else

+			mask = cmask[chn];

+				

+		if (mask)

+			numnotes++;

+		if (mask & 1)

+			pos++;

+		if (mask & 2)

+			pos++;

+		if (mask & 4)

+			pos++;

+		if (mask & 8)

+			pos += 2;

+	}

+

+	j->Pattern[i].NumNotes = numnotes;

+	j->Pattern[i].Note = malloc(numnotes * sizeof(MODULE_NOTE));

+	memset(j->Pattern[i].Note, 0, numnotes * sizeof(MODULE_NOTE));

+		

+	pos	= 0;

+	memset(cmask, 0, 64);

+	mask = 0;

+	numnotes = 0;

+

+	while (pos < len) {

+

+		int	b =	buf[pos];

+		#ifdef DEBUG_PATTERNS

+		fprintf(stderr, "NumNote: %i ", numnotes);

+		#endif

+		pos++;

+

+		if (b == 0) { //If end of row:

+			j->Pattern[i].Note[numnotes].Channel = -1;

+			numnotes++;

+			#ifdef DEBUG_PATTERNS

+			fprintf(stderr, "Channel: -1\n");

+			#endif

+			continue;

+		}

+

+		chn	= (b - 1) &	63;

+

+		if (b &	128) {

+			mask = buf[pos];

+			pos++;

+			cmask[chn] = mask;

+		} else

+			mask = cmask[chn];

+

+		#ifdef DEBUG_PATTERNS

+		fprintf(stderr, "Channel: %i Mask: %i ",	chn, mask);

+		#endif

+				

+		if (mask)

+			j->Pattern[i].Note[numnotes].Channel = chn;

+

+		if (mask & 1) {

+			j->Pattern[i].Note[numnotes].Note =	buf[pos];

+			j->Pattern[i].Note[numnotes].Mask |= NOTEMASK_NOTE;

+			cnote[chn] = buf[pos];

+			#ifdef DEBUG_PATTERNS

+			fprintf(stderr, "Note: %i ",	buf[pos]);

+			#endif

+			pos++;

+		}

+

+		if (mask & 2) {

+			j->Pattern[i].Note[numnotes].Instrument	= buf[pos];

+			j->Pattern[i].Note[numnotes].Mask |= NOTEMASK_INSTRUMENT;

+			cinstrument[chn] = buf[pos];

+			#ifdef DEBUG_PATTERNS

+			fprintf(stderr, "Inst: %i ",	buf[pos]);

+			#endif

+			pos++;

+		}

+

+		if (mask & 4) {

+			j->Pattern[i].Note[numnotes].VolPan = buf[pos];

+			j->Pattern[i].Note[numnotes].Mask |= NOTEMASK_VOLPAN;

+			cvol[chn] =	buf[pos];

+			#ifdef DEBUG_PATTERNS

+			fprintf(stderr, "Vol: %i ", buf[pos]);

+			#endif

+			pos++;

+		}

+

+		if (mask & 8) {

+			j->Pattern[i].Note[numnotes].Command = buf[pos];

+			j->Pattern[i].Note[numnotes].CommandValue = buf[pos+1];

+			j->Pattern[i].Note[numnotes].Mask |= NOTEMASK_COMMAND;

+			ccom[chn] = buf[pos];

+			ccomval[chn] = buf[pos+1];

+			#ifdef DEBUG_PATTERNS

+			fprintf(stderr, "Com: %i CommArg: %i ", buf[pos], buf[pos+1]);

+			#endif

+			pos += 2;

+		}

+

+		if (mask & 16) {

+			j->Pattern[i].Note[numnotes].Note = cnote[chn];

+			j->Pattern[i].Note[numnotes].Mask |= NOTEMASK_NOTE;

+			#ifdef DEBUG_PATTERNS

+			fprintf(stderr, "LNote: %i ", cnote[chn]);

+			#endif

+		}

+

+		if (mask & 32) {

+			j->Pattern[i].Note[numnotes].Instrument = cinstrument[chn];

+			j->Pattern[i].Note[numnotes].Mask |= NOTEMASK_INSTRUMENT;

+			#ifdef DEBUG_PATTERNS

+			fprintf(stderr, "LInst: %i ", cinstrument[chn]);

+			#endif

+		}

+

+		if (mask & 64) {

+			j->Pattern[i].Note[numnotes].VolPan = cvol[chn];

+			j->Pattern[i].Note[numnotes].Mask |= NOTEMASK_VOLPAN;

+			#ifdef DEBUG_PATTERNS

+			fprintf(stderr, "LVol: %i ",	cvol[chn]);

+			#endif

+		}

+

+		if (mask & 128)	{

+			j->Pattern[i].Note[numnotes].Command = ccom[chn];

+			j->Pattern[i].Note[numnotes].CommandValue =	ccomval[chn];

+			j->Pattern[i].Note[numnotes].Mask |= NOTEMASK_COMMAND;

+			#ifdef DEBUG_PATTERNS

+			fprintf(stderr, "LCom: %i LComArg: %i ",	ccom[chn], ccomval[chn]);

+			#endif

+		}

+

+		#ifdef DEBUG_PATTERNS

+		fprintf(stderr, "\n");

+		#endif

+

+		if (mask)

+			numnotes++;

+

+		#ifdef DEBUG_PATTERNS

+		rest(1000);

+		#endif

+	}

+

+	free(buf);

+

+	pack_fclose(f);

+

+	if (errno) {

+		destroy_it(j);

+		return NULL;

+	}

+

+	return j;

+}

+

+

+

+MODULE *load_it(char *file) {

+	PACKFILE *f;

+	MODULE *j = create_it();

+	int tver, tver2, flag;

+	long *insoffs = NULL, *samoffs = NULL, *patoffs = NULL;

+    int i;

+	

+	if (!j)

+		return NULL;

+

+	f = pack_fopen(file, F_READ);

+	

+	if (!f)

+		return NULL;

+

+	if (pack_mgetl(f) != MUSIC_IT) {

+		pack_fclose(f);

+		return NULL;

+	}

+

+ 	/* Skip song name and pattern row highlight info */

+	pack_fseek(f, 28);

+	

+	j->NumOrders = pack_igetw(f);

+	j->NumInstruments = pack_igetw(f);

+	j->NumSamples = pack_igetw(f);

+	j->NumPatterns = pack_igetw(f);

+

+	#ifdef DEBUG_HEADER

+	fprintf(stderr, "Loading IT: %i Orders, %i Instruments, %i Samples, %i Patterns\n", j->NumOrders, j->NumInstruments, j->NumSamples, j->NumPatterns);

+	#endif

+	

+	tver = pack_igetw(f);

+	j->Version = tver2 = pack_igetw(f);

+

+	#ifdef DEBUG_HEADER

+	fprintf(stderr, "Tracker ver: %X, %X\n", tver, tver2);

+	#endif

+

+	j->Flags = pack_igetw(f);

+	flag = pack_igetw(f);

+

+	j->GlobalVolume = pack_getc(f);

+	j->MixVolume = pack_getc(f);

+	j->Speed = pack_getc(f);

+	j->Tempo = pack_getc(f);

+	j->PanningSeparation = pack_getc(f);

+

+	#ifdef DEBUG_HEADER

+	fprintf(stderr, "Global Volume: %i, Mixing Volume: %i, Speed: %i, Tempo: %i, PanSep: %i\n", j->GlobalVolume,	j->MixVolume, j->Speed,	j->Tempo, j->PanningSeparation);

+	#endif

+

+	/* Skip Pitch Wheel Depth, Message Length, Message Offset and Reserved */

+	pack_fseek(f, 11);

+

+	#ifdef DEBUG_HEADER

+	fprintf(stderr, "Channel Pan:");

+	#endif

+

+	for (i = 0; i < MAX_IT_CHN; i++) {

+		j->Channel[i].Pan = pack_getc(f);

+		#ifdef DEBUG_HEADER

+		fprintf(stderr, " %i", j->Channel[i].Pan);

+		#endif

+	}

+	#ifdef DEBUG_HEADER

+	fprintf(stderr, "\nChannel Vol:");

+	#endif

+	for (i = 0; i < MAX_IT_CHN; i++) {

+		j->Channel[i].ChannelVolume = pack_getc(f);

+		#ifdef DEBUG_HEADER

+		fprintf(stderr, " %i", j->Channel[i].ChannelVolume);

+		#endif

+	}

+	#ifdef DEBUG_HEADER

+	fprintf(stderr, "\n");

+	#endif

+

+	j->Order = malloc(j->NumOrders);

+	if (!j->Order) {

+		destroy_it(j);

+		return NULL;

+	}

+	pack_fread(j->Order, j->NumOrders, f);

+

+	/* Whoops, no error checking! Er, would it be better to use arrays? */

+	if (j->NumInstruments)

+		insoffs = malloc(j->NumInstruments * sizeof(*insoffs));

+	if (j->NumSamples)

+		samoffs = malloc(j->NumSamples * sizeof(*samoffs));

+	if (j->NumPatterns)

+		patoffs = malloc(j->NumPatterns * sizeof(*patoffs));

+

+	for (i = 0; i < j->NumInstruments; i++) insoffs[i] = pack_igetl(f);

+	for (i = 0; i < j->NumSamples; i++) samoffs[i] = pack_igetl(f);

+	for (i = 0; i < j->NumPatterns; i++) patoffs[i] = pack_igetl(f);

+

+/* No skipping necessary - we can use the offsets.

+

+	if (flag&1)	{ //Song message attached

+		//Ignore.

+	}

+	if (flag & 4) {	//skip something:

+		short u;

+		char dummy[8];

+        int i;

+		u =	pack_igetw(f);

+		for	(i=0; i<u; u++)

+			pack_fread(dummy, 8, f);

+	}

+	if (flag & 8) {	//skip embedded MIDI configuration

+		char dummy[33];

+        int i;

+		for	(i=0; i<9+16+128; i++)

+			pack_fread(dummy, 32, f);

+

+	}

+*/

+	pack_fclose(f);

+

+	if (j->NumInstruments) {

+		j->Instrument = malloc(j->NumInstruments * sizeof(MODULE_INSTRUMENT));

+

+		if (!j->Instrument) {

+			#ifdef DEBUG_INSTRUMENTS

+			fprintf(stderr, "No Mem for Instruments!\n");

+			#endif

+			free(insoffs);

+			free(samoffs);

+			free(patoffs);

+			destroy_it(j);

+			return NULL;

+		}

+		memset(j->Instrument, 0, j->NumInstruments * sizeof(MODULE_INSTRUMENT));

+

+		for	(i = 0; i < j->NumInstruments; i++) {

+

+			if (tver2 < 0x200)

+				j = load_old_instrument(file, insoffs[i], j, i);

+			else

+				j = load_instrument(file, insoffs[i], j, i);

+

+			if (!j) {

+				free(insoffs);

+				free(samoffs);

+				free(patoffs);

+				return NULL;

+			}

+		}

+	}

+

+	if (j->NumSamples) {

+		j->Sample = malloc(j->NumSamples * sizeof(MODULE_SAMPLE));

+

+		if (!j->Sample) {

+			#ifdef DEBUG_SAMPLES

+			fprintf(stderr, "No Mem for Samples!\n");

+			#endif

+			free(insoffs);

+			free(samoffs);

+			free(patoffs);

+			destroy_it(j);

+			return NULL;

+		}

+		memset(j->Sample, 0, j->NumSamples * sizeof(MODULE_SAMPLE));

+

+		for (i=0; i<j->NumSamples; i++) {

+

+			j = load_it_sample(file, samoffs[i], j, i);

+

+			if (!j) {

+				free(insoffs);

+				free(samoffs);

+				free(patoffs);

+				return NULL;

+			}

+		}

+	}

+

+	if (j->NumPatterns) {

+		j->Pattern = malloc(j->NumPatterns * sizeof(MODULE_PATTERN));

+

+		if (!j->Pattern) {

+			#ifdef DEBUG_PATTERNS

+			fprintf(stderr, "No Mem for Patterns!\n");

+			#endif

+			free(insoffs);

+			free(samoffs);

+			free(patoffs);

+			destroy_it(j);

+			return NULL;

+		}

+		memset(j->Pattern, 0, j->NumPatterns * sizeof(MODULE_PATTERN));

+

+		for (i = 0; i < j->NumPatterns; i++) {

+

+			j = load_pattern(file, patoffs[i], j, i);

+

+			if (!j) {

+				free(insoffs);

+				free(samoffs);

+				free(patoffs);

+				return NULL;

+			}

+		}

+	}

+

+	if (insoffs)

+		free(insoffs);

+	if (samoffs)

+		free(samoffs);

+	if (patoffs)

+		free(patoffs);

+

+	return j;

+}

+

+

+

+/* ----------------- */

+

+

+

+#define DUH_SIGNATURE AL_ID('D', 'U', 'H', '!')

+

+

+

+#define SIGTYPE_SAMPLE AL_ID('S', 'A', 'M', 'P')

+

+#define SAMPFLAG_16BIT    1	/* sample in file is 16 bit, rather than 8 bit */

+#define SAMPFLAG_LOOP     2 /* loop indefinitely */

+#define SAMPFLAG_XLOOP    4 /* loop x times; only relevant if LOOP not set */

+#define SAMPFLAG_PINGPONG 8 /* loop back and forth, if LOOP or XLOOP set */

+

+/* SAMPPARAM_N_LOOPS: add 'value' iterations to the loop. 'value' is assumed

+ * to be positive.

+ */

+#define SAMPPARAM_N_LOOPS 0

+

+

+

+#define SIGTYPE_COMBINING AL_ID('C', 'O', 'M', 'B')

+

+

+

+#define SIGTYPE_STEREOPAN AL_ID('S', 'P', 'A', 'N')

+

+#define SPANPARAM_PAN 0

+

+

+

+#define SIGTYPE_SEQUENCE AL_ID('S', 'E', 'Q', 'U')

+

+#define SEQUENCE_START_SIGNAL  0

+#define SEQUENCE_SET_VOLUME    1

+#define SEQUENCE_SET_PITCH     2

+#define SEQUENCE_SET_PARAMETER 3

+#define SEQUENCE_STOP_SIGNAL   4

+

+

+

+void write_sample(MODULE_SAMPLE *sample, PACKFILE *f, int channel)

+{

+	long size = sample->SampleLength;

+	long i;

+	int flags = 0;

+	long loop_start = 0, loop_end = 0;

+

+	SAMPLE *smp = sample->Sample;

+

+	pack_mputl(SIGTYPE_SAMPLE, f);

+

+#ifdef STEREO_SAMPLES_COUNT_AS_TWO

+	if (sample->Flag & SAMPLE_STEREO) {

+		ASSERT((size & 1) == 0);

+		size >>= 1;

+	}

+#endif

+

+#ifdef SUSTAIN_LOOP_OVERRIDES_NORMAL_LOOP

+	if (sample->Flag & SAMPLE_USESUSTAINLOOP) {

+		flags |= SAMPFLAG_XLOOP;

+		if (sample->Flag & SAMPLE_PINGPONGSUSTAINLOOP)

+			flags |= SAMPFLAG_PINGPONG;

+	} else if (sample->Flag & SAMPLE_USELOOP) {

+		flags |= SAMPFLAG_LOOP;

+		if (sample->Flag & SAMPLE_PINGPONGLOOP)

+			flags |= SAMPFLAG_PINGPONG;

+	}

+#else

+	if (sample->Flag & SAMPLE_USELOOP) {

+		flags |= SAMPFLAG_LOOP;

+		if (sample->Flag & SAMPLE_PINGPONGLOOP)

+			flags |= SAMPFLAG_PINGPONG;

+	} else if (sample->Flag & SAMPLE_USESUSTAINLOOP) {

+		flags |= SAMPFLAG_XLOOP;

+		if (sample->Flag & SAMPLE_PINGPONGSUSTAINLOOP)

+			flags |= SAMPFLAG_PINGPONG;

+	}

+#endif

+

+	if (flags & (SAMPFLAG_LOOP | SAMPFLAG_XLOOP)) {

+		if (flags & SAMPFLAG_LOOP) {

+			loop_start = sample->LoopBegin;

+			loop_end = sample->LoopEnd;

+		} else {

+			loop_start = sample->SustainLoopBegin;

+			loop_end = sample->SustainLoopEnd;

+		}

+

+#ifdef STEREO_SAMPLES_COUNT_AS_TWO

+		if (sample->Flag & SAMPLE_STEREO) {

+			ASSERT(((loop_start | loop_end) & 1) == 0);

+			loop_start >>= 1;

+			loop_end >>= 1;

+		}

+#endif

+

+		if (loop_end > size)

+			loop_end = size;

+		else if (flags & SAMPFLAG_LOOP)

+			size = loop_end;

+	}

+

+	pack_iputl(size, f);

+

+	if (smp->bits == 16)

+		flags |= SAMPFLAG_16BIT;

+

+	pack_putc(flags, f);

+

+	if (flags & (SAMPFLAG_LOOP | SAMPFLAG_XLOOP)) {

+		pack_iputl(loop_start, f);

+		if (!(flags & SAMPFLAG_LOOP))

+			pack_iputl(loop_end, f);

+	}

+

+	if (flags & SAMPFLAG_16BIT) {

+

+		if (smp->stereo) {

+			for (i = 0; i < size; i++)

+				pack_iputw(((unsigned short *)smp->data)[(i << 1) + channel] ^ 0x8000, f);

+		} else {

+			for (i = 0; i < size; i++)

+				pack_iputw(((unsigned short *)smp->data)[i] ^ 0x8000, f);

+		}

+

+	} else {

+

+		if (smp->stereo) {

+			/* TEMPORARY CHANNEL COMBINING */

+			for (i = 0; i < size; i++)

+				pack_putc(((unsigned char *)smp->data)[(i << 1) + channel] ^ 0x80, f);

+		} else {

+			for (i = 0; i < size; i++)

+				pack_putc(((unsigned char *)smp->data)[i] ^ 0x80, f);

+		}

+

+	}

+}

+

+

+

+int sample_is_valid(MODULE_SAMPLE *sample)

+{

+	if (!(sample->Flag & SAMPLE_HASSAMPLE))

+		return 0;

+

+	if (sample->SampleLength <= 0)

+		return 0;

+

+#ifdef SUSTAIN_LOOP_OVERRIDES_NORMAL_LOOP

+	if ((sample->Flag & (SAMPLE_USELOOP | SAMPLE_USESUSTAINLOOP)) == SAMPLE_USELOOP)

+#else

+	if (sample->Flag & SAMPLE_USELOOP)

+#endif

+		if (sample->LoopEnd <= 0)

+			return 0;

+

+	return 1;

+}

+

+

+

+#define first_sample 1

+

+

+

+void write_mono_sample(MODULE_SAMPLE *sample, int n_samples, PACKFILE *f)

+{

+	pack_mputl(SIGTYPE_STEREOPAN, f);

+

+	/* Refer to the next sample. */

+	pack_iputl(first_sample + n_samples + 1, f);

+

+	write_sample(sample, f, 0);

+}

+

+

+

+void write_stereo_sample(MODULE_SAMPLE *sample, int n_samples, PACKFILE *f)

+{

+	pack_mputl(SIGTYPE_COMBINING, f);

+

+	/* Two samples. */

+	pack_putc(2, f);

+

+	/* Refer to the next two samples. */

+	pack_iputl(first_sample + n_samples + 1, f);

+	pack_iputl(first_sample + n_samples + 2, f);

+

+	write_sample(sample, f, 0);

+	write_sample(sample, f, 1);

+}

+

+

+

+unsigned char *seqdata = NULL;

+int seqpos = 0;

+int max_seqdata = 0;

+

+int seqtime = 0;

+

+int songtime;

+

+

+

+void sequence_c(int v)

+{

+	if (seqpos >= max_seqdata) {

+		max_seqdata += 1024;

+		seqdata = realloc(seqdata, max_seqdata);

+		if (!seqdata) {

+			errno = ENOMEM;

+			return;

+		}

+	}

+	seqdata[seqpos++] = v;

+}

+

+

+void sequence_w(int v)

+{

+	sequence_c(v);

+	sequence_c(v >> 8);

+}

+

+

+void sequence_l(long v)

+{

+	sequence_c(v);

+	sequence_c(v >> 8);

+	sequence_c(v >> 16);

+	sequence_c(v >> 24);

+}

+

+

+void sequence_cl(unsigned long v)

+{

+	int byte_count = 0;

+

+	while (byte_count < 4 && v >= 128) {

+		sequence_c(v | 128);

+		v >>= 7;

+		byte_count++;

+	}

+

+	sequence_c(v & 127);

+}

+

+

+

+void write_seqtime() {

+	sequence_cl(seqtime);

+	seqtime = 0;

+}

+

+

+

+int *sample_signal = NULL;

+

+

+

+void calculate_pan(MODULE *module, MODULE_CHANNEL *channel)

+{

+	int samp;

+

+	if (module->Flags & FLAG_USEINSTRUMENTS && channel->Instrument >= 1 && channel->Instrument <= module->NumInstruments) {

+		MODULE_INSTRUMENT *instrument = &module->Instrument[(int)channel->Instrument - 1];

+		if (instrument) {

+			unsigned char note = instrument->NoteNote[channel->Note];

+			samp = instrument->NoteSample[channel->Note];

+			if (instrument->DefaultPan <= 64)

+				channel->Pan = instrument->DefaultPan;

+			channel->PanSep = (note - instrument->PitchPanCenter) * instrument->PitchPanSeparation / 8;

+		} else {

+			samp = 0;

+			channel->PanSep = 0;

+		}

+	} else {

+		samp = channel->Instrument;

+		channel->PanSep = 0;

+	}

+

+	if (samp >= 1 && samp <= module->NumSamples) {

+		int pan = module->Sample[samp - 1].DefaultPanning;

+		if (pan >= 128 && pan <= 192)

+			channel->Pan = pan - 128;

+	}

+}

+

+

+

+/* This function assumes note->Channel >= 0. */

+void process_note_data(MODULE *module, MODULE_NOTE *note)

+{

+	MODULE_CHANNEL *channel = &module->Channel[(int)note->Channel];

+

+	if (note->Mask & NOTEMASK_NOTE) {

+		if (note->Note >= 120) {

+			channel->Note = note->Note;

+		} else if (channel->Note >= 120) {

+			channel->Note = note->Note;

+			channel->Flag |= CHANNEL_RETRIG;

+		} else {

+			channel->Note = note->Note;

+			if ((note->Mask & NOTEMASK_VOLPAN) == 0 ||

+				!(note->VolPan >= 193 && note->VolPan <= 202))

+			{

+				if ((note->Mask & NOTEMASK_COMMAND) == 0 ||

+					(note->Command != IT_TONE_PORTAMENTO &&

+					 note->Command != IT_VOLSLIDE_TONEPORTA))

+				{

+					channel->Flag |= CHANNEL_RETRIG;

+				}

+			}

+		}

+	}

+

+	if (note->Mask & NOTEMASK_INSTRUMENT) {

+		if (note->Instrument != channel->Instrument) {

+			channel->Flag |= CHANNEL_RETRIG;

+			channel->Instrument = note->Instrument;

+			if (!(module->Flags & FLAG_USEINSTRUMENTS)) {

+				if (channel->Instrument >= 1 && channel->Instrument <= module->NumSamples)

+					channel->sample = &module->Sample[channel->Instrument - 1];

+				else

+					channel->sample = NULL;

+			}

+		}

+	}

+

+	if (module->Flags & FLAG_USEINSTRUMENTS) {

+		if (channel->Instrument >= 1 && channel->Instrument <= module->NumInstruments) {

+			int samp = module->Instrument[(int)channel->Instrument - 1].NoteSample[channel->Note];

+			if (samp >= 1 && samp <= module->NumSamples)

+				channel->sample = &module->Sample[samp - 1];

+			else

+				channel->sample = NULL;

+		} else

+			channel->sample = NULL;

+	}

+

+	if (channel->Flag & CHANNEL_RETRIG)

+		calculate_pan(module, channel);

+

+	if (note->Mask & NOTEMASK_INSTRUMENT)

+		if (channel->sample)

+			channel->Volume = channel->sample->DefaultVolume;

+

+	if (!channel->sample)

+		channel->Flag &= ~CHANNEL_RETRIG;

+

+	if (note->Mask & NOTEMASK_VOLPAN) {

+		if (note->VolPan <= 64)

+			channel->Volume = note->VolPan;

+		else if (note->VolPan <= 74) {

+			unsigned char v = note->VolPan - 65;

+			if (v == 0)

+				v = channel->lastvolslide;

+			channel->lastvolslide = v;

+			/* = effect DxF where x == note->VolPan - 65 */

+			channel->Volume += v;

+			if (channel->Volume > 64) channel->Volume = 64;

+

+		} else if (note->VolPan <= 84) {

+			unsigned char v = note->VolPan - 75;

+			if (v == 0)

+				v = channel->lastvolslide;

+			channel->lastvolslide = v;

+			/* = effect DFx where x == note->VolPan - 75 */

+			channel->Volume -= v;

+			if (channel->Volume > 64) channel->Volume = 0;

+		} else if (note->VolPan <= 94) {

+			unsigned char v = note->VolPan - 85;

+			if (v == 0)

+				v = channel->lastvolslide;

+			channel->lastvolslide = v;

+			/* = effect Dx0 where x == note->VolPan - 85 */

+			channel->volslide = v;

+		} else if (note->VolPan <= 104) {

+			unsigned char v = note->VolPan - 95;

+			if (v == 0)

+				v = channel->lastvolslide;

+			channel->lastvolslide = v;

+			/* = effect D0x where x == note->VolPan - 95 */

+			channel->volslide = -v;

+		} else if (note->VolPan <= 114) {

+			unsigned char v = (note->VolPan - 105) << 2;

+			if (v == 0)

+				v = channel->lastEF;

+			channel->lastEF = v;

+			channel->portamento -= v << 4;

+		} else if (note->VolPan <= 124) {

+			unsigned char v = (note->VolPan - 115) << 2;

+			if (v == 0)

+				v = channel->lastEF;

+			channel->lastEF = v;

+			channel->portamento += v << 4;

+		} else if (note->VolPan < 128) { }

+		else if (note->VolPan <= 192)

+			channel->Pan = note->VolPan - 128;

+		else if (note->VolPan <= 202) {

+			//Tone Portamento

+			/* Affects G's memory. Has the equivalent slide given by this

+			 * table:

+			 */

+			static unsigned char SlideTable[] = {0, 1, 4, 8, 16, 32, 64, 96, 128, 255};

+

+			unsigned char v = SlideTable[note->VolPan - 193];

+			if (module->Flags & FLAG_COMPATIBLEGXX) {

+				if (v == 0)

+					v = channel->lastG;

+				channel->lastG = v;

+			} else {

+				if (v == 0)

+					v = channel->lastEF;

+				channel->lastEF = v;

+			}

+			channel->toneporta += v << 4;

+		} else if (note->VolPan <= 212)

+			;//Vibrato

+			/* This uses the same 'memory' as Hxx/Uxx. */

+	}

+

+	if (note->Mask & NOTEMASK_COMMAND) {

+		//Interpret effect

+		//unsigned char note->Command, note->CommandValue

+		switch (note->Command) {

+/*

+Notes about effects (as compared to other module formats)

+

+C               This is now in *HEX*. (Used to be in decimal in ST3)

+E/F/G/H/U       You need to check whether the song uses Amiga/Linear slides.

+H/U             Vibrato in Impulse Tracker is two times finer than in

+                any other tracker and is updated EVERY tick.

+                If "Old Effects" is *ON*, then the vibrato is played in the

+                normal manner (every non-row tick and normal depth)

+E/F/G           These commands ALL share the same memory.

+Oxx             Offsets to samples are to the 'xx00th' SAMPLE. (ie. for

+                16 bit samples, the offset is xx00h*2)

+                Oxx past the sample end will be ignored, unless "Old Effects"

+                is ON, in which case the Oxx will play from the end of the

+                sample.

+Yxy             This uses a table 4 times larger (hence 4 times slower) than

+                vibrato or tremelo. If the waveform is set to random, then

+                the 'speed' part of the command is interpreted as a delay.

+*/

+			case IT_SET_SPEED: if (note->CommandValue) {module->tick = module->Speed = note->CommandValue;} break;

+			//case IT_JUMP_TO_ORDER: module->processorder = note->CommandValue - 1; module->processrow = 0xFFFE; break;

+			//IT_JUMP_TO_ORDER would most likely be used to jump back, so it must be handled specially.

+			case IT_BREAK_TO_ROW: module->breakrow = note->CommandValue; module->processrow = 0xFFFE; break;

+			case IT_VOLUME_SLIDE:

+				{

+					unsigned char v = note->CommandValue;

+					if (v == 0)

+						v = channel->lastDKL;

+					channel->lastDKL = v;

+					if ((v & 0x0F) == 0) { /* Dx0 */

+						channel->volslide = v >> 4;

+						if (channel->volslide == 15) {

+							channel->Volume += 15;

+							if (channel->Volume > 64) channel->Volume = 64;

+						}

+					} else if ((v & 0xF0) == 0) { /* D0x */

+						channel->volslide = -v;

+						if (channel->volslide == -15) {

+							channel->Volume -= 15;

+							if (channel->Volume > 64) channel->Volume = 0;

+						}

+					} else if ((v & 0x0F) == 0x0F) { /* DxF */

+						channel->Volume += v >> 4;

+						if (channel->Volume > 64) channel->Volume = 64;

+					} else if ((v & 0xF0) == 0xF0) { /* DFx */

+						channel->Volume -= v & 15;

+						if (channel->Volume > 64) channel->Volume = 0;

+					}

+				}

+				break;

+			case IT_PORTAMENTO_DOWN:

+				{

+					unsigned char v = note->CommandValue;

+					if (v == 0)

+						v = channel->lastEF;

+					channel->lastEF = v;

+					channel->portamento -= v << 4;

+				}

+				break;

+			case IT_PORTAMENTO_UP:

+				{

+					unsigned char v = note->CommandValue;

+					if (v == 0)

+						v = channel->lastEF;

+					channel->lastEF = v;

+					channel->portamento += v << 4;

+				}

+				break;

+			case IT_TONE_PORTAMENTO:

+				{

+					unsigned char v = note->CommandValue;

+					if (module->Flags & FLAG_COMPATIBLEGXX) {

+						if (v == 0)

+							v = channel->lastG;

+						channel->lastG = v;

+					} else {

+						if (v == 0)

+							v = channel->lastEF;

+						channel->lastEF = v;

+					}

+					channel->toneporta += v << 4;

+				}

+				break;

+			//case IT_VIBRATO:

+			//case IT_TREMOR:

+			//case IT_ARPEGGIO:

+			//case IT_VOLSLIDE_VIBRATO:

+			//case IT_VOLSLIDE_TONEPORTA:

+			case IT_SET_CHANNEL_VOLUME:

+				if (note->CommandValue <= 64)

+					channel->ChannelVolume = note->CommandValue;

+#ifdef VOLUME_OUT_OF_RANGE_SETS_MAXIMUM

+				else

+					channel->ChannelVolume = 64;

+#endif

+				break;

+			case IT_CHANNEL_VOLUME_SLIDE:

+				{

+					unsigned char v = note->CommandValue;

+					if (v == 0)

+						v = channel->lastN;

+					channel->lastN = v;

+					if ((v & 0x0F) == 0) { /* Nx0 */

+						channel->channelvolslide = v >> 4;

+					} else if ((v & 0xF0) == 0) { /* N0x */

+						channel->channelvolslide = -v;

+					} else if ((v & 0x0F) == 0x0F) { /* NxF */

+						channel->ChannelVolume += v >> 4;

+						if (channel->ChannelVolume > 64) channel->ChannelVolume = 64;

+					} else if ((v & 0xF0) == 0xF0) { /* NFx */

+						channel->ChannelVolume -= v & 15;

+						if (channel->ChannelVolume > 64) channel->ChannelVolume = 0;

+					}

+				}

+				break;

+			//case IT_SET_SAMPLE_OFFSET:

+			//case IT_PANNING_SLIDE:

+			//case IT_RETRIGGER_NOTE:

+			//case IT_TREMOLO:

+			case IT_S:

+				switch (note->CommandValue >> 4) {

+					//case IT_S_SET_FILTER:

+					//case IT_S_SET_GLISSANDO_CONTROL:

+					//case IT_S_FINETUNE:

+					//case IT_S_SET_VIBRATO_WAVEFORM:

+					//case IT_S_SET_TREMOLO_WAVEFORM:

+					//case IT_S_SET_PANBRELLO_WAVEFORM:

+						/* Waveforms for commands S3x, S4x and S5x:

+						 *   0: Sine wave

+						 *   1: Ramp down

+						 *   2: Square wave

+						 *   3: Random wave

+						 */

+					//case IT_S7:

+					case IT_S_SET_PAN:

+						channel->Pan = ((note->CommandValue & 15) << 2) | ((note->CommandValue & 15) >> 2);

+						break;

+					//case IT_S_SET_SURROUND_SOUND:

+						/* S91 Set surround sound */

+					//case IT_S_SET_HIGH_OFFSET:

+						/* SAy Set high value of sample offset yxx00h */

+					//case IT_S_PATTERN_LOOP:

+						/* SB0 Set loopback point */

+					//case IT_S_DELAYED_NOTE_CUT:

+					//case IT_S_NOTE_DELAY:

+						/* SEx Pattern delay for x rows */

+					//case IT_S_SET_MIDI_MACRO:

+				}

+				break;

+			case IT_SET_SONG_TEMPO:

+				{

+					unsigned char v = note->CommandValue;

+					if (v == 0)

+						v = channel->lastW;

+					channel->lastW = v;

+					if (v < 0x10)

+						module->temposlide = -v;

+					else if (v < 0x20)

+						module->temposlide = v & 15;

+					else

+						module->Tempo = v;

+				}

+				break;

+			//case IT_FINE_VIBRATO:

+			case IT_SET_GLOBAL_VOLUME:

+				if (note->CommandValue <= 128)

+					module->GlobalVolume = note->CommandValue;

+#ifdef VOLUME_OUT_OF_RANGE_SETS_MAXIMUM

+				else

+					module->GlobalVolume = 128;

+#endif

+				break;

+			case IT_GLOBAL_VOLUME_SLIDE:

+				{

+					unsigned char v = note->CommandValue;

+					if (v == 0)

+						v = channel->lastW;

+					channel->lastW = v;

+					if ((v & 0x0F) == 0) { /* Nx0 */

+						module->globalvolslide = v >> 4;

+					} else if ((v & 0xF0) == 0) { /* N0x */

+						module->globalvolslide = -v;

+					} else if ((v & 0x0F) == 0x0F) { /* NxF */

+						module->GlobalVolume += v >> 4;

+						if (module->GlobalVolume > 64) module->GlobalVolume = 64;

+					} else if ((v & 0xF0) == 0xF0) { /* NFx */

+						module->GlobalVolume -= v & 15;

+						if (module->GlobalVolume > 64) module->GlobalVolume = 0;

+					}

+				}

+				break;

+			case IT_SET_PANNING:

+				channel->Pan = (note->CommandValue + 2) >> 2;

+				break;

+			//case IT_PANBRELLO:

+			//case IT_MIDI_MACRO://see MIDI.TXT

+		}

+	}

+}

+

+

+

+void update_effects(MODULE *module)

+{

+	int i;

+

+	module->GlobalVolume += module->globalvolslide;

+	if (module->GlobalVolume > 128) {

+		if (module->globalvolslide >= 0)

+			module->GlobalVolume = 128;

+		else

+			module->GlobalVolume = 0;

+	}

+

+	module->Tempo += module->temposlide;

+	if (module->Tempo < 32) {

+		if (module->temposlide >= 0)

+			module->Tempo = 255;

+		else

+			module->Tempo = 32;

+	}

+

+	for (i = 0; i < 64; i++) {

+		MODULE_CHANNEL *channel = &module->Channel[i];

+

+		channel->Volume += channel->volslide;

+		if (channel->Volume > 64) {

+			if (channel->volslide >= 0)

+				channel->Volume = 64;

+			else

+				channel->Volume = 0;

+		}

+

+		channel->ChannelVolume += channel->channelvolslide;

+		if (channel->ChannelVolume > 64) {

+			if (channel->channelvolslide >= 0)

+				channel->ChannelVolume = 64;

+			else

+				channel->ChannelVolume = 0;

+		}

+

+		channel->pitch += channel->portamento;

+		//We do not enforce any limits here. IT surely does. Investigate.

+

+		if (channel->toneporta && channel->sample) {

+			int destpitch;

+			if (module->Flags & FLAG_USEINSTRUMENTS)

+				destpitch = module->Instrument[(int)channel->Instrument - 1].NoteNote[channel->Note];

+			else

+				destpitch = channel->Note;

+			destpitch = (destpitch - 60) << 8;

+			if (channel->pitch > destpitch) {

+				channel->pitch -= channel->toneporta;

+				if (channel->pitch < destpitch)

+					channel->pitch = destpitch;

+			} else if (channel->pitch < destpitch) {

+				channel->pitch += channel->toneporta;

+				if (channel->pitch > destpitch)

+					channel->pitch = destpitch;

+			}

+		}

+	}

+}

+

+

+

+void reset_effects(MODULE *module)

+{

+	int i;

+

+	module->globalvolslide = 0;

+	module->temposlide = 0;

+

+	for (i = 0; i < 64; i++) {

+		module->Channel[i].volslide = 0;

+		module->Channel[i].channelvolslide = 0;

+		module->Channel[i].portamento = 0;

+		module->Channel[i].toneporta = 0;

+	}

+}

+

+

+

+/* This function assumes note->Channel >= 0... or it might later. */

+void update_pattern_variables(MODULE *module, MODULE_NOTE *note)

+{

+	/* MODULE_CHANNEL *channel = &module->Channel[(int)note->Channel]; */

+

+	if (note->Mask & NOTEMASK_COMMAND) {

+		switch (note->Command) {

+			case IT_S:

+				switch (note->CommandValue >> 4) {

+					case IT_S_FINE_PATTERN_DELAY: module->tick = module->Speed + (note->CommandValue & 15); break;

+					//case IT_S7:

+					//case IT_S_PATTERN_LOOP:

+						/* SB0 Set loopback point */

+					//case IT_S_DELAYED_NOTE_CUT:

+					//case IT_S_NOTE_DELAY:

+					case IT_S_PATTERN_DELAY: module->rowcount = 1 + (note->CommandValue & 15); break;

+				}

+				break;

+		}

+	}

+}

+

+

+

+unsigned char envelope_get_y(MODULE_ENVELOPE *envelope, MODULE_VENVELOPE *venvelope)

+{

+	int ys, ye;

+	int ts, te;

+	int t;

+

+	if (venvelope->NextNode <= 0)

+		return envelope->NodeY[0];

+

+	if (venvelope->NextNode >= envelope->NumNodes)

+		return envelope->NodeY[envelope->NumNodes - 1];

+

+	ys = envelope->NodeY[venvelope->NextNode - 1];

+	ye = envelope->NodeY[venvelope->NextNode];

+	ts = envelope->NodeTick[venvelope->NextNode - 1];

+	te = envelope->NodeTick[venvelope->NextNode];

+	t = venvelope->CurTick;

+

+	if (ts == te)

+		return ys;

+

+	return ys + (ye - ys) * (t - ts) / (te - ts);

+}

+

+

+

+unsigned int calculate_volume(MODULE *module, MODULE_VCHANNEL *vchannel)

+{

+	if (module->Flags & FLAG_USEINSTRUMENTS) {

+		int vev = 64;

+		if (module->Instrument[vchannel->Instrument - 1].VolumeEnvelope.Flag & ENVELOPE_ON)

+			vev = envelope_get_y(&module->Instrument[vchannel->Instrument - 1].VolumeEnvelope, &vchannel->VVolEnv);

+		return (((((((vchannel->Volume *

+					  vchannel->sample->GlobalVolume *

+					  module->Instrument[vchannel->Instrument - 1].GlobalVolume) >> 7) *

+					  module->GlobalVolume) >> 11) *

+					  vev *

+					  module->MixVolume) >> 10) *

+					  vchannel->fadeoutcount) >> 11;

+	}

+

+	return (((vchannel->Volume *

+			  vchannel->sample->GlobalVolume *

+			  module->GlobalVolume) >> 11) *

+			  module->MixVolume) >> 5;

+}

+

+

+

+void process_channels(MODULE *module)

+{

+	int i;

+

+	for (i = 0; i < 64; i++) {

+		MODULE_CHANNEL *channel = &module->Channel[i];

+		if (channel->Note < 120) {

+			if (channel->Flag & CHANNEL_RETRIG) {

+				channel->Flag &= ~CHANNEL_RETRIG;

+				if (channel->VChannel) {

+					if (!(module->Flags & FLAG_USEINSTRUMENTS) ||

+						(channel->VChannel->NNA = module->Instrument[channel->VChannel->Instrument - 1].NewNoteAction)

+						== NNA_NOTECUT)

+					{

+						if (channel->VChannel->Flag & VCHANNEL_PLAYING) {

+							write_seqtime();

+							sequence_c(SEQUENCE_STOP_SIGNAL);

+							sequence_c(channel->VChannel - module->VChannel);

+						}

+					} else {

+						if (channel->VChannel->NNA == NNA_NOTEOFF)

+							if ((module->Instrument[channel->VChannel->Instrument - 1].VolumeEnvelope.Flag & (ENVELOPE_ON | ENVELOPE_LOOP_ON)) != ENVELOPE_ON)

+								channel->VChannel->NNA = NNA_NOTEFADE;

+						if (channel->VChannel->NNA == NNA_NOTEFADE)

+							channel->VChannel->Flag |= VCHANNEL_FADING;

+						channel->VChannel->Flag |= VCHANNEL_BACKGROUND;

+						channel->VChannel->channel = NULL;

+						channel->VChannel = NULL;

+					}

+				}

+				if (!channel->VChannel) {

+					int k;

+					for (k = 0; k < 256; k++) {

+						if (!(module->VChannel[k].Flag & VCHANNEL_PLAYING)) {

+							channel->VChannel = &module->VChannel[k];

+							break;

+						}

+					}

+					if (!channel->VChannel) {

+						for (k = 0; k < 256; k++) {

+							if (module->VChannel[k].Flag & VCHANNEL_BACKGROUND) {

+								write_seqtime();

+								sequence_c(SEQUENCE_STOP_SIGNAL);

+								sequence_c(k);

+								channel->VChannel = &module->VChannel[k];

+								break;

+							}

+						}

+					}

+				}

+				if (channel->VChannel) {

+					unsigned char note;

+					channel->VChannel->Flag = VCHANNEL_PLAYING | VCHANNEL_RETRIG;

+					channel->VChannel->channel = channel;

+					channel->VChannel->Note = channel->Note;

+					if (module->Flags & FLAG_USEINSTRUMENTS)

+						note = module->Instrument[(int)channel->Instrument - 1].NoteNote[channel->Note];

+					else

+						note = channel->Note;

+					channel->pitch = (note - 60) << 8;

+					channel->VChannel->pitch = channel->pitch;

+					channel->VChannel->Instrument = channel->Instrument;

+					channel->VChannel->sample = channel->sample;

+					channel->VChannel->VVolEnv.NextNode = 0;

+					channel->VChannel->VVolEnv.CurTick = 0;

+					channel->VChannel->fadeoutcount = 1024;

+					channel->VChannel->NNA = NNA_NOTECONTINUE;

+					channel->VChannel->Volume = channel->ChannelVolume * channel->Volume;

+					channel->VChannel->Pan = channel->Pan;

+					channel->VChannel->PanSep = channel->PanSep;

+					/* Note: The DUH* fields are set when writing the start command to the DUH sequence. */

+					//BLEARGH: Anything else to initialise?

+				}

+			}

+		} else if (channel->VChannel) {

+			if (channel->Note == NOTE_CUT) {

+				if (channel->VChannel->Flag & VCHANNEL_PLAYING) {

+					write_seqtime();

+					sequence_c(SEQUENCE_STOP_SIGNAL);

+					sequence_c(channel->VChannel - module->VChannel);

+					channel->VChannel->Flag &= ~VCHANNEL_PLAYING;

+					channel->VChannel->channel = NULL;

+					channel->VChannel = NULL;

+				}

+			} else {

+				channel->VChannel->Flag |= VCHANNEL_BACKGROUND;

+

+				if (channel->Note == NOTE_OFF) {

+					if ((module->Instrument[channel->VChannel->Instrument - 1].VolumeEnvelope.Flag & (ENVELOPE_ON | ENVELOPE_LOOP_ON)) != ENVELOPE_ON)

+						channel->VChannel->NNA = NNA_NOTEFADE;

+					else

+						channel->VChannel->NNA = NNA_NOTEOFF;

+				} else

+					channel->VChannel->NNA = NNA_NOTEFADE;

+

+				if (channel->VChannel->NNA == NNA_NOTEFADE)

+					channel->VChannel->Flag |= VCHANNEL_FADING;

+				/*

+				channel->VChannel->channel = NULL;

+				channel->VChannel = NULL;

+				*/

+			}

+		}

+	}

+}

+

+

+

+/* This returns 1 if the envelope finishes. */

+int update_envelope(MODULE_VCHANNEL *vchannel, MODULE_ENVELOPE *envelope, MODULE_VENVELOPE *venvelope)

+{

+	if (!(envelope->Flag & ENVELOPE_ON))

+		return 0;

+

+	if (venvelope->NextNode >= envelope->NumNodes)

+		return 1;

+

+	while (venvelope->CurTick >= envelope->NodeTick[venvelope->NextNode]) {

+		if ((envelope->Flag & ENVELOPE_LOOP_ON) && venvelope->NextNode == envelope->LoopEnd) {

+			venvelope->NextNode = envelope->LoopBegin;

+			venvelope->CurTick = envelope->NodeTick[envelope->LoopBegin];

+			return 0;

+		}

+		if ((envelope->Flag & ENVELOPE_SUSTAINLOOP) && !(vchannel->Flag & VCHANNEL_BACKGROUND) && venvelope->NextNode == envelope->SustainLoopEnd) {

+			venvelope->NextNode = envelope->SustainLoopBegin;

+			venvelope->CurTick = envelope->NodeTick[envelope->SustainLoopBegin];

+			return 0;

+		}

+		if (venvelope->NextNode >= envelope->NumNodes)

+			return 1;

+

+		venvelope->NextNode++;

+	}

+

+	venvelope->CurTick++;

+

+	return 0;

+}

+

+

+

+/* This assumes the module uses instruments. */

+void update_envelopes(MODULE *module, MODULE_VCHANNEL *vchannel)

+{

+	if (vchannel->Flag & VCHANNEL_PLAYING) {

+		MODULE_ENVELOPE *volenv = &module->Instrument[vchannel->Instrument - 1].VolumeEnvelope;

+

+		if (update_envelope(vchannel, volenv, &vchannel->VVolEnv)) {

+			if (volenv->NumNodes && volenv->NodeY[volenv->NumNodes - 1] == 0) {

+				write_seqtime();

+				sequence_c(SEQUENCE_STOP_SIGNAL);

+				sequence_c(vchannel - module->VChannel);

+				vchannel->Flag = 0;

+				if (vchannel->channel)

+					vchannel->channel->VChannel = NULL;

+				vchannel->channel = NULL;

+			} else

+				vchannel->Flag |= VCHANNEL_FADING;

+		}

+	}

+}

+

+

+

+/* This assumes the module uses instruments. */

+void update_fadeout(MODULE *module, MODULE_VCHANNEL *vchannel)

+{

+	if (vchannel->Flag & VCHANNEL_PLAYING) {

+		if (vchannel->Flag & VCHANNEL_FADING) {

+			vchannel->fadeoutcount -= module->Instrument[vchannel->Instrument - 1].FadeOut;

+

+			if (vchannel->fadeoutcount <= 0) {

+				write_seqtime();

+				sequence_c(SEQUENCE_STOP_SIGNAL);

+				sequence_c(vchannel - module->VChannel);

+				vchannel->Flag = 0;

+				if (vchannel->channel)

+					vchannel->channel->VChannel = NULL;

+				vchannel->channel = NULL;

+			}

+		}

+	}

+}

+

+

+

+#define INCLUDE_RETRIG

+#define INCLUDE_PLAYING

+void process_vchannels(MODULE *module)

+{

+	int i;

+

+	for (i = 0; i < 256; i++) {

+		MODULE_VCHANNEL *vchannel = &module->VChannel[i];

+

+		if ((vchannel->Flag & VCHANNEL_PLAYING) && vchannel->channel) {

+			vchannel->Volume = vchannel->channel->ChannelVolume * vchannel->channel->Volume;

+			vchannel->Pan = vchannel->channel->Pan;

+			vchannel->PanSep = vchannel->channel->PanSep;

+		}

+

+		if (module->Flags & FLAG_USEINSTRUMENTS) {

+			//Update envelopes as required

+			update_envelopes(module, vchannel);

+			//Update fadeout as required

+			update_fadeout(module, vchannel);

+			//Calculate final volume if req

+			//Calculate final pan if req

+			//Process sample vibrato if req

+		} else {

+			//Calculate final volume if required

+			//Calculate final pan if required

+			//Process sample vibrato if required

+		}

+

+#ifdef INCLUDE_RETRIG

+		if (vchannel->Flag & VCHANNEL_RETRIG) {

+			vchannel->Flag &= ~VCHANNEL_RETRIG;

+

+			if (vchannel->sample) {

+				int C5Speed = vchannel->sample->C5Speed;

+				int adjust;

+

+#ifdef STEREO_SAMPLES_COUNT_AS_TWO

+				if (vchannel->sample->Flag & SAMPLE_STEREO)

+					C5Speed >>= 1;

+#endif

+

+				write_seqtime();

+				sequence_c(SEQUENCE_START_SIGNAL);

+				sequence_c(vchannel - module->VChannel);

+

+				sequence_cl(sample_signal[vchannel->sample - module->Sample]);

+				sequence_cl(0); // sample position: 65536 is one second

+

+				vchannel->DUHvol = calculate_volume(module, vchannel);

+

+				sequence_w(vchannel->DUHvol - (vchannel->DUHvol >> 16));

+

+				adjust = floor(12 * 256 *

+						(log(C5Speed / 65536.0) / log(2.0)) + 0.5);

+

+				/* pitch */

+				sequence_w(adjust + vchannel->pitch);

+

+				vchannel->DUHpan = 32;

+

+			} else

+				vchannel->Flag = 0;

+		}

+#endif

+

+#ifdef INCLUDE_PLAYING

+		if (vchannel->Flag & VCHANNEL_PLAYING) {

+			//Update to vchannel->channel->stuff if different from vchannel->stuff.

+			//stuff would be volume, panning, pitch, etc.

+			{

+				unsigned int volume = calculate_volume(module, vchannel);

+				if (volume != vchannel->DUHvol) {

+					vchannel->DUHvol = volume;

+					write_seqtime();

+					sequence_c(SEQUENCE_SET_VOLUME);

+					sequence_c(vchannel - module->VChannel);

+					sequence_w(volume - (volume >> 16));

+				}

+			}

+			{

+				int pan = vchannel->Pan + vchannel->PanSep;

+				if (pan < 0)

+					pan = 0;

+				else if (pan > 64)

+					pan = 64;

+				if (pan != vchannel->DUHpan) {

+					vchannel->DUHpan = pan;

+					write_seqtime();

+					sequence_c(SEQUENCE_SET_PARAMETER);

+					sequence_c(vchannel - module->VChannel);

+					sequence_c(SPANPARAM_PAN);

+					sequence_l(((int)pan << 3) - 256);

+				}

+			}

+			if (vchannel->channel) {

+				if (vchannel->channel->pitch != vchannel->pitch) {

+					int C5Speed = vchannel->sample->C5Speed;

+					int adjust;

+

+#ifdef STEREO_SAMPLES_COUNT_AS_TWO

+					if (vchannel->sample->Flag & SAMPLE_STEREO)

+						C5Speed >>= 1;

+#endif

+

+					vchannel->pitch = vchannel->channel->pitch;

+

+					write_seqtime();

+					sequence_c(SEQUENCE_SET_PITCH);

+					sequence_c(vchannel - module->VChannel);

+

+					adjust = floor(12 * 256 *

+							(log(C5Speed / 65536.0) / log(2.0)) + 0.5);

+

+					sequence_w(adjust + vchannel->pitch);

+				}

+			}

+

+			if (vchannel->Flag & VCHANNEL_BACKGROUND) {

+				//Process vchannel->NNA

+				//If the note has ended then:

+				/*

+				{

+					write_seqtime();

+					sequence_c(SEQUENCE_STOP_SIGNAL);

+					sequence_c(vchannel - module->VChannel);

+					vchannel->Flag = 0;

+				}

+				*/

+			} else {

+				//Process note

+			}

+		}

+#endif

+	}

+}

+

+

+

+void generate_patterns(MODULE *module)

+{

+	int patnum = module->Order[0];

+	int row;

+

+	MODULE_PATTERN *pattern;

+	MODULE_NOTE *note, *note_end;

+

+	module->processorder = 0;

+	module->processrow = 0;

+	module->breakrow = 0;

+	module->rowcount = 1;

+

+	module->tick = module->Speed;

+

+	goto start_the_loop; /* This ungainly goto will be averted later. */

+

+	for (;;) {

+		// Set note vol/freq to vol/freq set for each channel

+

+		module->tick--;

+		if (module->tick == 0) {

+			module->tick = module->Speed;

+			module->rowcount--;

+			if (module->rowcount == 0) {

+				module->rowcount = 1;

+				module->processrow++;

+				if (module->processrow >= pattern->NumRows) {

+					module->processrow = module->breakrow;

+					module->breakrow = 0;

+					module->processorder++;

+

+					start_the_loop:

+

+					for (; ; module->processorder++) {

+						if (module->processorder >= module->NumOrders)

+							return;

+

+						patnum = module->Order[module->processorder];

+

+						if (patnum < module->NumPatterns)

+							break;

+

+#ifdef INVALID_ORDERS_END_SONG

+						if (patnum != ORDER_SKIP)

+							return;

+#else

+						if (patnum == ORDER_END)

+							return;

+#endif

+					}

+

+					printf("  Order %i, Pattern %i\n", module->processorder, patnum);

+

+					pattern = &module->Pattern[patnum];

+

+				 	note = pattern->Note;

+				 	note_end = note + pattern->NumNotes;

+				}

+

+				row = module->processrow;

+

+				{

+					MODULE_NOTE *note_start = note;

+

+					while (note < note_end && note->Channel >= 0)

+						update_pattern_variables(module, note++);

+

+					note = note_start;

+				}

+

+				reset_effects(module);

+

+				//Should this code go before updating the pattern variables?

+				while (note < note_end) {

+ 					if (note->Channel < 0) {

+						note++;

+						break;

+					}

+					process_note_data(module, note++);

+				}

+

+			} else

+				update_effects(module);

+		} else

+			update_effects(module);

+

+		process_channels(module);

+

+		/* Output sound!!! */

+		process_vchannels(module);

+

+		/* Increment time by one tick. */

+		{

+			int inc = ((65536.0 * 60.0) / (4.0 * 6.0)) / module->Tempo;

+			seqtime += inc;

+			songtime += inc;

+		}

+	}

+}

+

+

+

+void stop_notes(MODULE *module)

+{

+	int c;

+	for (c = 0; c < 256; c++) {

+		if (module->VChannel[c].Flag & VCHANNEL_PLAYING) {

+			write_seqtime();

+			sequence_c(SEQUENCE_STOP_SIGNAL);

+			sequence_c(c);

+		}

+	}

+}

+

+

+

+void generate_sequence(MODULE *module)

+{

+	int i;

+

+	for (i = 0; i < 64; i++) {

+		module->Channel[i].Note = 255;

+		module->Channel[i].Instrument = 0;

+		module->Channel[i].sample = NULL;

+		module->Channel[i].VChannel = NULL;

+		module->Channel[i].lastvolslide = 0;

+		module->Channel[i].lastDKL = 0;

+		module->Channel[i].lastN = 0;

+		module->Channel[i].lastW = 0;

+		module->Channel[i].lastEF = 0;

+		module->Channel[i].lastG = 0;

+		module->Channel[i].lastT = 0;

+	}

+

+	for (i = 0; i < 256; i++)

+		module->VChannel[i].Flag = 0;

+

+	songtime = 0;

+

+	generate_patterns(module);

+/*

+	for (i = 0; i < module->NumOrders; i++) {

+

+		if (module->Order[i] < module->NumPatterns)

+			write_pattern(module, &module->Pattern[module->Order[i]]);

+		else {

+#ifdef INVALID_ORDERS_END_SONG

+			if (module->Order[i] != ORDER_SKIP)

+				break;

+#else

+			if (module->Order[i] == ORDER_END)

+				break;

+#endif

+		}

+	}

+*/

+	stop_notes(module);

+

+	/* Negative time to indicate the end of the sequence. */

+	sequence_cl(-1);

+

+	if (errno)

+		return;

+}

+

+

+

+void write_sequence(PACKFILE *f)

+{

+	pack_mputl(SIGTYPE_SEQUENCE, f);

+

+	pack_iputl(seqpos, f);

+	pack_fwrite(seqdata, seqpos, f);

+}

+

+

+

+void free_sequence()

+{

+	free(seqdata);

+	seqdata = NULL;

+	seqpos = 0;

+	max_seqdata = 0;

+	seqtime = 0;

+}

+

+

+

+int save_it_to_duh(MODULE *module, const char *filename)

+{

+	int i;

+	int n_samples = 0;

+

+	PACKFILE *f = pack_fopen(filename, F_WRITE_PACKED);

+	if (!f) return 1;

+

+	/* Write signature. */

+	pack_mputl(DUH_SIGNATURE, f);

+

+	/* Create array of true samples. */

+	sample_signal = malloc(module->NumSamples * sizeof(*sample_signal));

+

+	for (i = 0; i < module->NumSamples; i++) {

+		if (sample_is_valid(&module->Sample[i])) {

+			sample_signal[i] = first_sample + n_samples;

+			if (module->Sample[i].Flag & SAMPLE_STEREO)

+				n_samples += 3; /* COMB,SAMP,SAMP */

+			else

+				n_samples += 2; /* SPAN,SAMP */

+		} else

+			sample_signal[i] = -1;

+	}

+

+	printf("Generating sequence\n");

+	generate_sequence(module);

+

+	/* Write length of song. */

+	pack_iputl(songtime, f);

+

+	/* Write number of signals - one for the sequence, one for each sample. */

+	pack_iputl(1 + n_samples, f);

+

+	if (errno) {pack_fclose(f); free(sample_signal); return 1;}

+

+	printf("Writing sequence\n");

+	write_sequence(f);

+	free_sequence();

+

+	if (errno) {pack_fclose(f); free(sample_signal); return 1;}

+

+	printf("Writing samples");

+	n_samples = 0;

+	for (i = 0; i < module->NumSamples; i++) {

+		if ((i & 7) == 0)

+			printf("\n  ");

+		printf("%4d", i + 1);

+

+		if (sample_is_valid(&module->Sample[i])) {

+

+			if (module->Sample[i].Flag & SAMPLE_STEREO) {

+				write_stereo_sample(&module->Sample[i], n_samples, f);

+				n_samples += 3;

+			} else {

+				write_mono_sample(&module->Sample[i], n_samples, f);

+				n_samples += 2;

+			}

+

+			if (errno) {pack_fclose(f); free(sample_signal); return 1;}

+		}

+	}

+	printf("\n");

+

+	free(sample_signal);

+	sample_signal = NULL;

+

+	pack_fclose(f);

+

+	if (errno) {pack_fclose(f); return 1;}

+

+	return 0;

+}

+

+

+

+#undef first_sample

+

+

+

+void usage()

+{

+	allegro_message(

+		"Usage: cit.exe filename.it [filename.duh]\n"

+		"Converts an Impulse Tracker file into a Dynamic Universal Harmony.\n"

+	);

+

+	exit(1);

+}

+

+

+

+int main(int argc, char *argv[])

+{

+	MODULE *module;

+	int rv;

+	char *outmod;

+

+	if (argc < 2 || argc > 3)

+		usage();

+

+	allegro_init();

+	

+	/* Make the output file name if it wasn't specified */

+	if (argc == 2) {

+		int size = sizeof(char) * (ustrsizez(argv[1]) + 32);

+		outmod = malloc(size);

+		if (!outmod) {

+			allegro_message("Ran out of memory while trying to allocate %i bytes. (%s:(%i))\n", size, __FILE__, __LINE__);

+			return -1;

+		}

+		ustrzcpy(outmod, size, argv[1]);

+		replace_extension(outmod, argv[1], "duh", size);

+	}

+	else

+		outmod = argv[2];

+

+	module = load_it(argv[1]);

+

+	if (!module) {

+		allegro_exit();

+		allegro_message("Unable to load %s!\n", argv[1]);

+		return 1;

+	}

+

+	rv = save_it_to_duh(module, outmod);

+

+	destroy_it(module);

+

+	if (rv) {

+		delete_file(outmod);

+		allegro_exit();

+		allegro_message("Unable to save %s!\n", outmod);

+		return 1;

+	}

+	

+	if (argc == 2 && outmod)

+		free(outmod);

+

+	return 0;

+}

+END_OF_MAIN();

diff --git a/plugins/dumb/dumb-kode54/tools/citbugs.txt b/plugins/dumb/dumb-kode54/tools/citbugs.txt
new file mode 100644
index 00000000..20f71506
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/tools/citbugs.txt
@@ -0,0 +1,13 @@
+Bugs in cit.c

+-------------

+

+Please add to this list if you find cit.c is unfaithful to your IT file in any way (other than stuff that isn't implemented yet).

+

+channel->sample is only initialised when the instrument is changed. This means multisample instruments don't work properly.

+

+New SET_VOLUME commands are only written to the DUH file in the specific case that the channel volume changes. If any other volume changes, no command is written.

+

+cit.c is likely not to exhibit the same behaviour as IT when dealing with conflicting volume and effect column commands.

+

+Music length not properly converted. Winamp reports 4:05 on the .it and .xm, but 2:20 on the .duh

+

diff --git a/plugins/dumb/dumb-kode54/vc6/aldumb/aldumb.dsp b/plugins/dumb/dumb-kode54/vc6/aldumb/aldumb.dsp
new file mode 100644
index 00000000..ae1c2060
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/aldumb/aldumb.dsp
@@ -0,0 +1,142 @@
+# Microsoft Developer Studio Project File - Name="aldumb" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Static Library" 0x0104

+

+CFG=aldumb - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "aldumb.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "aldumb.mak" CFG="aldumb - Win32 Debug"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "aldumb - Win32 Release" (based on "Win32 (x86) Static Library")

+!MESSAGE "aldumb - Win32 Debug" (based on "Win32 (x86) Static Library")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "aldumb - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c

+# ADD CPP /nologo /MD /W3 /GX- /O2 /I "../../include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "DUMB_DECLARE_DEPRECATED" /FD /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "NDEBUG"

+# ADD RSC /l 0x409 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LIB32=link.exe -lib

+# ADD BASE LIB32 /nologo

+# ADD LIB32 /nologo /out:"Release\aldmb.lib"

+

+!ELSEIF  "$(CFG)" == "aldumb - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "Debug"

+# PROP BASE Intermediate_Dir "Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir "Debug"

+# PROP Intermediate_Dir "Debug"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c

+# ADD CPP /nologo /MDd /W3 /Gm /GX- /ZI /Od /I "../../include" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "DUMB_DECLARE_DEPRECATED" /D DEBUGMODE=1 /FD /GZ /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LIB32=link.exe -lib

+# ADD BASE LIB32 /nologo

+# ADD LIB32 /nologo /out:"Debug\aldmd.lib"

+

+!ENDIF 

+

+# Begin Target

+

+# Name "aldumb - Win32 Release"

+# Name "aldumb - Win32 Debug"

+# Begin Group "src"

+

+# PROP Default_Filter ""

+# Begin Group "allegro"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\src\allegro\alplay.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\allegro\datduh.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\allegro\datit.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\allegro\datmod.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\allegro\dats3m.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\allegro\datunld.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\allegro\datxm.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\allegro\packfile.c

+# End Source File

+# End Group

+# End Group

+# Begin Group "include"

+

+# PROP Default_Filter ""

+# Begin Group "internal"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\include\internal\aldumb.h

+# End Source File

+# End Group

+# Begin Source File

+

+SOURCE=..\..\include\aldumb.h

+# End Source File

+# End Group

+# End Target

+# End Project

diff --git a/plugins/dumb/dumb-kode54/vc6/aldumb/aldumb.vcproj b/plugins/dumb/dumb-kode54/vc6/aldumb/aldumb.vcproj
new file mode 100644
index 00000000..18a45294
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/aldumb/aldumb.vcproj
@@ -0,0 +1,303 @@
+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+	ProjectType="Visual C++"

+	Version="7.10"

+	Name="aldumb"

+	SccProjectName=""

+	SccLocalPath="">

+	<Platforms>

+		<Platform

+			Name="Win32"/>

+	</Platforms>

+	<Configurations>

+		<Configuration

+			Name="Debug|Win32"

+			OutputDirectory=".\Debug"

+			IntermediateDirectory=".\Debug"

+			ConfigurationType="4"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="_DEBUG;WIN32;_LIB;DUMB_DECLARE_DEPRECATED;DEBUGMODE=1"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="3"

+				PrecompiledHeaderFile=".\Debug/aldumb.pch"

+				AssemblerListingLocation=".\Debug/"

+				ObjectFile=".\Debug/"

+				ProgramDataBaseFileName=".\Debug/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				DebugInformationFormat="4"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLibrarianTool"

+				OutputFile="Debug\aldmd.lib"

+				SuppressStartupBanner="TRUE"/>

+			<Tool

+				Name="VCMIDLTool"/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="_DEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+		<Configuration

+			Name="Release|Win32"

+			OutputDirectory=".\Release"

+			IntermediateDirectory=".\Release"

+			ConfigurationType="4"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="2"

+				InlineFunctionExpansion="1"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="NDEBUG;WIN32;_LIB;DUMB_DECLARE_DEPRECATED"

+				StringPooling="TRUE"

+				RuntimeLibrary="2"

+				EnableFunctionLevelLinking="TRUE"

+				PrecompiledHeaderFile=".\Release/aldumb.pch"

+				AssemblerListingLocation=".\Release/"

+				ObjectFile=".\Release/"

+				ProgramDataBaseFileName=".\Release/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLibrarianTool"

+				OutputFile="Release\aldmb.lib"

+				SuppressStartupBanner="TRUE"/>

+			<Tool

+				Name="VCMIDLTool"/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="NDEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+	</Configurations>

+	<References>

+	</References>

+	<Files>

+		<Filter

+			Name="src"

+			Filter="">

+			<Filter

+				Name="allegro"

+				Filter="">

+				<File

+					RelativePath="..\..\src\allegro\alplay.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\allegro\datduh.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\allegro\datit.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\allegro\datmod.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\allegro\dats3m.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\allegro\datunld.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\allegro\datxm.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\allegro\packfile.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+			</Filter>

+		</Filter>

+		<Filter

+			Name="include"

+			Filter="">

+			<File

+				RelativePath="..\..\include\aldumb.h">

+			</File>

+			<Filter

+				Name="internal"

+				Filter="">

+				<File

+					RelativePath="..\..\include\internal\aldumb.h">

+				</File>

+			</Filter>

+		</Filter>

+	</Files>

+	<Globals>

+	</Globals>

+</VisualStudioProject>

diff --git a/plugins/dumb/dumb-kode54/vc6/dumb.dsw b/plugins/dumb/dumb-kode54/vc6/dumb.dsw
new file mode 100644
index 00000000..7231ad56
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumb.dsw
@@ -0,0 +1,122 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00

+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!

+

+###############################################################################

+

+Project: "aldumb"=.\aldumb\aldumb.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+    Begin Project Dependency

+    Project_Dep_Name dumb

+    End Project Dependency

+}}}

+

+###############################################################################

+

+Project: "dumb"=.\dumb\dumb.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+}}}

+

+###############################################################################

+

+Project: "dumb2wav"=.\dumb2wav\dumb2wav.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+    Begin Project Dependency

+    Project_Dep_Name dumb

+    End Project Dependency

+}}}

+

+###############################################################################

+

+Project: "dumb_static"=.\dumb_static\dumb_static.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+}}}

+

+###############################################################################

+

+Project: "dumbout"=.\dumbout\dumbout.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+    Begin Project Dependency

+    Project_Dep_Name dumb

+    End Project Dependency

+}}}

+

+###############################################################################

+

+Project: "dumbplay"=.\dumbplay\dumbplay.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+    Begin Project Dependency

+    Project_Dep_Name dumb

+    End Project Dependency

+    Begin Project Dependency

+    Project_Dep_Name aldumb

+    End Project Dependency

+}}}

+

+###############################################################################

+

+Project: "playduh"=.\playduh\playduh.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+    Begin Project Dependency

+    Project_Dep_Name dumb

+    End Project Dependency

+    Begin Project Dependency

+    Project_Dep_Name aldumb

+    End Project Dependency

+}}}

+

+###############################################################################

+

+Global:

+

+Package=<5>

+{{{

+}}}

+

+Package=<3>

+{{{

+}}}

+

+###############################################################################

+

diff --git a/plugins/dumb/dumb-kode54/vc6/dumb.sln b/plugins/dumb/dumb-kode54/vc6/dumb.sln
new file mode 100644
index 00000000..99611c5c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumb.sln
@@ -0,0 +1,76 @@
+Microsoft Visual Studio Solution File, Format Version 8.00

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "aldumb", "aldumb\aldumb.vcproj", "{52284B81-C5B7-4D22-94FE-9C1B55CD9BF8}"

+	ProjectSection(ProjectDependencies) = postProject

+		{D1D61D22-D6DF-4F7B-9B08-7277D1DC827C} = {D1D61D22-D6DF-4F7B-9B08-7277D1DC827C}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dumb", "dumb\dumb.vcproj", "{D1D61D22-D6DF-4F7B-9B08-7277D1DC827C}"

+	ProjectSection(ProjectDependencies) = postProject

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dumb2wav", "dumb2wav\dumb2wav.vcproj", "{9361AC48-0738-47B1-889E-EAD7BDBCA582}"

+	ProjectSection(ProjectDependencies) = postProject

+		{D1D61D22-D6DF-4F7B-9B08-7277D1DC827C} = {D1D61D22-D6DF-4F7B-9B08-7277D1DC827C}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dumb_static", "dumb_static\dumb_static.vcproj", "{670DC283-AC49-439A-A6F5-90680409B633}"

+	ProjectSection(ProjectDependencies) = postProject

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dumbout", "dumbout\dumbout.vcproj", "{428A0137-5329-42C2-9D7F-C6FEBA030465}"

+	ProjectSection(ProjectDependencies) = postProject

+		{D1D61D22-D6DF-4F7B-9B08-7277D1DC827C} = {D1D61D22-D6DF-4F7B-9B08-7277D1DC827C}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dumbplay", "dumbplay\dumbplay.vcproj", "{C5595BE0-2BA0-4829-93EE-43FE4BED45B2}"

+	ProjectSection(ProjectDependencies) = postProject

+		{52284B81-C5B7-4D22-94FE-9C1B55CD9BF8} = {52284B81-C5B7-4D22-94FE-9C1B55CD9BF8}

+		{D1D61D22-D6DF-4F7B-9B08-7277D1DC827C} = {D1D61D22-D6DF-4F7B-9B08-7277D1DC827C}

+	EndProjectSection

+EndProject

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "playduh", "playduh\playduh.vcproj", "{63C5F9B1-079A-4855-BB43-33430B3E400E}"

+	ProjectSection(ProjectDependencies) = postProject

+		{52284B81-C5B7-4D22-94FE-9C1B55CD9BF8} = {52284B81-C5B7-4D22-94FE-9C1B55CD9BF8}

+		{D1D61D22-D6DF-4F7B-9B08-7277D1DC827C} = {D1D61D22-D6DF-4F7B-9B08-7277D1DC827C}

+	EndProjectSection

+EndProject

+Global

+	GlobalSection(SolutionConfiguration) = preSolution

+		Debug = Debug

+		Release = Release

+	EndGlobalSection

+	GlobalSection(ProjectConfiguration) = postSolution

+		{52284B81-C5B7-4D22-94FE-9C1B55CD9BF8}.Debug.ActiveCfg = Debug|Win32

+		{52284B81-C5B7-4D22-94FE-9C1B55CD9BF8}.Debug.Build.0 = Debug|Win32

+		{52284B81-C5B7-4D22-94FE-9C1B55CD9BF8}.Release.ActiveCfg = Release|Win32

+		{52284B81-C5B7-4D22-94FE-9C1B55CD9BF8}.Release.Build.0 = Release|Win32

+		{D1D61D22-D6DF-4F7B-9B08-7277D1DC827C}.Debug.ActiveCfg = Debug|Win32

+		{D1D61D22-D6DF-4F7B-9B08-7277D1DC827C}.Debug.Build.0 = Debug|Win32

+		{D1D61D22-D6DF-4F7B-9B08-7277D1DC827C}.Release.ActiveCfg = Release|Win32

+		{D1D61D22-D6DF-4F7B-9B08-7277D1DC827C}.Release.Build.0 = Release|Win32

+		{9361AC48-0738-47B1-889E-EAD7BDBCA582}.Debug.ActiveCfg = Debug|Win32

+		{9361AC48-0738-47B1-889E-EAD7BDBCA582}.Debug.Build.0 = Debug|Win32

+		{9361AC48-0738-47B1-889E-EAD7BDBCA582}.Release.ActiveCfg = Release|Win32

+		{9361AC48-0738-47B1-889E-EAD7BDBCA582}.Release.Build.0 = Release|Win32

+		{670DC283-AC49-439A-A6F5-90680409B633}.Debug.ActiveCfg = Debug|Win32

+		{670DC283-AC49-439A-A6F5-90680409B633}.Debug.Build.0 = Debug|Win32

+		{670DC283-AC49-439A-A6F5-90680409B633}.Release.ActiveCfg = Release|Win32

+		{670DC283-AC49-439A-A6F5-90680409B633}.Release.Build.0 = Release|Win32

+		{428A0137-5329-42C2-9D7F-C6FEBA030465}.Debug.ActiveCfg = Debug|Win32

+		{428A0137-5329-42C2-9D7F-C6FEBA030465}.Debug.Build.0 = Debug|Win32

+		{428A0137-5329-42C2-9D7F-C6FEBA030465}.Release.ActiveCfg = Release|Win32

+		{428A0137-5329-42C2-9D7F-C6FEBA030465}.Release.Build.0 = Release|Win32

+		{C5595BE0-2BA0-4829-93EE-43FE4BED45B2}.Debug.ActiveCfg = Debug|Win32

+		{C5595BE0-2BA0-4829-93EE-43FE4BED45B2}.Debug.Build.0 = Debug|Win32

+		{C5595BE0-2BA0-4829-93EE-43FE4BED45B2}.Release.ActiveCfg = Release|Win32

+		{C5595BE0-2BA0-4829-93EE-43FE4BED45B2}.Release.Build.0 = Release|Win32

+		{63C5F9B1-079A-4855-BB43-33430B3E400E}.Debug.ActiveCfg = Debug|Win32

+		{63C5F9B1-079A-4855-BB43-33430B3E400E}.Debug.Build.0 = Debug|Win32

+		{63C5F9B1-079A-4855-BB43-33430B3E400E}.Release.ActiveCfg = Release|Win32

+		{63C5F9B1-079A-4855-BB43-33430B3E400E}.Release.Build.0 = Release|Win32

+	EndGlobalSection

+	GlobalSection(ExtensibilityGlobals) = postSolution

+	EndGlobalSection

+	GlobalSection(ExtensibilityAddIns) = postSolution

+	EndGlobalSection

+EndGlobal

diff --git a/plugins/dumb/dumb-kode54/vc6/dumb/dumb.dsp b/plugins/dumb/dumb-kode54/vc6/dumb/dumb.dsp
new file mode 100644
index 00000000..785f0418
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumb/dumb.dsp
@@ -0,0 +1,672 @@
+# Microsoft Developer Studio Project File - Name="dumb" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Static Library" 0x0104

+

+CFG=dumb - Win32 Release

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "dumb.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "dumb.mak" CFG="dumb - Win32 Release"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "dumb - Win32 Release" (based on "Win32 (x86) Static Library")

+!MESSAGE "dumb - Win32 Debug" (based on "Win32 (x86) Static Library")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+MTL=midl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir ".\Release"

+# PROP BASE Intermediate_Dir ".\Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir ".\Release"

+# PROP Intermediate_Dir ".\Release"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /MD /I "../../include" /W3 /O2 /Ob2 /D "NDEBUG" /D "WIN32" /D "_LIB" /D "DUMB_DECLARE_DEPRECATED" /D "_MBCS" /GF /Gy /Fp".\Release/dumb.pch" /Fo".\Release/" /Fd".\Release/" /c /GX 

+# ADD CPP /nologo /MD /I "../../include" /W3 /O2 /Ob2 /D "NDEBUG" /D "WIN32" /D "_LIB" /D "DUMB_DECLARE_DEPRECATED" /D "_MBCS" /GF /Gy /Fp".\Release/dumb.pch" /Fo".\Release/" /Fd".\Release/" /c /GX 

+# ADD BASE MTL /nologo /win32 

+# ADD MTL /nologo /win32 

+# ADD BASE RSC /l 1033 /d "NDEBUG" 

+# ADD RSC /l 1033 /d "NDEBUG" 

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo 

+# ADD BSC32 /nologo 

+LIB32=link.exe -lib

+# ADD BASE LIB32 /nologo /out:".\Release\dumb.lib" 

+# ADD LIB32 /nologo /out:".\Release\dumb.lib" 

+

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir ".\Debug"

+# PROP BASE Intermediate_Dir ".\Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir ".\Debug"

+# PROP Intermediate_Dir ".\Debug"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /MDd /I "../../include" /ZI /W3 /Od /D "_DEBUG" /D "WIN32" /D "_LIB" /D "DUMB_DECLARE_DEPRECATED" /D "DEBUGMODE=1" /D "_MBCS" /Fp".\Debug/dumb.pch" /Fo".\Debug/" /Fd".\Debug/" /GZ /c /GX 

+# ADD CPP /nologo /MDd /I "../../include" /ZI /W3 /Od /D "_DEBUG" /D "WIN32" /D "_LIB" /D "DUMB_DECLARE_DEPRECATED" /D "DEBUGMODE=1" /D "_MBCS" /Fp".\Debug/dumb.pch" /Fo".\Debug/" /Fd".\Debug/" /GZ /c /GX 

+# ADD BASE MTL /nologo /win32 

+# ADD MTL /nologo /win32 

+# ADD BASE RSC /l 1033 /d "_DEBUG" 

+# ADD RSC /l 1033 /d "_DEBUG" 

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo 

+# ADD BSC32 /nologo 

+LIB32=link.exe -lib

+# ADD BASE LIB32 /nologo /out:"Debug\dumbd.lib" 

+# ADD LIB32 /nologo /out:"Debug\dumbd.lib" 

+

+!ENDIF

+

+# Begin Target

+

+# Name "dumb - Win32 Release"

+# Name "dumb - Win32 Debug"

+# Begin Group "src"

+

+# PROP Default_Filter ""

+# Begin Group "core"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\src\core\atexit.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\duhlen.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\duhtag.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\dumbfile.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\loadduh.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\makeduh.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\rawsig.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\readduh.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\register.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\rendduh.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\rendsig.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\unload.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# End Group

+# Begin Group "helpers"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\src\helpers\barray.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\clickrem.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\memfile.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\resample.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\sampbuf.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\silence.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\stdfile.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# End Group

+# Begin Group "it"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\src\it\itload.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\itmisc.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\itorder.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\itread.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\itrender.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\itunload.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\load669.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\loadmod.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\loadmtm.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\loadoldpsm.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\loadpsm.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\loads3m.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\loadxm.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\ptmeffect.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\read669.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\readmod.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\readmtm.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\readoldpsm.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\readpsm.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\readptm.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\reads3m.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\readxm.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\xmeffect.c

+

+!IF  "$(CFG)" == "dumb - Win32 Release"

+

+# ADD CPP /nologo /O2 /GX 

+!ELSEIF  "$(CFG)" == "dumb - Win32 Debug"

+

+# ADD CPP /nologo /Od /GZ /GX 

+!ENDIF

+

+# End Source File

+# End Group

+# End Group

+# Begin Group "include"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\include\dumb.h

+# End Source File

+# Begin Group "internal"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\include\internal\dumb.h

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\include\internal\it.h

+# End Source File

+# End Group

+# End Group

+# End Target

+# End Project

+

diff --git a/plugins/dumb/dumb-kode54/vc6/dumb/dumb.vcproj b/plugins/dumb/dumb-kode54/vc6/dumb/dumb.vcproj
new file mode 100644
index 00000000..234bffe4
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumb/dumb.vcproj
@@ -0,0 +1,1970 @@
+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+	ProjectType="Visual C++"

+	Version="9.00"

+	Name="dumb"

+	ProjectGUID="{612D360C-A51B-4B34-8F49-33F42A2957F5}"

+	RootNamespace="dumb"

+	SccProjectName="&quot;$/foobar2000/plugins.root/plugins&quot;, CEAAAAAA"

+	SccLocalPath="..\..\..\.."

+	SccProvider="MSSCCI:Microsoft Visual SourceSafe"

+	TargetFrameworkVersion="131072"

+	>

+	<Platforms>

+		<Platform

+			Name="Win32"

+		/>

+	</Platforms>

+	<ToolFiles>

+	</ToolFiles>

+	<Configurations>

+		<Configuration

+			Name="Release|Win32"

+			OutputDirectory="$(ConfigurationName)"

+			IntermediateDirectory="$(ConfigurationName)"

+			ConfigurationType="4"

+			InheritedPropertySheets="..\..\..\..\..\Program Files\Microsoft Visual Studio 8\VC\VCProjectDefaults\UpgradeFromVC71.vsprops"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="false"

+			CharacterSet="2"

+			>

+			<Tool

+				Name="VCPreBuildEventTool"

+			/>

+			<Tool

+				Name="VCCustomBuildTool"

+			/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"

+			/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"

+			/>

+			<Tool

+				Name="VCMIDLTool"

+			/>

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="2"

+				InlineFunctionExpansion="2"

+				WholeProgramOptimization="true"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="NDEBUG;WIN32;_LIB;DUMB_DECLARE_DEPRECATED"

+				StringPooling="true"

+				RuntimeLibrary="2"

+				EnableFunctionLevelLinking="true"

+				PrecompiledHeaderFile="$(IntDir)\$(ProjectName).pch"

+				AssemblerListingLocation="$(IntDir)\"

+				ObjectFile="$(IntDir)\"

+				ProgramDataBaseFileName="$(IntDir)\"

+				WarningLevel="3"

+				SuppressStartupBanner="true"

+				CompileAs="0"

+			/>

+			<Tool

+				Name="VCManagedResourceCompilerTool"

+			/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="NDEBUG"

+				Culture="1033"

+			/>

+			<Tool

+				Name="VCPreLinkEventTool"

+			/>

+			<Tool

+				Name="VCLibrarianTool"

+				OutputFile="$(OutDir)\$(ProjectName).lib"

+				SuppressStartupBanner="true"

+			/>

+			<Tool

+				Name="VCALinkTool"

+			/>

+			<Tool

+				Name="VCXDCMakeTool"

+			/>

+			<Tool

+				Name="VCBscMakeTool"

+			/>

+			<Tool

+				Name="VCFxCopTool"

+			/>

+			<Tool

+				Name="VCPostBuildEventTool"

+			/>

+		</Configuration>

+		<Configuration

+			Name="Debug|Win32"

+			OutputDirectory="$(ConfigurationName)"

+			IntermediateDirectory="$(ConfigurationName)"

+			ConfigurationType="4"

+			InheritedPropertySheets="..\..\..\..\..\Program Files\Microsoft Visual Studio 8\VC\VCProjectDefaults\UpgradeFromVC71.vsprops"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="false"

+			CharacterSet="2"

+			>

+			<Tool

+				Name="VCPreBuildEventTool"

+			/>

+			<Tool

+				Name="VCCustomBuildTool"

+			/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"

+			/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"

+			/>

+			<Tool

+				Name="VCMIDLTool"

+			/>

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="_DEBUG;WIN32;_LIB;DUMB_DECLARE_DEPRECATED;DEBUGMODE=1"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="1"

+				PrecompiledHeaderFile="$(IntDir)\$(ProjectName).pch"

+				AssemblerListingLocation="$(IntDir)\"

+				ObjectFile="$(IntDir)\"

+				ProgramDataBaseFileName="$(IntDir)\"

+				WarningLevel="3"

+				SuppressStartupBanner="true"

+				DebugInformationFormat="4"

+				CompileAs="0"

+			/>

+			<Tool

+				Name="VCManagedResourceCompilerTool"

+			/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="_DEBUG"

+				Culture="1033"

+			/>

+			<Tool

+				Name="VCPreLinkEventTool"

+			/>

+			<Tool

+				Name="VCLibrarianTool"

+				OutputFile="$(OutDir)\$(ProjectName).lib"

+				SuppressStartupBanner="true"

+			/>

+			<Tool

+				Name="VCALinkTool"

+			/>

+			<Tool

+				Name="VCXDCMakeTool"

+			/>

+			<Tool

+				Name="VCBscMakeTool"

+			/>

+			<Tool

+				Name="VCFxCopTool"

+			/>

+			<Tool

+				Name="VCPostBuildEventTool"

+			/>

+		</Configuration>

+		<Configuration

+			Name="Release staticlink|Win32"

+			OutputDirectory="$(ConfigurationName)"

+			IntermediateDirectory="$(ConfigurationName)"

+			ConfigurationType="4"

+			InheritedPropertySheets="..\..\..\..\..\Program Files\Microsoft Visual Studio 8\VC\VCProjectDefaults\UpgradeFromVC71.vsprops"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="false"

+			CharacterSet="2"

+			WholeProgramOptimization="1"

+			>

+			<Tool

+				Name="VCPreBuildEventTool"

+			/>

+			<Tool

+				Name="VCCustomBuildTool"

+			/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"

+			/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"

+			/>

+			<Tool

+				Name="VCMIDLTool"

+			/>

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="2"

+				InlineFunctionExpansion="2"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="NDEBUG;WIN32;_LIB;DUMB_DECLARE_DEPRECATED"

+				StringPooling="true"

+				RuntimeLibrary="0"

+				EnableFunctionLevelLinking="true"

+				PrecompiledHeaderFile="$(IntDir)\$(ProjectName).pch"

+				AssemblerListingLocation="$(IntDir)\"

+				ObjectFile="$(IntDir)\"

+				ProgramDataBaseFileName="$(IntDir)\"

+				WarningLevel="3"

+				SuppressStartupBanner="true"

+				DebugInformationFormat="3"

+				CompileAs="0"

+			/>

+			<Tool

+				Name="VCManagedResourceCompilerTool"

+			/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="NDEBUG"

+				Culture="1033"

+			/>

+			<Tool

+				Name="VCPreLinkEventTool"

+			/>

+			<Tool

+				Name="VCLibrarianTool"

+				OutputFile="$(OutDir)\$(ProjectName).lib"

+				SuppressStartupBanner="true"

+			/>

+			<Tool

+				Name="VCALinkTool"

+			/>

+			<Tool

+				Name="VCXDCMakeTool"

+			/>

+			<Tool

+				Name="VCBscMakeTool"

+			/>

+			<Tool

+				Name="VCFxCopTool"

+			/>

+			<Tool

+				Name="VCPostBuildEventTool"

+			/>

+		</Configuration>

+	</Configurations>

+	<References>

+	</References>

+	<Files>

+		<Filter

+			Name="src"

+			>

+			<Filter

+				Name="core"

+				>

+				<File

+					RelativePath="..\..\src\core\atexit.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\duhlen.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\duhtag.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\dumbfile.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\loadduh.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\makeduh.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\rawsig.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\readduh.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\register.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\rendduh.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\rendsig.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\unload.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+			</Filter>

+			<Filter

+				Name="helpers"

+				>

+				<File

+					RelativePath="..\..\src\helpers\barray.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\clickrem.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\memfile.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\resamp2.inc"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						ExcludedFromBuild="true"

+						>

+						<Tool

+							Name="VCCustomBuildTool"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						ExcludedFromBuild="true"

+						>

+						<Tool

+							Name="VCCustomBuildTool"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						ExcludedFromBuild="true"

+						>

+						<Tool

+							Name="VCCustomBuildTool"

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\resamp3.inc"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						ExcludedFromBuild="true"

+						>

+						<Tool

+							Name="VCCustomBuildTool"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						ExcludedFromBuild="true"

+						>

+						<Tool

+							Name="VCCustomBuildTool"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						ExcludedFromBuild="true"

+						>

+						<Tool

+							Name="VCCustomBuildTool"

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\resample.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\resample.inc"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						ExcludedFromBuild="true"

+						>

+						<Tool

+							Name="VCCustomBuildTool"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						ExcludedFromBuild="true"

+						>

+						<Tool

+							Name="VCCustomBuildTool"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						ExcludedFromBuild="true"

+						>

+						<Tool

+							Name="VCCustomBuildTool"

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\riff.c"

+					>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\sampbuf.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\silence.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\stdfile.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+			</Filter>

+			<Filter

+				Name="it"

+				>

+				<File

+					RelativePath="..\..\src\it\itmisc.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\itorder.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\itrender.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\itunload.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\ptmeffect.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\xmeffect.c"

+					>

+					<FileConfiguration

+						Name="Release|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Debug|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"

+						/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release staticlink|Win32"

+						>

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+						/>

+					</FileConfiguration>

+				</File>

+				<Filter

+					Name="loaders"

+					>

+					<File

+						RelativePath="..\..\src\it\itload.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\itload2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\load669.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\load6692.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadasy.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadasy2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadmod.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadmod2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadmtm.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadmtm2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadoldpsm.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadoldpsm2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadpsm.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadpsm2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadptm.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadptm2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadriff.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadriff2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loads3m.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loads3m2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadstm.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadstm2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadxm.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\loadxm2.c"

+						>

+					</File>

+				</Filter>

+				<Filter

+					Name="readers"

+					>

+					<File

+						RelativePath="..\..\src\it\itread.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\itread2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\read669.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\read6692.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readam.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readasy.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readdsmf.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readmod.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readmod2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readmtm.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readoldpsm.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readpsm.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readptm.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readriff.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\reads3m.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\reads3m2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readstm.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readstm2.c"

+						>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readxm.c"

+						>

+						<FileConfiguration

+							Name="Release|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Debug|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="0"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+								BasicRuntimeChecks="3"

+							/>

+						</FileConfiguration>

+						<FileConfiguration

+							Name="Release staticlink|Win32"

+							>

+							<Tool

+								Name="VCCLCompilerTool"

+								Optimization="2"

+								AdditionalIncludeDirectories=""

+								PreprocessorDefinitions=""

+							/>

+						</FileConfiguration>

+					</File>

+					<File

+						RelativePath="..\..\src\it\readxm2.c"

+						>

+					</File>

+				</Filter>

+			</Filter>

+		</Filter>

+		<Filter

+			Name="include"

+			>

+			<File

+				RelativePath="..\..\include\dumb.h"

+				>

+			</File>

+			<Filter

+				Name="internal"

+				>

+				<File

+					RelativePath="..\..\include\internal\barray.h"

+					>

+				</File>

+				<File

+					RelativePath="..\..\include\internal\dumb.h"

+					>

+				</File>

+				<File

+					RelativePath="..\..\include\internal\it.h"

+					>

+				</File>

+				<File

+					RelativePath="..\..\include\internal\riff.h"

+					>

+				</File>

+			</Filter>

+		</Filter>

+	</Files>

+	<Globals>

+	</Globals>

+</VisualStudioProject>

diff --git a/plugins/dumb/dumb-kode54/vc6/dumb2wav/dumb2wav.dsp b/plugins/dumb/dumb-kode54/vc6/dumb2wav/dumb2wav.dsp
new file mode 100644
index 00000000..b5433a89
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumb2wav/dumb2wav.dsp
@@ -0,0 +1,90 @@
+# Microsoft Developer Studio Project File - Name="dumb2wav" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Console Application" 0x0103

+

+CFG=dumb2wav - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "dumb2wav.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "dumb2wav.mak" CFG="dumb2wav - Win32 Debug"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "dumb2wav - Win32 Release" (based on "Win32 (x86) Console Application")

+!MESSAGE "dumb2wav - Win32 Debug" (based on "Win32 (x86) Console Application")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "dumb2wav - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "NDEBUG"

+# ADD RSC /l 0x409 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+

+!ELSEIF  "$(CFG)" == "dumb2wav - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "Debug"

+# PROP BASE Intermediate_Dir "Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir "Debug"

+# PROP Intermediate_Dir "Debug"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c

+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../../include" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+

+!ENDIF 

+

+# Begin Target

+

+# Name "dumb2wav - Win32 Release"

+# Name "dumb2wav - Win32 Debug"

+# Begin Source File

+

+SOURCE=..\..\examples\dumb2wav.c

+# End Source File

+# End Target

+# End Project

diff --git a/plugins/dumb/dumb-kode54/vc6/dumb2wav/dumb2wav.vcproj b/plugins/dumb/dumb-kode54/vc6/dumb2wav/dumb2wav.vcproj
new file mode 100644
index 00000000..b09041ee
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumb2wav/dumb2wav.vcproj
@@ -0,0 +1,158 @@
+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+	ProjectType="Visual C++"

+	Version="7.10"

+	Name="dumb2wav"

+	SccProjectName=""

+	SccLocalPath="">

+	<Platforms>

+		<Platform

+			Name="Win32"/>

+	</Platforms>

+	<Configurations>

+		<Configuration

+			Name="Debug|Win32"

+			OutputDirectory=".\Debug"

+			IntermediateDirectory=".\Debug"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="3"

+				PrecompiledHeaderFile=".\Debug/dumb2wav.pch"

+				AssemblerListingLocation=".\Debug/"

+				ObjectFile=".\Debug/"

+				ProgramDataBaseFileName=".\Debug/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				DebugInformationFormat="4"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				OutputFile=".\Debug/dumb2wav.exe"

+				LinkIncremental="1"

+				SuppressStartupBanner="TRUE"

+				GenerateDebugInformation="TRUE"

+				ProgramDatabaseFile=".\Debug/dumb2wav.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Debug/dumb2wav.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="_DEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+		<Configuration

+			Name="Release|Win32"

+			OutputDirectory=".\Release"

+			IntermediateDirectory=".\Release"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="2"

+				InlineFunctionExpansion="1"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"

+				StringPooling="TRUE"

+				RuntimeLibrary="2"

+				EnableFunctionLevelLinking="TRUE"

+				PrecompiledHeaderFile=".\Release/dumb2wav.pch"

+				AssemblerListingLocation=".\Release/"

+				ObjectFile=".\Release/"

+				ProgramDataBaseFileName=".\Release/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				OutputFile=".\Release/dumb2wav.exe"

+				LinkIncremental="1"

+				SuppressStartupBanner="TRUE"

+				ProgramDatabaseFile=".\Release/dumb2wav.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Release/dumb2wav.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="NDEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+	</Configurations>

+	<References>

+	</References>

+	<Files>

+		<File

+			RelativePath="..\..\examples\dumb2wav.c">

+			<FileConfiguration

+				Name="Debug|Win32">

+				<Tool

+					Name="VCCLCompilerTool"

+					Optimization="0"

+					AdditionalIncludeDirectories=""

+					PreprocessorDefinitions=""

+					BasicRuntimeChecks="3"/>

+			</FileConfiguration>

+			<FileConfiguration

+				Name="Release|Win32">

+				<Tool

+					Name="VCCLCompilerTool"

+					Optimization="2"

+					AdditionalIncludeDirectories=""

+					PreprocessorDefinitions=""/>

+			</FileConfiguration>

+		</File>

+	</Files>

+	<Globals>

+	</Globals>

+</VisualStudioProject>

diff --git a/plugins/dumb/dumb-kode54/vc6/dumb_static/dumb_static.dsp b/plugins/dumb/dumb-kode54/vc6/dumb_static/dumb_static.dsp
new file mode 100644
index 00000000..ee923d9b
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumb_static/dumb_static.dsp
@@ -0,0 +1,254 @@
+# Microsoft Developer Studio Project File - Name="dumb_static" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Static Library" 0x0104

+

+CFG=dumb_static - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "dumb_static.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "dumb_static.mak" CFG="dumb_static - Win32 Debug"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "dumb_static - Win32 Release" (based on "Win32 (x86) Static Library")

+!MESSAGE "dumb_static - Win32 Debug" (based on "Win32 (x86) Static Library")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "dumb_static - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c

+# ADD CPP /nologo /MT /W3 /O2 /I "../../include" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "DUMB_DECLARE_DEPRECATED" /FD /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "NDEBUG"

+# ADD RSC /l 0x409 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LIB32=link.exe -lib

+# ADD BASE LIB32 /nologo

+# ADD LIB32 /nologo

+

+!ELSEIF  "$(CFG)" == "dumb_static - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "Debug"

+# PROP BASE Intermediate_Dir "Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir "Debug"

+# PROP Intermediate_Dir "Debug"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c

+# ADD CPP /nologo /MTd /W3 /Gm /ZI /Od /I "../../include" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "_LIB" /D "DUMB_DECLARE_DEPRECATED" /FD /GZ /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LIB32=link.exe -lib

+# ADD BASE LIB32 /nologo

+# ADD LIB32 /nologo /out:"Debug\dumbd_static.lib"

+

+!ENDIF 

+

+# Begin Target

+

+# Name "dumb_static - Win32 Release"

+# Name "dumb_static - Win32 Debug"

+# Begin Group "src"

+

+# PROP Default_Filter ""

+# Begin Group "core"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\src\core\atexit.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\duhlen.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\duhtag.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\dumbfile.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\loadduh.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\makeduh.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\rawsig.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\readduh.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\register.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\rendduh.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\rendsig.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\core\unload.c

+# End Source File

+# End Group

+# Begin Group "helpers"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\src\helpers\barray.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\clickrem.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\memfile.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\resample.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\sampbuf.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\silence.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\helpers\stdfile.c

+# End Source File

+# End Group

+# Begin Group "it"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\src\it\itload.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\itmisc.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\itorder.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\itread.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\itrender.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\itunload.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\loadmod.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\loads3m.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\loadxm.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\readmod.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\reads3m.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\readxm.c

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\src\it\xmeffect.c

+# End Source File

+# End Group

+# End Group

+# Begin Group "include"

+

+# PROP Default_Filter ""

+# Begin Group "internal"

+

+# PROP Default_Filter ""

+# Begin Source File

+

+SOURCE=..\..\include\internal\barray.h

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\include\internal\dumb.h

+# End Source File

+# Begin Source File

+

+SOURCE=..\..\include\internal\it.h

+# End Source File

+# End Group

+# Begin Source File

+

+SOURCE=..\..\include\dumb.h

+# End Source File

+# End Group

+# End Target

+# End Project

diff --git a/plugins/dumb/dumb-kode54/vc6/dumb_static/dumb_static.vcproj b/plugins/dumb/dumb-kode54/vc6/dumb_static/dumb_static.vcproj
new file mode 100644
index 00000000..0eb912ed
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumb_static/dumb_static.vcproj
@@ -0,0 +1,774 @@
+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+	ProjectType="Visual C++"

+	Version="7.10"

+	Name="dumb_static"

+	SccProjectName=""

+	SccLocalPath="">

+	<Platforms>

+		<Platform

+			Name="Win32"/>

+	</Platforms>

+	<Configurations>

+		<Configuration

+			Name="Debug|Win32"

+			OutputDirectory=".\Debug"

+			IntermediateDirectory=".\Debug"

+			ConfigurationType="4"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="_DEBUG;WIN32;_LIB;DUMB_DECLARE_DEPRECATED"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="1"

+				PrecompiledHeaderFile=".\Debug/dumb_static.pch"

+				AssemblerListingLocation=".\Debug/"

+				ObjectFile=".\Debug/"

+				ProgramDataBaseFileName=".\Debug/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				DebugInformationFormat="4"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLibrarianTool"

+				OutputFile="Debug\dumbd_static.lib"

+				SuppressStartupBanner="TRUE"/>

+			<Tool

+				Name="VCMIDLTool"/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="_DEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+		<Configuration

+			Name="Release|Win32"

+			OutputDirectory=".\Release"

+			IntermediateDirectory=".\Release"

+			ConfigurationType="4"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="2"

+				InlineFunctionExpansion="1"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="NDEBUG;WIN32;_LIB;DUMB_DECLARE_DEPRECATED"

+				StringPooling="TRUE"

+				RuntimeLibrary="0"

+				EnableFunctionLevelLinking="TRUE"

+				PrecompiledHeaderFile=".\Release/dumb_static.pch"

+				AssemblerListingLocation=".\Release/"

+				ObjectFile=".\Release/"

+				ProgramDataBaseFileName=".\Release/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLibrarianTool"

+				OutputFile=".\Release\dumb_static.lib"

+				SuppressStartupBanner="TRUE"/>

+			<Tool

+				Name="VCMIDLTool"/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="NDEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+	</Configurations>

+	<References>

+	</References>

+	<Files>

+		<Filter

+			Name="src"

+			Filter="">

+			<Filter

+				Name="core"

+				Filter="">

+				<File

+					RelativePath="..\..\src\core\atexit.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\duhlen.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\duhtag.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\dumbfile.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\loadduh.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\makeduh.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\rawsig.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\readduh.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\register.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\rendduh.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\rendsig.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\core\unload.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+			</Filter>

+			<Filter

+				Name="helpers"

+				Filter="">

+				<File

+					RelativePath="..\..\src\helpers\clickrem.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\memfile.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\resample.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\sampbuf.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\silence.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\helpers\stdfile.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+			</Filter>

+			<Filter

+				Name="it"

+				Filter="">

+				<File

+					RelativePath="..\..\src\it\itload.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\itmisc.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\itorder.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\itread.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\itrender.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\itunload.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\loadmod.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\loads3m.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\loadxm.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\readmod.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\reads3m.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\readxm.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+				<File

+					RelativePath="..\..\src\it\xmeffect.c">

+					<FileConfiguration

+						Name="Debug|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="0"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""

+							BasicRuntimeChecks="3"/>

+					</FileConfiguration>

+					<FileConfiguration

+						Name="Release|Win32">

+						<Tool

+							Name="VCCLCompilerTool"

+							Optimization="2"

+							AdditionalIncludeDirectories=""

+							PreprocessorDefinitions=""/>

+					</FileConfiguration>

+				</File>

+			</Filter>

+		</Filter>

+		<Filter

+			Name="include"

+			Filter="">

+			<File

+				RelativePath="..\..\include\dumb.h">

+			</File>

+			<Filter

+				Name="internal"

+				Filter="">

+				<File

+					RelativePath="..\..\include\internal\dumb.h">

+				</File>

+				<File

+					RelativePath="..\..\include\internal\it.h">

+				</File>

+			</Filter>

+		</Filter>

+	</Files>

+	<Globals>

+	</Globals>

+</VisualStudioProject>

diff --git a/plugins/dumb/dumb-kode54/vc6/dumbout/dumbout.dsp b/plugins/dumb/dumb-kode54/vc6/dumbout/dumbout.dsp
new file mode 100644
index 00000000..01f6ed2f
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumbout/dumbout.dsp
@@ -0,0 +1,90 @@
+# Microsoft Developer Studio Project File - Name="dumbout" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Console Application" 0x0103

+

+CFG=dumbout - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "dumbout.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "dumbout.mak" CFG="dumbout - Win32 Debug"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "dumbout - Win32 Release" (based on "Win32 (x86) Console Application")

+!MESSAGE "dumbout - Win32 Debug" (based on "Win32 (x86) Console Application")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "dumbout - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../include" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "NDEBUG"

+# ADD RSC /l 0x409 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+

+!ELSEIF  "$(CFG)" == "dumbout - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "Debug"

+# PROP BASE Intermediate_Dir "Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir "Debug"

+# PROP Intermediate_Dir "Debug"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ  /c

+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../../include" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FD /GZ  /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+

+!ENDIF 

+

+# Begin Target

+

+# Name "dumbout - Win32 Release"

+# Name "dumbout - Win32 Debug"

+# Begin Source File

+

+SOURCE=..\..\examples\dumbout.c

+# End Source File

+# End Target

+# End Project

diff --git a/plugins/dumb/dumb-kode54/vc6/dumbout/dumbout.vcproj b/plugins/dumb/dumb-kode54/vc6/dumbout/dumbout.vcproj
new file mode 100644
index 00000000..bde96316
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumbout/dumbout.vcproj
@@ -0,0 +1,161 @@
+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+	ProjectType="Visual C++"

+	Version="7.10"

+	Name="dumbout"

+	SccProjectName=""

+	SccLocalPath="">

+	<Platforms>

+		<Platform

+			Name="Win32"/>

+	</Platforms>

+	<Configurations>

+		<Configuration

+			Name="Debug|Win32"

+			OutputDirectory=".\Debug"

+			IntermediateDirectory=".\Debug"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="3"

+				PrecompiledHeaderFile=".\Debug/dumbout.pch"

+				AssemblerListingLocation=".\Debug/"

+				ObjectFile=".\Debug/"

+				ProgramDataBaseFileName=".\Debug/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				DebugInformationFormat="4"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				OutputFile=".\Debug/dumbout.exe"

+				LinkIncremental="1"

+				SuppressStartupBanner="TRUE"

+				GenerateDebugInformation="TRUE"

+				ProgramDatabaseFile=".\Debug/dumbout.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Debug/dumbout.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="_DEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+		<Configuration

+			Name="Release|Win32"

+			OutputDirectory=".\Release"

+			IntermediateDirectory=".\Release"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="1"

+				InlineFunctionExpansion="1"

+				OmitFramePointers="TRUE"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"

+				StringPooling="TRUE"

+				ExceptionHandling="FALSE"

+				RuntimeLibrary="2"

+				BufferSecurityCheck="FALSE"

+				EnableFunctionLevelLinking="TRUE"

+				PrecompiledHeaderFile=".\Release/dumbout.pch"

+				AssemblerListingLocation=".\Release/"

+				ObjectFile=".\Release/"

+				ProgramDataBaseFileName=".\Release/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				OutputFile=".\Release/dumbout.exe"

+				LinkIncremental="1"

+				SuppressStartupBanner="TRUE"

+				ProgramDatabaseFile=".\Release/dumbout.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Release/dumbout.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="NDEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+	</Configurations>

+	<References>

+	</References>

+	<Files>

+		<File

+			RelativePath="..\..\examples\dumbout.c">

+			<FileConfiguration

+				Name="Debug|Win32">

+				<Tool

+					Name="VCCLCompilerTool"

+					Optimization="0"

+					AdditionalIncludeDirectories=""

+					PreprocessorDefinitions=""

+					BasicRuntimeChecks="3"/>

+			</FileConfiguration>

+			<FileConfiguration

+				Name="Release|Win32">

+				<Tool

+					Name="VCCLCompilerTool"

+					Optimization="2"

+					AdditionalIncludeDirectories=""

+					PreprocessorDefinitions=""/>

+			</FileConfiguration>

+		</File>

+	</Files>

+	<Globals>

+	</Globals>

+</VisualStudioProject>

diff --git a/plugins/dumb/dumb-kode54/vc6/dumbplay/dumbplay.dsp b/plugins/dumb/dumb-kode54/vc6/dumbplay/dumbplay.dsp
new file mode 100644
index 00000000..88d53b0d
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumbplay/dumbplay.dsp
@@ -0,0 +1,90 @@
+# Microsoft Developer Studio Project File - Name="dumbplay" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Console Application" 0x0103

+

+CFG=dumbplay - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "dumbplay.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "dumbplay.mak" CFG="dumbplay - Win32 Debug"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "dumbplay - Win32 Release" (based on "Win32 (x86) Console Application")

+!MESSAGE "dumbplay - Win32 Debug" (based on "Win32 (x86) Console Application")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "dumbplay - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../include" /D "NDEBUG" /D "ALLEGRO_NO_MAGIC_MAIN" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /FD /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "NDEBUG"

+# ADD RSC /l 0x409 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+# ADD LINK32 alleg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+

+!ELSEIF  "$(CFG)" == "dumbplay - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "Debug"

+# PROP BASE Intermediate_Dir "Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir "Debug"

+# PROP Intermediate_Dir "Debug"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ  /c

+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../../include" /D "_DEBUG" /D "ALLEGRO_NO_MAGIC_MAIN" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /FD /GZ  /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 alleg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+

+!ENDIF 

+

+# Begin Target

+

+# Name "dumbplay - Win32 Release"

+# Name "dumbplay - Win32 Debug"

+# Begin Source File

+

+SOURCE=..\..\examples\dumbplay.c

+# End Source File

+# End Target

+# End Project

diff --git a/plugins/dumb/dumb-kode54/vc6/dumbplay/dumbplay.vcproj b/plugins/dumb/dumb-kode54/vc6/dumbplay/dumbplay.vcproj
new file mode 100644
index 00000000..429a0a6b
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/dumbplay/dumbplay.vcproj
@@ -0,0 +1,160 @@
+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+	ProjectType="Visual C++"

+	Version="7.10"

+	Name="dumbplay"

+	SccProjectName=""

+	SccLocalPath="">

+	<Platforms>

+		<Platform

+			Name="Win32"/>

+	</Platforms>

+	<Configurations>

+		<Configuration

+			Name="Debug|Win32"

+			OutputDirectory=".\Debug"

+			IntermediateDirectory=".\Debug"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="_DEBUG;ALLEGRO_NO_MAGIC_MAIN;WIN32;_CONSOLE"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="3"

+				PrecompiledHeaderFile=".\Debug/dumbplay.pch"

+				AssemblerListingLocation=".\Debug/"

+				ObjectFile=".\Debug/"

+				ProgramDataBaseFileName=".\Debug/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				DebugInformationFormat="4"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				AdditionalDependencies="alleg.lib odbc32.lib odbccp32.lib"

+				OutputFile=".\Debug/dumbplay.exe"

+				LinkIncremental="1"

+				SuppressStartupBanner="TRUE"

+				GenerateDebugInformation="TRUE"

+				ProgramDatabaseFile=".\Debug/dumbplay.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Debug/dumbplay.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="_DEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+		<Configuration

+			Name="Release|Win32"

+			OutputDirectory=".\Release"

+			IntermediateDirectory=".\Release"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="2"

+				InlineFunctionExpansion="1"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="NDEBUG;ALLEGRO_NO_MAGIC_MAIN;WIN32;_CONSOLE"

+				StringPooling="TRUE"

+				RuntimeLibrary="2"

+				EnableFunctionLevelLinking="TRUE"

+				PrecompiledHeaderFile=".\Release/dumbplay.pch"

+				AssemblerListingLocation=".\Release/"

+				ObjectFile=".\Release/"

+				ProgramDataBaseFileName=".\Release/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				AdditionalDependencies="alleg.lib odbc32.lib odbccp32.lib"

+				OutputFile=".\Release/dumbplay.exe"

+				LinkIncremental="1"

+				SuppressStartupBanner="TRUE"

+				ProgramDatabaseFile=".\Release/dumbplay.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Release/dumbplay.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="NDEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+	</Configurations>

+	<References>

+	</References>

+	<Files>

+		<File

+			RelativePath="..\..\examples\dumbplay.c">

+			<FileConfiguration

+				Name="Debug|Win32">

+				<Tool

+					Name="VCCLCompilerTool"

+					Optimization="0"

+					AdditionalIncludeDirectories=""

+					PreprocessorDefinitions=""

+					BasicRuntimeChecks="3"/>

+			</FileConfiguration>

+			<FileConfiguration

+				Name="Release|Win32">

+				<Tool

+					Name="VCCLCompilerTool"

+					Optimization="2"

+					AdditionalIncludeDirectories=""

+					PreprocessorDefinitions=""/>

+			</FileConfiguration>

+		</File>

+	</Files>

+	<Globals>

+	</Globals>

+</VisualStudioProject>

diff --git a/plugins/dumb/dumb-kode54/vc6/playduh/playduh.dsp b/plugins/dumb/dumb-kode54/vc6/playduh/playduh.dsp
new file mode 100644
index 00000000..e9ccd77d
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/playduh/playduh.dsp
@@ -0,0 +1,91 @@
+# Microsoft Developer Studio Project File - Name="playduh" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Console Application" 0x0103

+

+CFG=playduh - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "playduh.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "playduh.mak" CFG="playduh - Win32 Debug"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "playduh - Win32 Release" (based on "Win32 (x86) Console Application")

+!MESSAGE "playduh - Win32 Debug" (based on "Win32 (x86) Console Application")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "playduh - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir "Release"

+# PROP Intermediate_Dir "Release"

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c

+# ADD CPP /nologo /MD /W3 /GX /O2 /I "../../include" /D "NDEBUG" /D "ALLEGRO_NO_MAGIC_MAIN" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /FD /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "NDEBUG"

+# ADD RSC /l 0x409 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+# ADD LINK32 alleg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386

+

+!ELSEIF  "$(CFG)" == "playduh - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "Debug"

+# PROP BASE Intermediate_Dir "Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir "Debug"

+# PROP Intermediate_Dir "Debug"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ  /c

+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../../include" /D "_DEBUG" /D "ALLEGRO_NO_MAGIC_MAIN" /D "WIN32" /D "_CONSOLE" /D "_MBCS" /FD /GZ  /c

+# SUBTRACT CPP /YX

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 alleg.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept

+

+!ENDIF 

+

+# Begin Target

+

+# Name "playduh - Win32 Release"

+# Name "playduh - Win32 Debug"

+# Begin Source File

+

+SOURCE=..\..\examples\playduh.c

+# End Source File

+# End Target

+# End Project

diff --git a/plugins/dumb/dumb-kode54/vc6/playduh/playduh.vcproj b/plugins/dumb/dumb-kode54/vc6/playduh/playduh.vcproj
new file mode 100644
index 00000000..5b6635f8
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/vc6/playduh/playduh.vcproj
@@ -0,0 +1,160 @@
+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+	ProjectType="Visual C++"

+	Version="7.10"

+	Name="playduh"

+	SccProjectName=""

+	SccLocalPath="">

+	<Platforms>

+		<Platform

+			Name="Win32"/>

+	</Platforms>

+	<Configurations>

+		<Configuration

+			Name="Release|Win32"

+			OutputDirectory=".\Release"

+			IntermediateDirectory=".\Release"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="2"

+				InlineFunctionExpansion="1"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="NDEBUG;ALLEGRO_NO_MAGIC_MAIN;WIN32;_CONSOLE"

+				StringPooling="TRUE"

+				RuntimeLibrary="2"

+				EnableFunctionLevelLinking="TRUE"

+				PrecompiledHeaderFile=".\Release/playduh.pch"

+				AssemblerListingLocation=".\Release/"

+				ObjectFile=".\Release/"

+				ProgramDataBaseFileName=".\Release/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				AdditionalDependencies="alleg.lib odbc32.lib odbccp32.lib"

+				OutputFile=".\Release/playduh.exe"

+				LinkIncremental="1"

+				SuppressStartupBanner="TRUE"

+				ProgramDatabaseFile=".\Release/playduh.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Release/playduh.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="NDEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+		<Configuration

+			Name="Debug|Win32"

+			OutputDirectory=".\Debug"

+			IntermediateDirectory=".\Debug"

+			ConfigurationType="1"

+			UseOfMFC="0"

+			ATLMinimizesCRunTimeLibraryUsage="FALSE"

+			CharacterSet="2">

+			<Tool

+				Name="VCCLCompilerTool"

+				Optimization="0"

+				AdditionalIncludeDirectories="../../include"

+				PreprocessorDefinitions="_DEBUG;ALLEGRO_NO_MAGIC_MAIN;WIN32;_CONSOLE"

+				BasicRuntimeChecks="3"

+				RuntimeLibrary="3"

+				PrecompiledHeaderFile=".\Debug/playduh.pch"

+				AssemblerListingLocation=".\Debug/"

+				ObjectFile=".\Debug/"

+				ProgramDataBaseFileName=".\Debug/"

+				WarningLevel="3"

+				SuppressStartupBanner="TRUE"

+				DebugInformationFormat="4"

+				CompileAs="0"/>

+			<Tool

+				Name="VCCustomBuildTool"/>

+			<Tool

+				Name="VCLinkerTool"

+				AdditionalDependencies="alleg.lib odbc32.lib odbccp32.lib"

+				OutputFile=".\Debug/playduh.exe"

+				LinkIncremental="1"

+				SuppressStartupBanner="TRUE"

+				GenerateDebugInformation="TRUE"

+				ProgramDatabaseFile=".\Debug/playduh.pdb"

+				SubSystem="1"

+				TargetMachine="1"/>

+			<Tool

+				Name="VCMIDLTool"

+				TypeLibraryName=".\Debug/playduh.tlb"

+				HeaderFileName=""/>

+			<Tool

+				Name="VCPostBuildEventTool"/>

+			<Tool

+				Name="VCPreBuildEventTool"/>

+			<Tool

+				Name="VCPreLinkEventTool"/>

+			<Tool

+				Name="VCResourceCompilerTool"

+				PreprocessorDefinitions="_DEBUG"

+				Culture="1033"/>

+			<Tool

+				Name="VCWebServiceProxyGeneratorTool"/>

+			<Tool

+				Name="VCXMLDataGeneratorTool"/>

+			<Tool

+				Name="VCWebDeploymentTool"/>

+			<Tool

+				Name="VCManagedWrapperGeneratorTool"/>

+			<Tool

+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>

+		</Configuration>

+	</Configurations>

+	<References>

+	</References>

+	<Files>

+		<File

+			RelativePath="..\..\examples\playduh.c">

+			<FileConfiguration

+				Name="Release|Win32">

+				<Tool

+					Name="VCCLCompilerTool"

+					Optimization="2"

+					AdditionalIncludeDirectories=""

+					PreprocessorDefinitions=""/>

+			</FileConfiguration>

+			<FileConfiguration

+				Name="Debug|Win32">

+				<Tool

+					Name="VCCLCompilerTool"

+					Optimization="0"

+					AdditionalIncludeDirectories=""

+					PreprocessorDefinitions=""

+					BasicRuntimeChecks="3"/>

+			</FileConfiguration>

+		</File>

+	</Files>

+	<Globals>

+	</Globals>

+</VisualStudioProject>

diff --git a/plugins/dumb/dumb-kode54/winamp/config.rc b/plugins/dumb/dumb-kode54/winamp/config.rc
new file mode 100644
index 00000000..1c8bf83c
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/winamp/config.rc
@@ -0,0 +1,144 @@
+//Microsoft Developer Studio generated resource script.

+//

+#include "resource.h"

+

+#define APSTUDIO_READONLY_SYMBOLS

+/////////////////////////////////////////////////////////////////////////////

+//

+// Generated from the TEXTINCLUDE 2 resource.

+//

+#include "afxres.h"

+

+/////////////////////////////////////////////////////////////////////////////

+#undef APSTUDIO_READONLY_SYMBOLS

+

+/////////////////////////////////////////////////////////////////////////////

+// English (U.S.) resources

+

+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)

+#ifdef _WIN32

+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US

+#pragma code_page(1252)

+#endif //_WIN32

+

+/////////////////////////////////////////////////////////////////////////////

+//

+// Dialog

+//

+

+IDD_CONFIG DIALOGEX 0, 0, 297, 170

+STYLE DS_MODALFRAME | DS_3DLOOK | WS_CAPTION | WS_SYSMENU

+CAPTION "Duh! Plug-in"

+FONT 8, "MS Sans Serif"

+BEGIN

+    GROUPBOX        "Output Bit Rate",IDC_STATIC,5,10,70,40,WS_TABSTOP

+    CONTROL         "8 bits",IDC_8BPS,"Button",BS_AUTORADIOBUTTON | WS_GROUP |

+                    WS_TABSTOP,15,25,47,8

+    CONTROL         "16 bits",IDC_16BPS,"Button",BS_AUTORADIOBUTTON,15,35,45,

+                    10

+    CONTROL         "Stereo",IDC_STEREO,"Button",BS_AUTOCHECKBOX | BS_CENTER |

+                    WS_TABSTOP,5,55,70,12,WS_EX_DLGMODALFRAME

+    GROUPBOX        "Frequency",IDC_STATIC,5,85,70,60

+    CONTROL         "11025 Hz",IDC_11KHZ,"Button",BS_AUTORADIOBUTTON |

+                    WS_GROUP | WS_TABSTOP,15,95,47,10

+    CONTROL         "22050 Hz",IDC_22KHZ,"Button",BS_AUTORADIOBUTTON,15,105,

+                    47,10

+    CONTROL         "44100 Hz",IDC_44KHZ,"Button",BS_AUTORADIOBUTTON,15,115,

+                    47,10

+    CONTROL         "48000 Hz",IDC_48KHZ,"Button",BS_AUTORADIOBUTTON,15,125,

+                    47,10

+    GROUPBOX        "Resampling",IDC_STATIC,85,10,100,70

+    CONTROL         "Aliasing",IDC_ALIASING,"Button",BS_AUTORADIOBUTTON |

+                    WS_GROUP | WS_TABSTOP,95,20,53,11

+    CONTROL         "Linear",IDC_LINEAR,"Button",BS_AUTORADIOBUTTON,95,31,53,

+                    11

+    CONTROL         "Linear + Low-pass",IDC_LINEAR_LOW_PASS,"Button",

+                    BS_AUTORADIOBUTTON,95,42,70,11

+    CONTROL         "Quadratic",IDC_QUADRATIC,"Button",BS_AUTORADIOBUTTON,95,

+                    52,53,11

+    CONTROL         "Cubic",IDC_CUBIC,"Button",BS_AUTORADIOBUTTON,95,63,53,

+                    11

+    LTEXT           "Fastest",IDC_STATIC,150,22,24,8

+    LTEXT           "Nicest",IDC_STATIC,150,65,21,8

+    GROUPBOX        "Thread Priority",IDC_STATIC,85,85,100,60

+    CONTROL         "Slider1",IDC_THREAD_PRI,"msctls_trackbar32",

+                    TBS_AUTOTICKS | WS_TABSTOP,100,95,70,15

+    LTEXT           "Normal",IDC_STATIC,90,110,23,8

+    LTEXT           "Higher",IDC_STATIC,125,110,22,8

+    LTEXT           "Highest",IDC_STATIC,155,110,25,8

+    LTEXT           "You shouldn't normally change this",IDC_STATIC,95,120,

+                    75,20

+    GROUPBOX        "Buffer Size",IDC_STATIC,195,10,95,70

+    CONTROL         "Slider1",IDC_BUFFERSIZE,"msctls_trackbar32",

+                    TBS_AUTOTICKS | WS_TABSTOP,200,20,85,15

+    RTEXT           "0 KS",IDC_BUFFERSIZE2,250,35,35,10

+    LTEXT           "Increase this value to give better skip protection on slower computers",

+                    IDC_STATIC,200,45,85,30

+    DEFPUSHBUTTON   "OK",IDC_OK,155,150,65,15,0,WS_EX_DLGMODALFRAME

+    PUSHBUTTON      "Cancel",IDC_CANCEL,225,150,65,15,0,WS_EX_DLGMODALFRAME

+    PUSHBUTTON      "Default",IDC_DEFAULT,5,150,70,15

+    PUSHBUTTON      "Nicest",IDC_NICEST,210,100,65,15

+    PUSHBUTTON      "Fastest",IDC_FASTEST,210,120,65,15

+    GROUPBOX        "Quick Settings",IDC_STATIC,195,85,95,60

+END

+

+

+#ifdef APSTUDIO_INVOKED

+/////////////////////////////////////////////////////////////////////////////

+//

+// TEXTINCLUDE

+//

+

+1 TEXTINCLUDE DISCARDABLE 

+BEGIN

+    "resource.h\0"

+END

+

+2 TEXTINCLUDE DISCARDABLE 

+BEGIN

+    "#include ""afxres.h""\r\n"

+    "\0"

+END

+

+3 TEXTINCLUDE DISCARDABLE 

+BEGIN

+    "\r\n"

+    "\0"

+END

+

+#endif    // APSTUDIO_INVOKED

+

+

+/////////////////////////////////////////////////////////////////////////////

+//

+// DESIGNINFO

+//

+

+#ifdef APSTUDIO_INVOKED

+GUIDELINES DESIGNINFO DISCARDABLE 

+BEGIN

+    IDD_CONFIG, DIALOG

+    BEGIN

+        LEFTMARGIN, 6

+        RIGHTMARGIN, 289

+        TOPMARGIN, 13

+        BOTTOMMARGIN, 163

+    END

+END

+#endif    // APSTUDIO_INVOKED

+

+#endif    // English (U.S.) resources

+/////////////////////////////////////////////////////////////////////////////

+

+

+

+#ifndef APSTUDIO_INVOKED

+/////////////////////////////////////////////////////////////////////////////

+//

+// Generated from the TEXTINCLUDE 3 resource.

+//

+

+

+/////////////////////////////////////////////////////////////////////////////

+#endif    // not APSTUDIO_INVOKED

+

diff --git a/plugins/dumb/dumb-kode54/winamp/gui.c b/plugins/dumb/dumb-kode54/winamp/gui.c
new file mode 100644
index 00000000..45ac978b
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/winamp/gui.c
@@ -0,0 +1,331 @@
+

+#include <stdio.h>

+#include <windows.h>

+//#include <mmreg.h>

+//#include <msacm.h>

+#include <math.h>

+#include <commctrl.h>

+

+#include "in_duh.h"

+#include "resource.h"

+

+#include "gui.h"

+

+

+/* Registry settings */

+#define REGISTRY_KEY "Software\\Winamp\\DUH Plug-in"

+static HKEY registry = INVALID_HANDLE_VALUE;

+

+/* Some default values for config */

+int config_bits_per_sample = 16;

+int config_frequency = 44100;

+int config_stereo = CHANNEL_STEREO;

+int config_resampling = RESAMPLING_CUBIC;

+int config_buffer_size = 8192;

+int config_thread_priority = PRIORITY_HIGH;

+

+

+/*************************

+ * Registry manipulation */

+

+static int read_registry(char const *name, unsigned long type, void *ptr, unsigned long size)

+{

+	unsigned long reg_type;

+

+	if (registry == INVALID_HANDLE_VALUE ||

+		RegQueryValueEx(registry, name, 0, &reg_type, ptr, &size) != ERROR_SUCCESS

+		|| reg_type != type)

+		

+		return -1;

+

+	return 0;

+}

+

+

+static int write_registry(char const *name, unsigned long type, void *ptr, unsigned long size)

+{

+	if (registry == INVALID_HANDLE_VALUE

+		|| RegSetValueEx(registry, name, 0, type, ptr, size) != ERROR_SUCCESS)

+		

+		return -1;

+

+	return 0;

+}

+

+

+# define LOAD_REG_INT(name, var, defaultv) (read_registry(name, REG_DWORD,  \

+	&(var), sizeof(var)) == -1 ? ((var) = (defaultv)) : (var))

+

+# define LOAD_REG_STRING(name, var, defaultv) (read_registry(name, REG_SZ,  \

+	(var), sizeof(var)) == -1 ? strcpy(var, (defaultv)) : (var))

+

+# define SAVE_REG_INT(name, var) (write_registry(name, REG_DWORD, &(var), sizeof(var)))

+# define SAVE_REG_STRING(name, var) (write_registry(name, REG_SZ, (var), sizeof(var)))

+

+

+/*********************

+ * Range check       */

+

+#define CHECK_RANGE(x, a, b) x = ((x < (a)) ? (a) : ((x > (b)) ? (b) : x))

+

+

+/*********************

+ * Config Dialog Box */

+

+

+static INT_PTR CALLBACK config_dialog(HWND dialog, UINT message,

+								   WPARAM wparam, LPARAM lparam)

+{

+	int which;

+	int temp;

+	static int old_slider1 = 0;

+	char str[64];

+

+	(void)lparam;

+

+	switch (message) {

+	case WM_INITDIALOG:

+

+		/* Ok, now we need to set up the dialog's controls

+		 * to match the current config 

+		 */

+

+		/* Channels */

+		CheckDlgButton(dialog, IDC_STEREO, config_stereo == CHANNEL_STEREO ? BST_CHECKED : BST_UNCHECKED);

+

+		/* Bits per sample */

+		switch (config_bits_per_sample) {

+			case  8: which = IDC_8BPS;  break;

+			case 16: which = IDC_16BPS; break;

+			default:

+			which = 0;

+		}

+		if (which)

+			CheckRadioButton(dialog, IDC_8BPS, IDC_16BPS, which);

+

+		/* Resampling method */

+		switch (config_resampling) {

+			case  RESAMPLING_ALIASING:  which = IDC_ALIASING;  break;

+			case  RESAMPLING_LINEAR:    which = IDC_LINEAR;    break;

+			case  RESAMPLING_LINEAR2:   which = IDC_LINEAR_LOW_PASS;   break;

+			case  RESAMPLING_QUADRATIC: which = IDC_QUADRATIC; break;

+			case  RESAMPLING_CUBIC:     which = IDC_CUBIC;     break;

+			default:

+			which = 0;

+		}

+		if (which)

+			CheckRadioButton(dialog, IDC_ALIASING, IDC_CUBIC, which);

+

+		/* Frequency */

+		switch (config_frequency) {

+			case  11025:  which = IDC_11KHZ; break;

+			case  22050:  which = IDC_22KHZ; break;

+			case  44100:  which = IDC_44KHZ; break;

+			case  48000:  which = IDC_48KHZ; break;

+			default:

+			which = 0;

+		}

+		if (which)

+			CheckRadioButton(dialog, IDC_11KHZ, IDC_48KHZ, which);

+

+		/* Buffer size - 1 KB -> 32 KB slider */

+		old_slider1 = (int)(log(config_buffer_size) / log(2)) - 10;

+		SendDlgItemMessage(dialog, IDC_BUFFERSIZE, TBM_SETRANGE, FALSE, MAKELONG(0, 5));

+		SendDlgItemMessage(dialog, IDC_BUFFERSIZE, TBM_SETPOS, TRUE, old_slider1);

+		sprintf(str, "%i KS", config_buffer_size / 1024);

+		SetDlgItemText(dialog, IDC_BUFFERSIZE2, str);

+

+		/* Thread Priority */

+		SendDlgItemMessage(dialog, IDC_THREAD_PRI, TBM_SETRANGE, FALSE, MAKELONG(0, 2));

+		SendDlgItemMessage(dialog, IDC_THREAD_PRI, TBM_SETPOS,   TRUE,  config_thread_priority);

+

+		return TRUE;

+

+	case WM_COMMAND:

+		switch (LOWORD(wparam)) {

+

+		case IDC_DEFAULT:

+			/* Load default settings */

+

+			/* Channels */

+			CheckDlgButton(dialog, IDC_STEREO, BST_CHECKED);

+

+			/* Bits per sample */

+			CheckRadioButton(dialog, IDC_8BPS, IDC_16BPS, IDC_16BPS);

+

+			/* Resampling method */

+			CheckRadioButton(dialog, IDC_ALIASING, IDC_CUBIC, IDC_LINEAR_LOW_PASS);

+

+			/* Frequency */

+			CheckRadioButton(dialog, IDC_11KHZ, IDC_48KHZ, IDC_44KHZ);

+

+			/* Buffer size - 1 KB -> 32 KB slider */

+			SendDlgItemMessage(dialog, IDC_BUFFERSIZE, TBM_SETPOS, TRUE, 3);

+			sprintf(str, "%i KS", 8192 / 1024);

+			SetDlgItemText(dialog, IDC_BUFFERSIZE2, str);

+

+			/* Thread Priority */

+			SendDlgItemMessage(dialog, IDC_THREAD_PRI, TBM_SETPOS,   TRUE,  PRIORITY_HIGH);

+

+			return TRUE;

+

+		case IDC_NICEST:

+			/* Load nicest settings */

+

+			/* Channels */

+			CheckDlgButton(dialog, IDC_STEREO, BST_CHECKED);

+

+			/* Bits per sample */

+			CheckRadioButton(dialog, IDC_8BPS, IDC_16BPS, IDC_16BPS);

+

+			/* Resampling method */

+			CheckRadioButton(dialog, IDC_ALIASING, IDC_CUBIC, IDC_CUBIC);

+

+			/* Frequency */

+			CheckRadioButton(dialog, IDC_11KHZ, IDC_48KHZ, IDC_48KHZ);

+

+			/* Buffer size - 1 KB -> 32 KB slider */

+			SendDlgItemMessage(dialog, IDC_BUFFERSIZE, TBM_SETPOS, TRUE, 3);

+			sprintf(str, "%i KS", 8192 / 1024);

+			SetDlgItemText(dialog, IDC_BUFFERSIZE2, str);

+

+			/* Thread Priority */

+			SendDlgItemMessage(dialog, IDC_THREAD_PRI, TBM_SETPOS,   TRUE,  PRIORITY_HIGH);

+

+			return TRUE;

+

+		case IDC_FASTEST:

+			/* Load fastest settings */

+

+			/* Channels */

+			CheckDlgButton(dialog, IDC_STEREO, BST_UNCHECKED);

+

+			/* Bits per sample */

+			CheckRadioButton(dialog, IDC_8BPS, IDC_16BPS, IDC_8BPS);

+

+			/* Resampling method */

+			CheckRadioButton(dialog, IDC_ALIASING, IDC_CUBIC, IDC_ALIASING);

+

+			/* Frequency */

+			CheckRadioButton(dialog, IDC_11KHZ, IDC_48KHZ, IDC_11KHZ);

+

+			/* Buffer size - 1 KB -> 32 KB slider */

+			SendDlgItemMessage(dialog, IDC_BUFFERSIZE, TBM_SETPOS, TRUE, 3);

+			sprintf(str, "%i KS", 8192 / 1024);

+			SetDlgItemText(dialog, IDC_BUFFERSIZE2, str);

+

+			/* Thread Priority */

+			SendDlgItemMessage(dialog, IDC_THREAD_PRI, TBM_SETPOS,   TRUE,  PRIORITY_HIGH);

+

+			return TRUE;

+

+		case IDC_OK:

+			/* Read back configuration */

+			config_stereo = (IsDlgButtonChecked(dialog, IDC_STEREO) == BST_CHECKED) ? CHANNEL_STEREO : CHANNEL_MONO;

+			config_bits_per_sample = (IsDlgButtonChecked(dialog, IDC_8BPS) == BST_CHECKED) ? 8 : 16;

+			config_resampling = (IsDlgButtonChecked(dialog, IDC_ALIASING) == BST_CHECKED) ? RESAMPLING_ALIASING

+				: (IsDlgButtonChecked(dialog, IDC_LINEAR) == BST_CHECKED) ? RESAMPLING_LINEAR

+				: (IsDlgButtonChecked(dialog, IDC_LINEAR_LOW_PASS) == BST_CHECKED) ? RESAMPLING_LINEAR2

+				: (IsDlgButtonChecked(dialog, IDC_QUADRATIC) == BST_CHECKED) ? RESAMPLING_QUADRATIC

+				: RESAMPLING_CUBIC;

+			config_frequency = (IsDlgButtonChecked(dialog, IDC_11KHZ) == BST_CHECKED) ? 11025

+				: (IsDlgButtonChecked(dialog, IDC_22KHZ) == BST_CHECKED) ? 22050

+				: (IsDlgButtonChecked(dialog, IDC_44KHZ) == BST_CHECKED) ? 44100

+				: 48000;

+			config_buffer_size = 1 << (SendDlgItemMessage(dialog, IDC_BUFFERSIZE, TBM_GETPOS, 0, 0) + 10);

+

+			config_thread_priority = SendDlgItemMessage(dialog, IDC_THREAD_PRI, TBM_GETPOS, 0, 0);

+

+		case IDCANCEL:

+		case IDC_CANCEL:

+		case IDCLOSE:

+			EndDialog(dialog, wparam);

+			return TRUE;

+		}

+		break;

+	default:

+		temp = 1 << (SendDlgItemMessage(dialog, IDC_BUFFERSIZE, TBM_GETPOS, 0, 0) + 10);

+		if (temp != old_slider1) {

+			old_slider1 = temp;

+			sprintf(str, "%i KS", temp / 1024);

+			SetDlgItemText(dialog, IDC_BUFFERSIZE2, str);

+			return TRUE;

+		}

+		break;

+	}

+	return FALSE;

+}

+

+

+

+/* DUH Config dialog */

+void config(HWND hwndParent) {

+

+	if (DialogBox(mod.hDllInstance, MAKEINTRESOURCE(IDD_CONFIG),

+		hwndParent, config_dialog) == IDC_OK) {

+

+		SAVE_REG_INT("Stereo",         config_stereo);

+		SAVE_REG_INT("Frequency",      config_frequency);

+		SAVE_REG_INT("Resampling",     config_resampling);

+		SAVE_REG_INT("BitsPerSample",  config_bits_per_sample);

+		SAVE_REG_INT("BufferSize",     config_buffer_size);

+		SAVE_REG_INT("ThreadPriority", config_thread_priority);

+	}

+}

+

+

+void config_init(void) {

+

+	/* Load config from registry */

+

+	if (RegCreateKeyEx(HKEY_CURRENT_USER, REGISTRY_KEY, 0, "",

+		REG_OPTION_NON_VOLATILE, KEY_READ | KEY_WRITE, 0,

+		&registry, 0) != ERROR_SUCCESS)

+		

+		registry = INVALID_HANDLE_VALUE;

+

+	LOAD_REG_INT("Stereo",         config_stereo,     CHANNEL_STEREO);

+	LOAD_REG_INT("Frequency",      config_frequency,  44100);

+	LOAD_REG_INT("Resampling",     config_resampling, RESAMPLING_CUBIC);

+	LOAD_REG_INT("BitsPerSample",  config_bits_per_sample, 16);

+	LOAD_REG_INT("BufferSize",     config_buffer_size, 8192);

+	LOAD_REG_INT("ThreadPriority", config_thread_priority, PRIORITY_HIGH);

+

+	CHECK_RANGE(config_stereo, CHANNEL_MONO, CHANNEL_STEREO);

+	if (   config_frequency != 11025

+		&& config_frequency != 22050

+		&& config_frequency != 44100

+		&& config_frequency != 48000)

+		config_frequency = 44100;

+	CHECK_RANGE(config_resampling, RESAMPLING_ALIASING, RESAMPLING_CUBIC);

+	if (   config_bits_per_sample != 8

+		&& config_bits_per_sample != 16)

+		config_bits_per_sample = 16;

+	CHECK_RANGE(config_buffer_size, 1024, 32768);

+	CHECK_RANGE(config_thread_priority, PRIORITY_NORMAL, PRIORITY_HIGHEST);

+

+

+	return;

+}

+

+

+

+void config_quit(void) {

+

+	/* Close registry key */

+	if (registry != INVALID_HANDLE_VALUE) {

+		RegCloseKey(registry);

+		registry = INVALID_HANDLE_VALUE;

+	}

+

+	return;

+}

+

+

+

+/* About box, yay! */

+void about(HWND hwndParent) {

+	MessageBox(hwndParent, "DUH! Winamp Plugin\n Version " VERSION " (x86)\n", 

+		"About:", MB_OK | MB_ICONINFORMATION);

+}

+

diff --git a/plugins/dumb/dumb-kode54/winamp/gui.h b/plugins/dumb/dumb-kode54/winamp/gui.h
new file mode 100644
index 00000000..7924b247
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/winamp/gui.h
@@ -0,0 +1,26 @@
+#define CHANNEL_MONO   1

+#define CHANNEL_STEREO 2

+

+#define RESAMPLING_ALIASING  0

+#define RESAMPLING_LINEAR    1

+#define RESAMPLING_LINEAR2   2

+#define RESAMPLING_QUADRATIC 3

+#define RESAMPLING_CUBIC     4

+

+#define PRIORITY_NORMAL  0

+#define PRIORITY_HIGH    1

+#define PRIORITY_HIGHEST 2

+

+

+extern void config(HWND hwndParent);

+extern void about(HWND hwndParent);

+

+extern void config_init(void);

+extern void config_quit(void);

+

+extern int config_bits_per_sample;

+extern int config_frequency;

+extern int config_stereo;

+extern int config_resampling;

+extern int config_buffer_size;

+extern int config_thread_priority;

diff --git a/plugins/dumb/dumb-kode54/winamp/in2.h b/plugins/dumb/dumb-kode54/winamp/in2.h
new file mode 100644
index 00000000..d156c34b
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/winamp/in2.h
@@ -0,0 +1,123 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * in2.h - Winamp plug-in header file                 / / \  \

+ *                                                   | <  /   \_

+ * By Bob.                                           |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+#include "out.h"

+

+// note: exported symbol is now winampGetInModule2.

+

+#define IN_VER 0x100

+

+typedef struct 

+{

+	int version;				// module type (IN_VER)

+	char *description;			// description of module, with version string

+

+	HWND hMainWindow;			// winamp's main window (filled in by winamp)

+	HINSTANCE hDllInstance;		// DLL instance handle (Also filled in by winamp)

+

+	char *FileExtensions;		// "mp3\0Layer 3 MPEG\0mp2\0Layer 2 MPEG\0mpg\0Layer 1 MPEG\0"

+								// May be altered from Config, so the user can select what they want

+	

+	int is_seekable;			// is this stream seekable? 

+	int UsesOutputPlug;			// does this plug-in use the output plug-ins? (musn't ever change, ever :)

+

+	void (*Config)(HWND hwndParent); // configuration dialog

+	void (*About)(HWND hwndParent);  // about dialog

+

+	void (*Init)();				// called at program init

+	void (*Quit)();				// called at program quit

+

+	void (*GetFileInfo)(char *file, char *title, int *length_in_ms); // if file == NULL, current playing is used

+	int (*InfoBox)(char *file, HWND hwndParent);

+	

+	int (*IsOurFile)(char *fn);	// called before extension checks, to allow detection of mms://, etc

+	// playback stuff

+	int (*Play)(char *fn);		// return zero on success, -1 on file-not-found, some other value on other (stopping winamp) error

+	void (*Pause)();			// pause stream

+	void (*UnPause)();			// unpause stream

+	int (*IsPaused)();			// ispaused? return 1 if paused, 0 if not

+	void (*Stop)();				// stop (unload) stream

+

+	// time stuff

+	int (*GetLength)();			// get length in ms

+	int (*GetOutputTime)();		// returns current output time in ms. (usually returns outMod->GetOutputTime()

+	void (*SetOutputTime)(int time_in_ms);	// seeks to point in stream (in ms). Usually you signal yoru thread to seek, which seeks and calls outMod->Flush()..

+

+	// volume stuff

+	void (*SetVolume)(int volume);	// from 0 to 255.. usually just call outMod->SetVolume

+	void (*SetPan)(int pan);	// from -127 to 127.. usually just call outMod->SetPan

+	

+	// in-window builtin vis stuff

+

+	void (*SAVSAInit)(int maxlatency_in_ms, int srate);		// call once in Play(). maxlatency_in_ms should be the value returned from outMod->Open()

+	// call after opening audio device with max latency in ms and samplerate

+	void (*SAVSADeInit)();	// call in Stop()

+

+

+	// simple vis supplying mode

+	void (*SAAddPCMData)(void *PCMData, int nch, int bps, int timestamp); 

+											// sets the spec data directly from PCM data

+											// quick and easy way to get vis working :)

+											// needs at least 576 samples :)

+

+	// advanced vis supplying mode, only use if you're cool. Use SAAddPCMData for most stuff.

+	int (*SAGetMode)();		// gets csa (the current type (4=ws,2=osc,1=spec))

+							// use when calling SAAdd()

+	void (*SAAdd)(void *data, int timestamp, int csa); // sets the spec data, filled in by winamp

+

+

+	// vis stuff (plug-in)

+	// simple vis supplying mode

+	void (*VSAAddPCMData)(void *PCMData, int nch, int bps, int timestamp); // sets the vis data directly from PCM data

+											// quick and easy way to get vis working :)

+											// needs at least 576 samples :)

+

+	// advanced vis supplying mode, only use if you're cool. Use VSAAddPCMData for most stuff.

+	int (*VSAGetMode)(int *specNch, int *waveNch); // use to figure out what to give to VSAAdd

+	void (*VSAAdd)(void *data, int timestamp); // filled in by winamp, called by plug-in

+

+

+	// call this in Play() to tell the vis plug-ins the current output params. 

+	void (*VSASetInfo)(int nch, int srate);

+

+

+	// dsp plug-in processing: 

+	// (filled in by winamp, called by input plug)

+

+	// returns 1 if active (which means that the number of samples returned by dsp_dosamples

+	// could be greater than went in.. Use it to estimate if you'll have enough room in the

+	// output buffer

+	int (*dsp_isactive)(); 

+

+	// returns number of samples to output. This can be as much as twice numsamples. 

+	// be sure to allocate enough buffer for samples, then.

+	int (*dsp_dosamples)(short int *samples, int numsamples, int bps, int nch, int srate);

+

+

+	// eq stuff

+	void (*EQSet)(int on, char data[10], int preamp); // 0-64 each, 31 is +0, 0 is +12, 63 is -12. Do nothing to ignore.

+

+	// info setting (filled in by winamp)

+	void (*SetInfo)(int bitrate, int srate, int stereo, int synched); // if -1, changes ignored? :)

+

+	Out_Module *outMod; // filled in by winamp, optionally used :)

+} In_Module;

+

+

diff --git a/plugins/dumb/dumb-kode54/winamp/in_duh.c b/plugins/dumb/dumb-kode54/winamp/in_duh.c
new file mode 100644
index 00000000..e97c07af
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/winamp/in_duh.c
@@ -0,0 +1,655 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * in_duh.c - Winamp plug-in for DUMB.                / / \  \

+ *                                                   | <  /   \_

+ * By Bob.                                           |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+

+//#define SOFTVOLUME

+

+#include "in_duh.h"

+#include "resource.h"

+#include "gui.h"

+

+

+typedef struct DUH_PLAYER

+{

+	int n_channels;

+	DUH_SIGRENDERER *dr;

+	float volume;

+}

+DUH_PLAYER;

+

+

+/* Winamp Output module; we write to this to tell Winamp what to play */

+In_Module mod;

+

+/* Currently playing file */

+DUH *duh;

+DUH_PLAYER *duh_player;

+int init_duh = TRUE;

+char *duh_filename = NULL;

+#ifdef SOFTVOLUME

+int thevolume = 255;

+#endif

+

+

+

+/******************

+ *  Configuration */

+static int bits_per_sample;

+static int frequency;

+static int stereo;

+static int resampling;

+static int buffer_size;

+static int thread_priority;

+

+

+

+/****************

+ * Winamp Stuff */

+

+HANDLE input_file = INVALID_HANDLE_VALUE;    /* input file handle */

+

+int killDecodeThread = 0;                    /* the kill switch for the decode thread */

+HANDLE thread_handle = INVALID_HANDLE_VALUE; /* the handle to the decode thread */

+

+DWORD WINAPI __stdcall DecodeThread(void *b); /* the decode thread procedure */

+

+/* Avoid CRT. Evil. Big. Bloated. */

+BOOL WINAPI _DllMainCRTStartup(HANDLE hInst, ULONG ul_reason_for_call, LPVOID lpReserved)

+{

+	(void)hInst;

+	(void)ul_reason_for_call;

+	(void)lpReserved;

+	return TRUE;

+}

+

+

+/* Post this to the main window at end of file (after playback as stopped) */

+#define WM_WA_MPEG_EOF (WM_USER+2)

+

+

+

+/* Stuff for interfacing with Winamp */

+int decode_pos_ms;

+int paused;

+int seek_needed;      /* if != -1, it is the point that the decode thread should seek to, in ms. */

+//char *sample_buffer = NULL;

+

+//int buffer_pos = 0;

+

+

+

+/* Init DUH */

+void init()

+{

+	config_init();

+	dumb_register_stdfiles();

+}

+

+

+

+/* De-Init */

+void quit()

+{

+	config_quit();

+

+	if (duh_player)

+		free(duh_player);

+	if (duh)

+		unload_duh(duh);

+

+	if (duh_filename)

+		free(duh_filename);

+

+	//if (sample_buffer)

+		//free(sample_buffer);

+

+	dumb_exit();

+}

+

+

+

+/* WA SDK: used for detecting URL streams.. unused here. strncmp(fn,"http://",7) to detect HTTP streams, etc */

+/* I -think- we need to tell Winamp that the file should use our plug-in */

+int isourfile(char *fn) { (void)fn; return 0; }

+

+void stop_duh(DUH_PLAYER *dp)

+{

+	if (dp) {

+		duh_end_sigrenderer(dp->dr);

+		free(dp);

+	}

+}

+

+

+int play(char *fn) 

+{ 

+	static int priority_table[] = {

+		THREAD_PRIORITY_NORMAL, THREAD_PRIORITY_ABOVE_NORMAL, THREAD_PRIORITY_HIGHEST

+	};

+	int maxlatency;

+	unsigned long thread_id;

+

+	/* Get rid of an old DUH */

+	if (duh_player) {

+		stop_duh(duh_player);

+		duh_player = NULL;

+	}

+

+	if (duh)

+		unload_duh(duh);

+

+	/* Load file */

+	duh = load_duh(fn);

+	if (!duh) {

+		duh = dumb_load_it(fn);

+		if (!duh) {

+			duh = dumb_load_xm(fn);

+			if (!duh) {

+				duh = dumb_load_s3m(fn);

+				if (!duh) {

+					duh = dumb_load_mod(fn);

+					if (!duh)

+						return 1;

+				}

+			}

+		}

+	}

+

+	init_duh = TRUE;

+

+	/* Set up some things for Winamp */

+	paused = 0;

+	decode_pos_ms = 0;

+	seek_needed = -1;

+

+	bits_per_sample = config_bits_per_sample;

+	frequency       = config_frequency;

+	stereo          = config_stereo;

+	resampling      = config_resampling;

+	buffer_size     = config_buffer_size;

+	thread_priority = priority_table[config_thread_priority];

+

+	/* Create the sample buffer */

+	//if (sample_buffer)

+		//free(sample_buffer);

+

+	//sample_buffer = malloc(((bits_per_sample + 7) / 8) * stereo * buffer_size);

+

+	//if (!sample_buffer)

+		//return 1;

+

+	//buffer_pos = 0;

+

+	/* Note: I -really- don't know what this does. Winamp's SDK doesn't mention this function... */

+	maxlatency = mod.outMod->Open(frequency, stereo, bits_per_sample, -1, -1);

+	if (maxlatency < 0) {  /* error opening device */

+		unload_duh(duh);

+		duh = NULL;

+		return 1;

+	}

+

+	/* Store the file name */

+	if (duh_filename)

+		free(duh_filename);

+	duh_filename = strdup(fn);

+

+	/* Note2: Dunno what does too; damn those Winamp docs */

+	/* dividing by 1000 for the first parameter of setinfo makes it */

+	/* display 'H'... for hundred.. i.e. 14H Kbps. */

+	mod.SetInfo((frequency * bits_per_sample * stereo) / 1000,

+		frequency / 1000, stereo, 1);

+

+	/* Ditto */

+	/* initialize vis stuff */

+	mod.SAVSAInit(maxlatency, frequency);

+	mod.VSASetInfo(frequency, stereo);

+

+	/* Ditthree */

+#ifdef SOFTVOLUME

+	mod.outMod->SetVolume(255);

+#else

+	mod.outMod->SetVolume(-666); /* set the output plug-ins default volume */

+#endif

+

+	/* Ok, now we set up the decoding thread */

+	killDecodeThread = 0;

+	thread_handle = (HANDLE) CreateThread(NULL,0,DecodeThread,&killDecodeThread,0,&thread_id);

+	SetThreadPriority(thread_handle, thread_priority);

+

+	return 0; 

+}

+

+

+

+/* Standard Winamp stuff */

+void pause()   { paused = 1;   mod.outMod->Pause(1); }

+void unpause() { paused = 0;   mod.outMod->Pause(0); }

+int ispaused() { return paused; }

+

+

+

+/* Stop playing the file */

+void stop()

+{

+	if (thread_handle != INVALID_HANDLE_VALUE)

+	{

+		killDecodeThread=1;

+		if (WaitForSingleObject(thread_handle,INFINITE) == WAIT_TIMEOUT)

+		{

+			MessageBox(mod.hMainWindow,"Error asking thread to die!\n","Error killing decode thread",0);

+			TerminateThread(thread_handle,0);

+		}

+		CloseHandle(thread_handle);

+		thread_handle = INVALID_HANDLE_VALUE;

+	}

+	if (duh_player) {

+		stop_duh(duh_player);

+		duh_player = NULL;

+	}

+

+	if (duh) {

+		unload_duh(duh);

+		duh = NULL;

+	}

+

+	/* Should I unload the file? It takes time to reload... */

+

+	mod.outMod->Close();

+

+	mod.SAVSADeInit();

+}

+

+

+

+int getlength()

+{

+	return (int) ((LONG_LONG)duh_get_length(duh) * 1000 >> 16);

+}

+

+

+

+int getoutputtime()

+{

+	return decode_pos_ms + (mod.outMod->GetOutputTime() - mod.outMod->GetWrittenTime());

+}

+

+

+

+void setoutputtime(int time_in_ms)

+{

+	seek_needed = time_in_ms;

+}

+

+

+

+void setvolume(int volume)

+{

+#ifdef SOFTVOLUME

+	thevolume = volume;

+	if (duh_player) duh_player->volume = volume / 255.0f;

+#else

+	mod.outMod->SetVolume(volume);

+#endif

+}

+

+

+

+void setpan(int pan) { mod.outMod->SetPan(pan); }

+

+

+

+int infoDlg(char *fn, HWND hwnd)

+{

+	(void)fn;

+	(void)hwnd;

+	// TODO: implement info dialog.

+	return 0;

+}

+

+

+

+static const char *fn_basename(const char *filename)

+{

+	for (;;) {

+		const char *p = strpbrk(filename, "/\\");

+		if (!p) return filename;

+		filename = p + 1;

+	}

+}

+

+

+

+void getfileinfo(char *filename, char *title, int *length_in_ms)

+{

+	if (!filename || !*filename) { /* currently playing file */

+

+		if (length_in_ms)

+			*length_in_ms = getlength();

+

+		if (title) {

+			const char *mod_title = duh_get_tag(duh, "TITLE");

+			if (mod_title && mod_title[0])

+				sprintf(title, "%s - %s", fn_basename(filename), mod_title);

+			else

+				strcpy(title, fn_basename(filename));

+		}

+	}

+	else { /* some other file */

+#if 1 // needs fixing better than this! more to add to DUMB's API?

+		if (length_in_ms || title) {

+			DUH *duh = load_duh(filename);

+			if (!duh) {

+				duh = dumb_load_it(filename);

+				if (!duh) {

+					duh = dumb_load_xm(filename);

+					if (!duh) {

+						duh = dumb_load_s3m(filename);

+						if (!duh) {

+							duh = dumb_load_mod(filename);

+							if (!duh)

+								return;

+						}

+					}

+				}

+			}

+

+			if (length_in_ms)

+				*length_in_ms = (int)((LONG_LONG)duh_get_length(duh) * 1000 >> 16);

+

+			if (title) {

+				const char *mod_title = duh_get_tag(duh, "TITLE");

+				if (mod_title && mod_title[0])

+					sprintf(title, "%s - %s", fn_basename(duh_filename), mod_title);

+				else

+					strcpy(title, fn_basename(duh_filename));

+			}

+

+			unload_duh(duh);

+		}

+#elif 0

+		/* This code only works (worked?) for DUH files. */

+		DUMBFILE *d = dumbfile_open(filename);

+

+		if (!d)

+			return;

+

+		if (dumbfile_mgetl(d) != DUH_SIGNATURE)

+			return;

+

+		*length_in_ms = (unsigned int)((LONG_LONG)dumbfile_igetl(d) * 1000 >> 16);

+

+		if (title)

+			strcpy(title, filename);

+

+		dumbfile_close(d);

+#else

+		*length_in_ms = 1000 * 60 * 10;

+

+		if (title)

+			strcpy(title, filename);

+#endif

+	}

+}

+

+

+

+void eq_set(int on, char data[10], int preamp)

+{

+	(void)on;

+	(void)data;

+	(void)preamp;

+	/* No equalizer support, sorry */

+}

+

+

+

+DUH_PLAYER *start_duh(DUH *duh, int n_channels, long pos, float volume)

+{

+	DUH_PLAYER *dp;

+

+	// This restriction is imposed by Allegro. <-- um...?

+	ASSERT(n_channels > 0);

+	ASSERT(n_channels <= 2);

+

+	if (!duh)

+		return NULL;

+

+	dp = malloc(sizeof(*dp));

+	if (!dp)

+		return NULL;

+

+	dp->n_channels = n_channels;

+

+	dp->dr = duh_start_sigrenderer(duh, 0, n_channels, pos);

+

+	if (!dp->dr) {

+		free(dp);

+		return NULL;

+	}

+

+	{

+		DUMB_IT_SIGRENDERER *itsr = duh_get_it_sigrenderer(dp->dr);

+		dumb_it_set_loop_callback(itsr, &dumb_it_callback_terminate, NULL);

+		dumb_it_set_xm_speed_zero_callback(itsr, &dumb_it_callback_terminate, NULL);

+	}

+

+	dp->volume = volume;

+

+	return dp;

+}

+

+

+

+

+void pause_duh(DUH_PLAYER *dp)

+{

+	(void)dp;

+	pause();

+}

+

+

+

+void resume_duh(DUH_PLAYER *dp)

+{

+	(void)dp;

+	unpause();

+}

+

+

+

+void set_duh_volume(DUH_PLAYER *dp, float volume)

+{

+	(void)dp;

+	setvolume((int)(volume * 255.0f));

+}

+

+

+

+

+/* Generate 576 samples of data from the DUH_PLAYER */

+int get_576_samples(DUH_PLAYER *dp, char *buf)

+{

+#if 1

+	if (!dp) return 0;

+

+	long n = duh_render(dp->dr, bits_per_sample, bits_per_sample == 8 ? 1 : 0,

+		dp->volume, 65536.0f / frequency, 576, buf);

+

+	return n * (bits_per_sample >> 3) * stereo;

+#else

+	long n;

+	int bps = ((bits_per_sample + 7) / 8) * stereo;

+

+	if (!dp)

+		return 0;

+

+	if (buffer_pos == 0 || buffer_pos + 576 >= buffer_size) {

+

+		if (buffer_pos) {

+			memmove(sample_buffer, sample_buffer + bps * buffer_pos, (buffer_size - buffer_pos) * bps);

+			buffer_pos = buffer_size - buffer_pos;

+		}

+

+		n = duh_render(dp->dr, bits_per_sample, bits_per_sample == 8 ? 1 : 0,

+			dp->volume, 65536.0f / frequency, buffer_size - buffer_pos,

+			sample_buffer + buffer_pos * bps);

+

+		if (n > 576) n = 576;

+

+		n *= bps;

+		buffer_pos = 0;

+	}

+

+	memcpy(buf, sample_buffer + buffer_pos * bps, 576 * bps);

+

+	buffer_pos += 576;

+

+	return 576 * bps;

+#endif

+}

+

+

+DWORD WINAPI __stdcall DecodeThread(void *b)

+{

+	static char buf[576 * 4];

+	int done = 0;

+	int length = 0;

+

+	if (init_duh) {

+		dumb_resampling_quality = resampling;

+#ifdef SOFTVOLUME

+		duh_player = start_duh(duh, stereo, 0, thevolume / 255.0f);

+#else

+		duh_player = start_duh(duh, stereo, 0, 1.0f);

+#endif

+		init_duh = FALSE;

+	}

+	length = getlength();

+

+

+	while (! *((int *)b) )

+	{

+		if (seek_needed != -1) {

+

+			decode_pos_ms = seek_needed-(seek_needed%1000);

+			seek_needed = -1;

+			done = 0;

+

+			mod.outMod->Flush(decode_pos_ms);

+

+			/* Position the playback pointer */

+			stop_duh(duh_player);

+			duh_player = start_duh(duh, stereo, (unsigned int)(decode_pos_ms * 65536.0 / 1000.0), 1.0);

+		}

+		if (done) {

+			mod.outMod->CanWrite();

+

+			if (!mod.outMod->IsPlaying()) {

+				PostMessage(mod.hMainWindow,WM_WA_MPEG_EOF,0,0);

+				return 0;

+			}

+			Sleep(10);

+		}

+		else if (mod.outMod->CanWrite() >= ((576 * stereo * ((bits_per_sample + 7) / 8)))) {

+

+			int l = get_576_samples(duh_player, buf);

+

+			if (!l || decode_pos_ms >= length) {

+				done = 1;

+			}

+			else {

+				/* Vis plug-ins interface */

+				mod.SAAddPCMData((char *)buf,  stereo, bits_per_sample, decode_pos_ms);

+				mod.VSAAddPCMData((char *)buf, stereo, bits_per_sample, decode_pos_ms);

+

+				/* Add PCM to output buffer */

+				decode_pos_ms += (576 * 1000) / frequency;

+

+				if (mod.dsp_isactive())

+					l = mod.dsp_dosamples((short *)buf, l / stereo / ((bits_per_sample + 7) / 8), bits_per_sample,

+						stereo, frequency) * (stereo * ((bits_per_sample + 7) / 8));

+

+				mod.outMod->Write(buf, l);

+			}

+		}

+		else /* Nothing to do this pass */

+			Sleep(config_frequency / 1000);

+	}

+	return 0;

+}

+

+

+

+In_Module mod =

+{

+	IN_VER,

+	"DUH! Player v" VERSION

+#ifdef __alpha

+	" (AXP)"

+#else

+	" (x86)"

+#endif

+	,

+	0,  /* hMainWindow */

+	0,  /* hDllInstance */

+	"DUH\0Dynamic Universal Harmony File (*.DUH)\0"

+	"IT\0Impulse Tracker Module (*.IT)\0"

+	"XM\0Fast Tracker 2 Module (*.XM)\0"

+	"S3M\0Scream Tracker 3 Module (*.S3M)\0"

+	"MOD\0Amiga Module (*.MOD)\0"

+	,

+	1,  /* is_seekable */

+	1,  /* uses output */

+	config,

+	about,

+	init,

+	quit,

+	getfileinfo,

+	infoDlg,

+	isourfile,

+	play,

+	pause,

+	unpause,

+	ispaused,

+	stop,

+

+	getlength,

+	getoutputtime,

+	setoutputtime,

+

+	setvolume,

+	setpan,

+

+	0,0,0,0,0,0,0,0,0, /* vis stuff */

+

+

+	0,0, /* dsp */

+

+	eq_set,

+

+	NULL,		/* setinfo */

+

+	0 /* out_mod */

+

+};

+

+__declspec( dllexport ) In_Module * winampGetInModule2()

+{

+	return &mod;

+}

diff --git a/plugins/dumb/dumb-kode54/winamp/in_duh.h b/plugins/dumb/dumb-kode54/winamp/in_duh.h
new file mode 100644
index 00000000..38dfe182
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/winamp/in_duh.h
@@ -0,0 +1,40 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * in_duh.h - Winamp plug-in header file.             / / \  \

+ *                                                   | <  /   \_

+ * By Bob.                                           |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#include <windows.h>

+//#include <mmreg.h>

+//#include <msacm.h>

+#include <math.h>

+

+#include "in2.h"

+

+#include "../include/dumb.h"

+

+

+/******************

+ * Plug in config */

+

+#define VERSION "0.1"

+

+

+#define STREAM_SIZE 576

+#define STREAM_FREQ 44100

+

+

+extern In_Module mod;

diff --git a/plugins/dumb/dumb-kode54/winamp/minalleg.c b/plugins/dumb/dumb-kode54/winamp/minalleg.c
new file mode 100644
index 00000000..af645339
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/winamp/minalleg.c
@@ -0,0 +1,2179 @@
+/* Mini Allegro - File and compression routines */

+/* Ripped from Allegro WIP */

+

+#include <stddef.h>

+#include <stdlib.h>

+#include <stdarg.h>

+#include <limits.h>

+#include <errno.h>

+#include <stdlib.h>

+#include <limits.h>

+#include <stdio.h>

+#include <ctype.h>

+#include <fcntl.h>

+#include <string.h>

+#include <sys/stat.h>

+#include <io.h>

+#include "minalleg.h"

+

+

+#ifndef _USE_LFN

+#define _USE_LFN  0

+#endif

+

+

+#if (!defined S_IRUSR) && (!defined SCAN_DEPEND)

+   #define S_IRUSR   S_IREAD

+   #define S_IWUSR   S_IWRITE

+#endif

+

+

+

+#define N            4096           /* 4k buffers for LZ compression */

+#define F            18             /* upper limit for LZ match length */

+#define THRESHOLD    2              /* LZ encode string into pos and length

+				       if match size is greater than this */

+

+

+typedef struct PACK_DATA            /* stuff for doing LZ compression */

+{

+   int state;                       /* where have we got to in the pack? */

+   int i, c, len, r, s;

+   int last_match_length, code_buf_ptr;

+   unsigned char mask;

+   char code_buf[17];

+   int match_position;

+   int match_length;

+   int lson[N+1];                   /* left children, */

+   int rson[N+257];                 /* right children, */

+   int dad[N+1];                    /* and parents, = binary search trees */

+   unsigned char text_buf[N+F-1];   /* ring buffer, with F-1 extra bytes

+				       for string comparison */

+} PACK_DATA;

+

+

+typedef struct UNPACK_DATA          /* for reading LZ files */

+{

+   int state;                       /* where have we got to? */

+   int i, j, k, r, c;

+   int flags;

+   unsigned char text_buf[N+F-1];   /* ring buffer, with F-1 extra bytes

+				       for string comparison */

+} UNPACK_DATA;

+

+

+static int refill_buffer(PACKFILE *f);

+static int flush_buffer(PACKFILE *f, int last);

+static void pack_inittree(PACK_DATA *dat);

+static void pack_insertnode(int r, PACK_DATA *dat);

+static void pack_deletenode(int p, PACK_DATA *dat);

+static int pack_write(PACKFILE *file, PACK_DATA *dat, int size, unsigned char *buf, int last);

+static int pack_read(PACKFILE *file, UNPACK_DATA *dat, int s, unsigned char *buf);

+

+static char the_password[256] = "";

+

+int _packfile_filesize = 0;

+int _packfile_datasize = 0;

+

+int _packfile_type = 0;

+

+

+#define FA_DAT_FLAGS  (FA_RDONLY | FA_ARCH)

+

+

+int pack_getc(PACKFILE *f)

+{

+   f->buf_size--;

+   if (f->buf_size > 0)

+      return *(f->buf_pos++);

+   else

+      return _sort_out_getc(f);

+}

+

+

+int pack_putc(int c, PACKFILE *f)

+{

+   f->buf_size++;

+   if (f->buf_size >= F_BUF_SIZE)

+      return _sort_out_putc(c, f);

+   else

+      return (*(f->buf_pos++) = c);

+}

+

+

+/* fix_filename_case:

+ *  Converts filename to upper case.

+ */

+char *fix_filename_case(char *filename)

+{

+   return filename;

+}

+

+

+

+/* fix_filename_slashes:

+ *  Converts '/' or '\' to system specific path separator.

+ */

+char *fix_filename_slashes(char *filename)

+{

+   int pos, c;

+

+   for (pos=0; c = filename[pos]; pos++) {

+      if ((c == '/') || (c == '\\'))

+		  filename[pos] = OTHER_PATH_SEPARATOR;

+   }

+

+   return filename;

+}

+

+

+

+/* fix_filename_path:

+ *  Canonicalizes path.

+ */

+char *fix_filename_path(char *dest, char *path, int size)

+{

+   int saved_errno = errno;

+   char buf[512], buf2[512];

+   char *p;

+   int pos = 0;

+   int drive = -1;

+   int c1, i;

+

+   memset(buf, 0, sizeof(buf));

+

+   #if (DEVICE_SEPARATOR != 0) && (DEVICE_SEPARATOR != '\0')

+

+      /* check whether we have a drive letter */

+      c1 = tolower(path[0]);

+      if ((c1 >= 'a') && (c1 <= 'z')) {

+	 int c2 = path[1];

+	 if (c2 == DEVICE_SEPARATOR) {

+	    drive = c1 - 'a';

+	    path += 2;

+	 }

+      }

+

+      /* if not, use the current drive */

+      if (drive < 0)

+	 drive = _al_getdrive();

+

+	  buf[pos] = drive + 'a';      pos++;

+	  buf[pos] = DEVICE_SEPARATOR; pos++;

+   #endif

+

+   /* if the path is relative, make it absolute */

+   if ((path[0] != '/') && (path[0] != OTHER_PATH_SEPARATOR) && (path[0] != '#')) {

+      _al_getdcwd(drive, buf2, sizeof(buf2) - 1);

+      put_backslash(buf2);

+

+      p = buf2;

+      if ((tolower(p[0]) >= 'a') && (tolower(p[0]) <= 'z') && (p[1] == DEVICE_SEPARATOR))

+	 p += 2;

+

+	  memcpy(buf + pos, p, sizeof(buf) - pos);

+      pos = strlen(buf);

+   }

+

+   /* add our path, and clean it up a bit */

+   memcpy(buf + pos, path, sizeof(buf) - pos);

+

+   fix_filename_case(buf);

+   fix_filename_slashes(buf);

+

+   /* remove duplicate slashes */

+   buf2[0] = OTHER_PATH_SEPARATOR;

+   buf2[1] = OTHER_PATH_SEPARATOR;

+   buf2[2] = 0;

+   pos = 2;

+

+   while ((p = strstr(buf, buf2)) != NULL)

+      memmove(p, p + 1, strlen(p));

+

+   /* remove /./ patterns */

+   buf2[0] = OTHER_PATH_SEPARATOR;

+   buf2[1] = '.';

+   buf2[2] = OTHER_PATH_SEPARATOR;

+   buf2[3] = 0;

+   pos = 3;

+

+   while ((p = strstr(buf, buf2)) != NULL) {

+      memmove(p, p + 1, strlen(p));

+      memmove(p, p + 1, strlen(p));

+   }

+

+   /* collapse /../ patterns */

+   buf2[0] = OTHER_PATH_SEPARATOR;

+   buf2[1] = '.';

+   buf2[2] = '.';

+   buf2[3] = OTHER_PATH_SEPARATOR;

+   buf2[4] = 0;

+   pos = 4;

+

+   while ((p = strstr(buf, buf2)) != NULL) {

+      for (i = 0; buf + i < p; i++)

+		  ;

+

+      while (--i > 0) {

+	 c1 = buf[i];

+

+	 if (c1 == OTHER_PATH_SEPARATOR)

+	    break;

+

+	 if (c1 == DEVICE_SEPARATOR) {

+	    i++;

+	    break;

+	 }

+      }

+

+      if (i < 0)

+	 i = 0;

+

+      p += strlen(buf2);

+      memmove(buf+i+1, p, strlen(p) + 1);

+   }

+

+   /* all done! */

+   memcpy(dest, buf, MIN(size, (int)strlen(buf)));

+

+   errno = saved_errno;

+

+   return dest;

+}

+

+

+

+/* replace_filename:

+ *  Replaces filename in path with different one.

+ *  It does not append '/' to the path.

+ */

+char *replace_filename(char *dest, char *path, char *filename, int size)

+{

+   char tmp[512];

+   int pos, c;

+

+   pos = strlen(path);

+

+   while (pos>0) {

+      c = path[pos - 1];

+      if ((c == '/') || (c == OTHER_PATH_SEPARATOR) || (c == DEVICE_SEPARATOR) || (c == '#'))

+	 break;

+      pos--;

+   }

+   memset(tmp, 0, sizeof(tmp));

+   memcpy(tmp, path, MIN(sizeof(tmp), pos));

+   memcpy(tmp + MIN(sizeof(tmp), pos), filename, MIN(strlen(filename), sizeof(tmp) - pos));

+

+   memcpy(dest, tmp, MIN((int)strlen(tmp), size));

+

+   return dest;

+}

+

+

+

+/* replace_extension:

+ *  Replaces extension in filename with different one.

+ *  It appends '.' if it is not present in the filename.

+ */

+char *replace_extension(char *dest, char *filename, char *ext, int size)

+{

+   char tmp[512];

+   int pos, end, c;

+

+   pos = end = strlen(filename);

+

+   while (pos>0) {

+      c = filename[pos - 1];

+      if ((c == '.') || (c == '/') || (c == OTHER_PATH_SEPARATOR) || (c == DEVICE_SEPARATOR) || (c == '#'))

+	 break;

+      pos--;

+   }

+

+   if (filename[pos - 1] == '.')

+      end = pos - 1;

+

+   memcpy(tmp, filename, MIN((int)sizeof(tmp), strlen(filename)));

+   if (strlen(tmp) < sizeof(tmp)-1) {

+      tmp[strlen(tmp)+1] = 0;

+      tmp[strlen(tmp)] = '.';

+   }

+   memcpy(tmp + strlen(tmp), ext, MIN(sizeof(tmp) - (int)strlen(tmp), (int)strlen(ext)));

+   memcpy(dest, tmp, MIN(size, sizeof(tmp)));

+

+   return dest;

+}

+

+

+

+/* append_filename:

+ *  Append filename to path, adding separator if necessary.

+ */

+char *append_filename(char *dest, char *path, char *filename, int size)

+{

+   char tmp[512];

+   int pos, c;

+

+   memcpy(tmp, path, MIN(sizeof(tmp) - 1, strlen(path)));

+   tmp[511] = 0;

+   pos = strlen(tmp);

+

+   if ((pos > 0) && (tmp[pos] < ((int)sizeof(tmp) - 2))) {

+      c = tmp[pos - 1];

+

+      if ((c != '/') && (c != OTHER_PATH_SEPARATOR) && (c != DEVICE_SEPARATOR) && (c != '#')) {

+		tmp[pos] = OTHER_PATH_SEPARATOR;

+		pos++;

+		tmp[pos] = 0;

+      }

+   }

+

+   memcpy(tmp + strlen(tmp), filename, MIN(sizeof(tmp) - (int)strlen(tmp), (int)strlen(filename)));

+   memcpy(dest, tmp, MIN(sizeof(tmp), (int)strlen(tmp)));

+

+   return dest;

+}

+

+

+

+/* get_filename:

+ *  When passed a completely specified file path, this returns a pointer

+ *  to the filename portion. Both '\' and '/' are recognized as directory

+ *  separators.

+ */

+char *get_filename(char *path)

+{

+   int pos, c;

+

+   pos = strlen(path);

+

+   while (pos>0) {

+      c = path[pos - 1];

+      if ((c == '/') || (c == OTHER_PATH_SEPARATOR) || (c == DEVICE_SEPARATOR) || (c == '#'))

+	 break;

+      pos--;

+   }

+

+   return (char *)path + pos;

+}

+

+

+

+/* get_extension:

+ *  When passed a complete filename (with or without path information)

+ *  this returns a pointer to the file extension.

+ */

+char *get_extension(char *filename)

+{

+   int pos, c;

+

+   pos = strlen(filename);

+

+   while (pos>0) {

+      c = filename[pos - 1];

+      if ((c == '.') || (c == '/') || (c == OTHER_PATH_SEPARATOR) || (c == DEVICE_SEPARATOR) || (c == '#'))

+	 break;

+      pos--;

+   }

+

+   if ((pos>0) && (filename[pos-1] == '.'))

+      return (char *)filename + pos;

+

+   return (char *)filename + strlen(filename);

+}

+

+

+

+/* put_backslash:

+ *  If the last character of the filename is not a \, /, or #, this routine

+ *  will concatenate a \ on to it.

+ */

+void put_backslash(char *filename)

+{

+   int c;

+

+   if (*filename) {

+      c = filename[strlen(filename)-1];

+

+      if ((c == '/') || (c == OTHER_PATH_SEPARATOR) || (c == DEVICE_SEPARATOR) || (c == '#'))

+	 return;

+   }

+

+   filename += strlen(filename);

+   filename[0] = OTHER_PATH_SEPARATOR;

+   filename[1] = 0;

+}

+

+

+

+/* file_exists:

+ *  Checks whether a file matching the given name and attributes exists,

+ *  returning non zero if it does. The file attribute may contain any of

+ *  the FA_* constants from dir.h. If aret is not null, it will be set 

+ *  to the attributes of the matching file. If an error occurs the system 

+ *  error code will be stored in errno.

+ */

+int file_exists(char *filename, int attrib, int *aret)

+{

+   int a;

+

+   if (!_al_file_isok(filename))

+      return 0;

+

+   if (!_al_file_exists(filename, attrib, &a))

+      return FALSE;

+

+   if (aret)

+      *aret = a;

+

+   return TRUE;

+}

+

+

+

+/* exists:

+ *  Shortcut version of file_exists().

+ */

+int exists(char *filename)

+{

+   return file_exists(filename, FA_ARCH | FA_RDONLY, NULL);

+}

+

+

+

+/* file_size:

+ *  Returns the size of a file, in bytes.

+ *  If the file does not exist or an error occurs, it will return zero

+ *  and store the system error code in errno.

+ */

+long file_size(char *filename)

+{

+

+   if (!_al_file_isok(filename))

+      return 0;

+

+   return _al_file_size(filename);

+}

+

+

+

+/* file_time:

+ *  Returns a file time-stamp.

+ *  If the file does not exist or an error occurs, it will return zero

+ *  and store the system error code in errno.

+ */

+time_t file_time(char *filename)

+{

+   if (!_al_file_isok(filename))

+      return 0;

+

+   return _al_file_time(filename);

+}

+

+

+

+/* delete_file:

+ *  Removes a file from the disk.

+ */

+int delete_file(char *filename)

+{

+   errno = 0;

+

+   if (!_al_file_isok(filename))

+      return errno;

+

+   unlink(filename);   

+

+   return errno;

+}

+

+

+

+/* for_each_file:

+ *  Finds all the files on the disk which match the given wildcard

+ *  specification and file attributes, and executes callback() once for

+ *  each. callback() will be passed three arguments, the first a string

+ *  which contains the completed filename, the second being the attributes

+ *  of the file, and the third an int which is simply a copy of param (you

+ *  can use this for whatever you like). If an error occurs an error code

+ *  will be stored in errno, and callback() can cause for_each_file() to

+ *  abort by setting errno itself. Returns the number of successful calls

+ *  made to callback(). The file attribute may contain any of the FA_* 

+ *  flags from dir.h.

+ */

+int for_each_file(char *name, int attrib, void (*callback)(char *filename, int attrib, int param), int param)

+{

+   char dta_name[512], buf[512];

+   void *dta;

+   int dta_attrib;

+   int c = 0;

+

+   if (!_al_file_isok(name))

+      return 0;

+

+   dta = _al_findfirst(name, attrib, dta_name, &dta_attrib);

+

+   if (!dta)

+      return 0;

+

+   do {

+      replace_filename(buf, name, dta_name, sizeof(buf));

+      (*callback)(buf, dta_attrib, param);

+      if (errno != 0)

+	 break;

+      c++;

+   } while (_al_findnext(dta, dta_name, &dta_attrib) == 0);

+

+   _al_findclose(dta);

+

+   errno = 0;

+   return c;

+}

+

+

+

+/* packfile_password:

+ *  Sets the password to be used by all future read/write operations.

+ */

+void packfile_password(char *password)

+{

+   int i = 0;

+   int c;

+

+   if (password) {

+      while ((c = *password) != 0) {

+		  password++;

+	 the_password[i++] = c;

+	 if (i >= (int)sizeof(the_password)-1)

+	    break;

+      }

+   }

+

+   the_password[i] = 0;

+}

+

+

+

+/* encrypt_id:

+ *  Helper for encrypting magic numbers, using the current password.

+ */

+static long encrypt_id(long x, int new_format)

+{

+   long mask = 0;

+   int i, pos;

+

+   if (the_password[0]) {

+      for (i=0; the_password[i]; i++)

+	 mask ^= ((long)the_password[i] << ((i&3) * 8));

+

+      for (i=0, pos=0; i<4; i++) {

+	 mask ^= (long)the_password[pos++] << (24-i*8);

+	 if (!the_password[pos])

+	    pos = 0;

+      }

+

+      if (new_format)

+	 mask ^= 42;

+   }

+

+   return x ^ mask;

+}

+

+

+

+/* clone_password:

+ *  Sets up a local password string for use by this packfile.

+ */

+static int clone_password(PACKFILE *f)

+{

+   if (the_password[0]) {

+      if ((f->passdata = malloc(strlen(the_password)+1)) == NULL) {

+	 errno = ENOMEM;

+	 return FALSE;

+      }

+      strcpy(f->passdata, the_password);

+   }

+   else

+      f->passdata = NULL;

+

+   f->passpos = f->passdata;

+

+   return TRUE;

+}

+

+

+

+/* pack_fopen:

+ *  Opens a file according to mode, which may contain any of the flags:

+ *  'r': open file for reading.

+ *  'w': open file for writing, overwriting any existing data.

+ *  'p': open file in 'packed' mode. Data will be compressed as it is

+ *       written to the file, and automatically uncompressed during read

+ *       operations. Files created in this mode will produce garbage if

+ *       they are read without this flag being set.

+ *  '!': open file for writing in normal, unpacked mode, but add the value

+ *       F_NOPACK_MAGIC to the start of the file, so that it can be opened

+ *       in packed mode and Allegro will automatically detect that the

+ *       data does not need to be decompressed.

+ *

+ *  Instead of these flags, one of the constants F_READ, F_WRITE,

+ *  F_READ_PACKED, F_WRITE_PACKED or F_WRITE_NOPACK may be used as the second 

+ *  argument to fopen().

+ *

+ *  On success, fopen() returns a pointer to a file structure, and on error

+ *  it returns NULL and stores an error code in errno. An attempt to read a 

+ *  normal file in packed mode will cause errno to be set to EDOM.

+ */

+PACKFILE *pack_fopen(const char *filename, char *mode)

+{

+   PACKFILE *f, *f2;

+   long header = FALSE;

+   int c;

+

+   _packfile_type = 0;

+

+   if (!_al_file_isok(filename))

+      return NULL;

+

+   errno = 0;

+

+   if ((f = malloc(sizeof(PACKFILE))) == NULL) {

+      errno = ENOMEM;

+      return NULL;

+   }

+

+   f->buf_pos = f->buf;

+   f->flags = 0;

+   f->buf_size = 0;

+   f->filename = NULL;

+   f->passdata = NULL;

+   f->passpos = NULL;

+

+   while ((c = *(mode++)) != 0) {

+      switch (c) {

+	 case 'r': case 'R': f->flags &= ~PACKFILE_FLAG_WRITE; break;

+	 case 'w': case 'W': f->flags |= PACKFILE_FLAG_WRITE; break;

+	 case 'p': case 'P': f->flags |= PACKFILE_FLAG_PACK; break;

+	 case '!': f->flags &= ~PACKFILE_FLAG_PACK; header = TRUE; break;

+      }

+   }

+

+   if (f->flags & PACKFILE_FLAG_WRITE) {

+      if (f->flags & PACKFILE_FLAG_PACK) {

+	 /* write a packed file */

+	 PACK_DATA *dat = malloc(sizeof(PACK_DATA));

+

+	 if (!dat) {

+	    errno = ENOMEM;

+	    free(f);

+	    return NULL;

+	 }

+

+	 if ((f->parent = pack_fopen(filename, F_WRITE)) == NULL) {

+	    free(dat);

+	    free(f);

+	    return NULL;

+	 }

+

+	 pack_mputl(encrypt_id(F_PACK_MAGIC, TRUE), f->parent);

+

+	 f->todo = 4;

+

+	 for (c=0; c < N - F; c++)

+	    dat->text_buf[c] = 0; 

+

+	 dat->state = 0;

+

+	 f->pack_data = dat;

+      }

+      else {

+	 /* write a 'real' file */

+	 f->parent = NULL;

+	 f->pack_data = NULL;

+

+	 if (!clone_password(f)) {

+	    free(f);

+	    return NULL;

+	 }

+#ifndef ALLEGRO_MPW

+	 f->hndl = open(filename, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);

+#else

+	 f->hndl = _al_open(uconvert_toascii(filename, NULL), O_WRONLY | O_BINARY | O_CREAT | O_TRUNC);

+#endif

+	 if (f->hndl < 0) {

+	    if (f->passdata)

+	       free(f->passdata);

+	    free(f);

+	    return NULL;

+	 }

+

+	 errno = 0;

+	 f->todo = 0;

+

+	 if (header)

+	    pack_mputl(encrypt_id(F_NOPACK_MAGIC, TRUE), f);

+      }

+   }

+   else { 

+      if (f->flags & PACKFILE_FLAG_PACK) {

+	 /* read a packed file */

+	 UNPACK_DATA *dat = malloc(sizeof(UNPACK_DATA));

+

+	 if (!dat) {

+	    errno = ENOMEM;

+	    free(f);

+	    return NULL;

+	 }

+

+	 if ((f->parent = pack_fopen(filename, F_READ)) == NULL) {

+	    free(dat);

+	    free(f);

+	    return NULL;

+	 }

+

+	 header = pack_mgetl(f->parent);

+

+	 if ((f->parent->passpos) &&

+	     ((header == encrypt_id(F_PACK_MAGIC, FALSE)) ||

+	      (header == encrypt_id(F_NOPACK_MAGIC, FALSE)))) {

+

+	    /* backward compatibility mode */

+	    pack_fclose(f->parent);

+

+	    if (!clone_password(f)) {

+	       free(dat);

+	       free(f);

+	       return NULL;

+	    }

+

+	    if ((f->parent = pack_fopen(filename, F_READ)) == NULL) {

+	       free(dat);

+	       free(f);

+	       return NULL;

+	    }

+

+	    f->parent->flags |= PACKFILE_FLAG_OLD_CRYPT;

+	    f->flags |= PACKFILE_FLAG_OLD_CRYPT;

+

+	    pack_mgetl(f->parent);

+

+	    if (header == encrypt_id(F_PACK_MAGIC, FALSE))

+	       header = encrypt_id(F_PACK_MAGIC, TRUE);

+	    else

+	       header = encrypt_id(F_NOPACK_MAGIC, TRUE);

+	 }

+

+	 if (header == encrypt_id(F_PACK_MAGIC, TRUE)) {

+	    for (c=0; c < N - F; c++)

+	       dat->text_buf[c] = 0; 

+	    dat->state = 0;

+	    f->todo = LONG_MAX;

+	    f->pack_data = (char *)dat;

+	 }

+	 else if (header == encrypt_id(F_NOPACK_MAGIC, TRUE)) {

+	    f2 = f->parent;

+	    free(dat);

+	    free(f);

+	    return f2;

+	 }

+	 else {

+	    pack_fclose(f->parent);

+	    free(dat);

+	    free(f);

+	    if (errno == 0)

+	       errno = EDOM;

+	    return NULL;

+	 }

+      }

+      else {

+	 /* read a 'real' file */

+	 f->parent = NULL;

+	 f->pack_data = NULL;

+

+	 f->todo = _al_file_size(filename);

+

+	 if (errno) {

+	    free(f);

+	    return NULL;

+	 }

+

+	 if (!clone_password(f)) {

+	    free(f);

+	    return NULL;

+	 }

+

+#ifndef ALLEGRO_MPW

+	 f->hndl = open(filename, O_RDONLY | O_BINARY, S_IRUSR | S_IWUSR);

+#else

+	 f->hndl = _al_open(uconvert_toascii(filename, NULL), O_RDONLY | O_BINARY);

+#endif

+

+	 if (f->hndl < 0) {

+	    if (f->passdata)

+	       free(f->passdata);

+	    free(f);

+	    return NULL;

+	 }

+      }

+   }

+

+   return f;

+}

+

+

+

+/* pack_fclose:

+ *  Closes a file after it has been read or written.

+ *  Returns zero on success. On error it returns an error code which is

+ *  also stored in errno. This function can fail only when writing to

+ *  files: if the file was opened in read mode it will always succeed.

+ */

+int pack_fclose(PACKFILE *f)

+{

+   if (f) {

+      if (f->flags & PACKFILE_FLAG_WRITE) {

+	 if (f->flags & PACKFILE_FLAG_CHUNK)

+	    return pack_fclose(pack_fclose_chunk(f));

+

+	 flush_buffer(f, TRUE);

+      }

+

+      if (f->passdata)

+	 free(f->passdata);

+

+      if (f->pack_data)

+	 free(f->pack_data);

+

+      if (f->parent)

+	 pack_fclose(f->parent);

+      else

+	 close(f->hndl);

+

+      free(f);

+      return errno;

+   }

+

+   return 0;

+}

+

+

+

+/* pack_fopen_chunk: 

+ *  Opens a sub-chunk of the specified file, for reading or writing depending

+ *  on the type of the file. The returned file pointer describes the sub

+ *  chunk, and replaces the original file, which will no longer be valid.

+ *  When writing to a chunk file, data is sent to the original file, but

+ *  is prefixed with two length counts (32 bit, big-endian). For uncompressed 

+ *  chunks these will both be set to the length of the data in the chunk.

+ *  For compressed chunks, created by setting the pack flag, the first will

+ *  contain the raw size of the chunk, and the second will be the negative

+ *  size of the uncompressed data. When reading chunks, the pack flag is

+ *  ignored, and the compression type is detected from the sign of the

+ *  second size value. The file structure used to read chunks checks the

+ *  chunk size, and will return EOF if you try to read past the end of

+ *  the chunk. If you don't read all of the chunk data, when you call

+ *  pack_fclose_chunk(), the parent file will advance past the unused data.

+ *  When you have finished reading or writing a chunk, you should call

+ *  pack_fclose_chunk() to return to your original file.

+ */

+PACKFILE *pack_fopen_chunk(PACKFILE *f, int pack)

+{

+   PACKFILE *chunk;

+   char *name;

+   int c;

+

+   if (f->flags & PACKFILE_FLAG_WRITE) {

+

+      /* write a sub-chunk */ 

+      name = tmpnam(NULL);

+      chunk = pack_fopen(name, (pack ? F_WRITE_PACKED : F_WRITE_NOPACK));

+

+      if (chunk) {

+         chunk->filename = strdup(name);

+

+	 if (pack)

+	    chunk->parent->parent = f;

+	 else

+	    chunk->parent = f;

+

+	 chunk->flags |= PACKFILE_FLAG_CHUNK;

+      }

+   }

+   else {

+      /* read a sub-chunk */

+      _packfile_filesize = pack_mgetl(f);

+      _packfile_datasize = pack_mgetl(f);

+

+      if ((chunk = malloc(sizeof(PACKFILE))) == NULL) {

+	 errno = ENOMEM;

+	 return NULL;

+      }

+

+      chunk->buf_pos = chunk->buf;

+      chunk->flags = PACKFILE_FLAG_CHUNK;

+      chunk->buf_size = 0;

+      chunk->filename = NULL;

+      chunk->passdata = NULL;

+      chunk->passpos = NULL;

+      chunk->parent = f;

+

+      if (f->flags & PACKFILE_FLAG_OLD_CRYPT) {

+	 /* backward compatibility mode */

+	 if (f->passdata) {

+	    if ((chunk->passdata = malloc(strlen(f->passdata)+1)) == NULL) {

+	       errno = ENOMEM;

+	       free(chunk);

+	       return NULL;

+	    }

+	    strcpy(chunk->passdata, f->passdata);

+	    chunk->passpos = chunk->passdata + (long)f->passpos - (long)f->passdata;

+	    f->passpos = f->passdata;

+	 }

+	 chunk->flags |= PACKFILE_FLAG_OLD_CRYPT;

+      }

+

+      if (_packfile_datasize < 0) {

+	 /* read a packed chunk */

+	 UNPACK_DATA *dat = malloc(sizeof(UNPACK_DATA));

+

+	 if (!dat) {

+	    errno = ENOMEM;

+	    if (chunk->passdata) free(chunk->passdata);

+	    free(chunk);

+	    return NULL;

+	 }

+

+	 for (c=0; c < N - F; c++)

+	    dat->text_buf[c] = 0; 

+

+	 dat->state = 0;

+	 _packfile_datasize = -_packfile_datasize;

+	 chunk->todo = _packfile_datasize;

+	 chunk->pack_data = (char *)dat;

+	 chunk->flags |= PACKFILE_FLAG_PACK;

+      }

+      else {

+	 /* read an uncompressed chunk */

+	 chunk->todo = _packfile_datasize;

+	 chunk->pack_data = NULL;

+      }

+   }

+

+   return chunk;

+}

+

+

+

+/* pack_fclose_chunk:

+ *  Call after reading or writing a sub-chunk. This closes the chunk file,

+ *  and returns a pointer to the original file structure (the one you

+ *  passed to pack_fopen_chunk()), to allow you to read or write data 

+ *  after the chunk.

+ */

+PACKFILE *pack_fclose_chunk(PACKFILE *f)

+{

+   PACKFILE *parent = f->parent;

+   PACKFILE *tmp;

+   char *name = f->filename;

+   int header;

+

+   if (f->flags & PACKFILE_FLAG_WRITE) {

+      /* finish writing a chunk */

+      _packfile_datasize = f->todo + f->buf_size - 4;

+

+      if (f->flags & PACKFILE_FLAG_PACK) {

+	 parent = parent->parent;

+	 f->parent->parent = NULL;

+      }

+      else

+	 f->parent = NULL;

+

+      f->flags &= ~PACKFILE_FLAG_CHUNK;

+      pack_fclose(f);

+

+      tmp = pack_fopen(name, F_READ);

+      _packfile_filesize = tmp->todo - 4;

+

+      header = pack_mgetl(tmp);

+

+      pack_mputl(_packfile_filesize, parent);

+

+      if (header == encrypt_id(F_PACK_MAGIC, TRUE))

+	 pack_mputl(-_packfile_datasize, parent);

+      else

+	 pack_mputl(_packfile_datasize, parent);

+

+      while (!pack_feof(tmp))

+	 pack_putc(pack_getc(tmp), parent);

+

+      pack_fclose(tmp);

+

+      delete_file(name);

+      free(name);

+   }

+   else {

+      /* finish reading a chunk */

+      while (f->todo > 0)

+	 pack_getc(f);

+

+      if ((f->passpos) && (f->flags & PACKFILE_FLAG_OLD_CRYPT))

+	 parent->passpos = parent->passdata + (long)f->passpos - (long)f->passdata;

+

+      if (f->passdata)

+	 free(f->passdata);

+

+      if (f->pack_data)

+	 free(f->pack_data);

+

+      free(f);

+   }

+

+   return parent;

+}

+

+

+

+/* pack_fseek:

+ *  Like the stdio fseek() function, but only supports forward seeks 

+ *  relative to the current file position.

+ */

+int pack_fseek(PACKFILE *f, int offset)

+{

+   int i;

+

+   if (f->flags & PACKFILE_FLAG_WRITE)

+      return -1;

+

+   errno = 0;

+

+   /* skip forward through the buffer */

+   if (f->buf_size > 0) {

+      i = MIN(offset, f->buf_size);

+      f->buf_size -= i;

+      f->buf_pos += i;

+      offset -= i;

+      if ((f->buf_size <= 0) && (f->todo <= 0))

+	 f->flags |= PACKFILE_FLAG_EOF;

+   }

+

+   /* need to seek some more? */

+   if (offset > 0) {

+      i = MIN(offset, f->todo);

+

+      if ((f->flags & PACKFILE_FLAG_PACK) || (f->passpos)) {

+	 /* for compressed files, we just have to read through the data */

+	 while (i > 0) {

+	    pack_getc(f);

+	    i--;

+	 }

+      }

+      else {

+	 if (f->parent) {

+	    /* pass the seek request on to the parent file */

+	    pack_fseek(f->parent, i);

+	 }

+	 else {

+	    /* do a real seek */

+	    lseek(f->hndl, i, SEEK_CUR);

+	 }

+	 f->todo -= i;

+	 if (f->todo <= 0)

+	    f->flags |= PACKFILE_FLAG_EOF;

+      }

+   }

+

+   return errno;

+}

+

+

+

+/* pack_igetw:

+ *  Reads a 16 bit word from a file, using intel byte ordering.

+ */

+int pack_igetw(PACKFILE *f)

+{

+   int b1, b2;

+

+   if ((b1 = pack_getc(f)) != EOF)

+      if ((b2 = pack_getc(f)) != EOF)

+	 return ((b2 << 8) | b1);

+

+   return EOF;

+}

+

+

+

+/* pack_igetl:

+ *  Reads a 32 bit long from a file, using intel byte ordering.

+ */

+long pack_igetl(PACKFILE *f)

+{

+   int b1, b2, b3, b4;

+

+   if ((b1 = pack_getc(f)) != EOF)

+      if ((b2 = pack_getc(f)) != EOF)

+	 if ((b3 = pack_getc(f)) != EOF)

+	    if ((b4 = pack_getc(f)) != EOF)

+	       return (((long)b4 << 24) | ((long)b3 << 16) |

+		       ((long)b2 << 8) | (long)b1);

+

+   return EOF;

+}

+

+

+

+/* pack_iputw:

+ *  Writes a 16 bit int to a file, using intel byte ordering.

+ */

+int pack_iputw(int w, PACKFILE *f)

+{

+   int b1, b2;

+

+   b1 = (w & 0xFF00) >> 8;

+   b2 = w & 0x00FF;

+

+   if (pack_putc(b2,f)==b2)

+      if (pack_putc(b1,f)==b1)

+	 return w;

+

+   return EOF;

+}

+

+

+

+/* pack_iputw:

+ *  Writes a 32 bit long to a file, using intel byte ordering.

+ */

+long pack_iputl(long l, PACKFILE *f)

+{

+   int b1, b2, b3, b4;

+

+   b1 = (int)((l & 0xFF000000L) >> 24);

+   b2 = (int)((l & 0x00FF0000L) >> 16);

+   b3 = (int)((l & 0x0000FF00L) >> 8);

+   b4 = (int)l & 0x00FF;

+

+   if (pack_putc(b4,f)==b4)

+      if (pack_putc(b3,f)==b3)

+	 if (pack_putc(b2,f)==b2)

+	    if (pack_putc(b1,f)==b1)

+	       return l;

+

+   return EOF;

+}

+

+

+

+/* pack_mgetw:

+ *  Reads a 16 bit int from a file, using motorola byte-ordering.

+ */

+int pack_mgetw(PACKFILE *f)

+{

+   int b1, b2;

+

+   if ((b1 = pack_getc(f)) != EOF)

+      if ((b2 = pack_getc(f)) != EOF)

+	 return ((b1 << 8) | b2);

+

+   return EOF;

+}

+

+

+

+/* pack_mgetl:

+ *  Reads a 32 bit long from a file, using motorola byte-ordering.

+ */

+long pack_mgetl(PACKFILE *f)

+{

+   int b1, b2, b3, b4;

+

+   if ((b1 = pack_getc(f)) != EOF)

+      if ((b2 = pack_getc(f)) != EOF)

+	 if ((b3 = pack_getc(f)) != EOF)

+	    if ((b4 = pack_getc(f)) != EOF)

+	       return (((long)b1 << 24) | ((long)b2 << 16) |

+		       ((long)b3 << 8) | (long)b4);

+

+   return EOF;

+}

+

+

+

+/* pack_mputw:

+ *  Writes a 16 bit int to a file, using motorola byte-ordering.

+ */

+int pack_mputw(int w, PACKFILE *f)

+{

+   int b1, b2;

+

+   b1 = (w & 0xFF00) >> 8;

+   b2 = w & 0x00FF;

+

+   if (pack_putc(b1,f)==b1)

+      if (pack_putc(b2,f)==b2)

+	 return w;

+

+   return EOF;

+}

+

+

+

+/* pack_mputl:

+ *  Writes a 32 bit long to a file, using motorola byte-ordering.

+ */

+long pack_mputl(long l, PACKFILE *f)

+{

+   int b1, b2, b3, b4;

+

+   b1 = (int)((l & 0xFF000000L) >> 24);

+   b2 = (int)((l & 0x00FF0000L) >> 16);

+   b3 = (int)((l & 0x0000FF00L) >> 8);

+   b4 = (int)l & 0x00FF;

+

+   if (pack_putc(b1,f)==b1)

+      if (pack_putc(b2,f)==b2)

+	 if (pack_putc(b3,f)==b3)

+	    if (pack_putc(b4,f)==b4)

+	       return l;

+

+   return EOF;

+}

+

+

+

+/* pack_fread:

+ *  Reads n bytes from f and stores them at memory location p. Returns the 

+ *  number of items read, which will be less than n if EOF is reached or an 

+ *  error occurs. Error codes are stored in errno.

+ */

+long pack_fread(void *p, long n, PACKFILE *f)

+{

+   unsigned char *cp = (unsigned char *)p;

+   long c;

+   int i;

+

+   for (c=0; c<n; c++) {

+      if (--(f->buf_size) > 0)

+	 *(cp++) = *(f->buf_pos++);

+      else {

+	 i = _sort_out_getc(f);

+	 if (i == EOF)

+	    return c;

+	 else

+	    *(cp++) = i;

+      }

+   }

+

+   return n;

+}

+

+

+

+/* pack_fwrite:

+ *  Writes n bytes to the file f from memory location p. Returns the number 

+ *  of items written, which will be less than n if an error occurs. Error 

+ *  codes are stored in errno.

+ */

+long pack_fwrite(void *p, long n, PACKFILE *f)

+{

+   unsigned char *cp = (unsigned char *)p;

+   long c;

+

+   for (c=0; c<n; c++) {

+      if (++(f->buf_size) >= F_BUF_SIZE) {

+	 if (_sort_out_putc(*cp,f) != *cp)

+	    return c;

+	 cp++;

+      }

+      else

+	 *(f->buf_pos++)=*(cp++);

+   }

+

+   return n;

+}

+

+

+

+/* pack_ungetc:

+ *  Puts a character back in the file's input buffer.  Added by gfoot for

+ *  use in the fgets function; maybe it should be in the API.  It only works

+ *  for characters just fetched by pack_getc.

+ */

+static void pack_ungetc (int ch, PACKFILE *f)

+{

+   *(--f->buf_pos) = (unsigned char) ch;

+   f->buf_size++;

+   f->flags &= ~PACKFILE_FLAG_EOF;

+}

+

+

+

+/* pack_fgets:

+ *  Reads a line from a text file, storing it at location p. Stops when a

+ *  linefeed is encountered, or max characters have been read. Returns a

+ *  pointer to where it stored the text, or NULL on error. The end of line

+ *  is handled by detecting optional '\r' characters optionally followed 

+ *  by '\n' characters. This supports CR-LF (DOS/Windows), LF (Unix), and

+ *  CR (Mac) formats.

+ */

+char *pack_fgets(char *p, int max, PACKFILE *f)

+{

+   char *pmax;

+   int c;

+

+   errno = 0;

+

+   pmax = p+max - 1;

+

+   if (pack_feof(f)) {

+      if (1 < max) *p = 0;

+      return NULL;

+   }

+

+   while ((c = pack_getc (f)) != EOF) {

+

+      if (c == '\r' || c == '\n') {

+	 /* Technically we should check there's space in the buffer, and if so,

+	  * add a \n.  But pack_fgets has never done this. */

+	 if (c == '\r') {

+	    /* eat the following \n, if any */

+	    if ((c = pack_getc (f)) != '\n') pack_ungetc (c, f);

+	 }

+	 break;

+      }

+

+      /* is there room in the buffer? */

+      if (1 > pmax - p) {

+	 pack_ungetc (c, f);

+	 c = '\0';

+	 break;

+      }

+

+      /* write the character */

+      *p = c;

+	  p++;

+   }

+

+   /* terminate the string */

+   *p = 0;

+

+   if (c == '\0' || errno)

+      return NULL;

+

+   return p;

+}

+

+

+

+/* pack_fputs:

+ *  Writes a string to a text file, returning zero on success, -1 on error.

+ */

+int pack_fputs(char *p, PACKFILE *f)

+{

+   char *s;

+

+   errno = 0;

+

+   s = p;

+

+   while (*s) {

+	 if (*s == '\n')

+	    pack_putc('\r', f);

+

+      pack_putc(*s, f);

+      s++;

+   }

+

+   if (errno)

+      return -1;

+   else

+      return 0;

+}

+

+

+

+/* _sort_out_getc:

+ *  Helper function for the pack_getc() macro.

+ */

+int _sort_out_getc(PACKFILE *f)

+{

+   if (f->buf_size == 0) {

+      if (f->todo <= 0)

+	 f->flags |= PACKFILE_FLAG_EOF;

+      return *(f->buf_pos++);

+   }

+   return refill_buffer(f);

+}

+

+

+

+/* refill_buffer:

+ *  Refills the read buffer. The file must have been opened in read mode,

+ *  and the buffer must be empty.

+ */

+static int refill_buffer(PACKFILE *f)

+{

+   int i, sz, done, offset;

+

+   if ((f->flags & PACKFILE_FLAG_EOF) || (f->todo <= 0)) {

+      f->flags |= PACKFILE_FLAG_EOF;

+      return EOF;

+   }

+

+   if (f->parent) {

+      if (f->flags & PACKFILE_FLAG_PACK) {

+	 f->buf_size = pack_read(f->parent, (UNPACK_DATA *)f->pack_data, MIN(F_BUF_SIZE, f->todo), f->buf);

+      }

+      else {

+	 f->buf_size = pack_fread(f->buf, MIN(F_BUF_SIZE, f->todo), f->parent);

+      } 

+      if (f->parent->flags & PACKFILE_FLAG_EOF)

+	 f->todo = 0;

+      if (f->parent->flags & PACKFILE_FLAG_ERROR)

+	 goto err;

+   }

+   else {

+      f->buf_size = MIN(F_BUF_SIZE, f->todo);

+

+      offset = lseek(f->hndl, 0, SEEK_CUR);

+      done = 0;

+

+      errno = 0;

+      sz = read(f->hndl, f->buf, f->buf_size);

+

+      while (sz+done < f->buf_size) {

+	 if ((sz < 0) && ((errno != EINTR) && (errno != EAGAIN)))

+	    goto err;

+

+	 if (sz > 0)

+	    done += sz;

+

+	 lseek(f->hndl, offset+done, SEEK_SET);

+         errno = 0;

+	 sz = read(f->hndl, f->buf+done, f->buf_size-done);

+      }

+      errno = 0;

+

+      if (errno == EINTR)

+	 errno = 0;

+

+      if ((f->passpos) && (!(f->flags & PACKFILE_FLAG_OLD_CRYPT))) {

+	 for (i=0; i<f->buf_size; i++) {

+	    f->buf[i] ^= *(f->passpos++);

+	    if (!*f->passpos)

+	       f->passpos = f->passdata;

+	 }

+      }

+   }

+

+   f->todo -= f->buf_size;

+   f->buf_pos = f->buf;

+   f->buf_size--;

+   if (f->buf_size <= 0)

+      if (f->todo <= 0)

+	 f->flags |= PACKFILE_FLAG_EOF;

+

+   return *(f->buf_pos++);

+

+   err:

+   errno = EFAULT;

+   f->flags |= PACKFILE_FLAG_ERROR;

+   return EOF;

+}

+

+

+

+/* _sort_out_putc:

+ *  Helper function for the pack_putc() macro.

+ */

+int _sort_out_putc(int c, PACKFILE *f)

+{

+   f->buf_size--;

+

+   if (flush_buffer(f, FALSE))

+      return EOF;

+

+   f->buf_size++;

+   return (*(f->buf_pos++)=c);

+}

+

+

+

+/* flush_buffer:

+ * flushes a file buffer to the disk. The file must be open in write mode.

+ */

+static int flush_buffer(PACKFILE *f, int last)

+{

+   int i, sz, done, offset;

+

+   if (f->buf_size > 0) {

+      if (f->flags & PACKFILE_FLAG_PACK) {

+	 if (pack_write(f->parent, (PACK_DATA *)f->pack_data, f->buf_size, f->buf, last))

+	    goto err;

+      }

+      else {

+	 if ((f->passpos) && (!(f->flags & PACKFILE_FLAG_OLD_CRYPT))) {

+	    for (i=0; i<f->buf_size; i++) {

+	       f->buf[i] ^= *(f->passpos++);

+	       if (!*f->passpos)

+		  f->passpos = f->passdata;

+	    }

+	 }

+

+	 offset = lseek(f->hndl, 0, SEEK_CUR);

+	 done = 0;

+

+	 errno = 0;

+	 sz = write(f->hndl, f->buf, f->buf_size);

+

+	 while (sz+done < f->buf_size) {

+	    if ((sz < 0) && ((errno != EINTR) && (errno != EAGAIN)))

+	       goto err;

+

+	    if (sz > 0)

+	       done += sz;

+

+	    lseek(f->hndl, offset+done, SEEK_SET);

+	    errno = 0;

+	    sz = write(f->hndl, f->buf+done, f->buf_size-done);

+	 }

+	 errno = 0;

+      }

+      f->todo += f->buf_size;

+   }

+   f->buf_pos = f->buf;

+   f->buf_size = 0;

+   return 0;

+

+   err:

+   errno = EFAULT;

+   f->flags |= PACKFILE_FLAG_ERROR;

+   return EOF;

+}

+

+

+

+/***************************************************

+ ************ LZSS compression routines ************

+ ***************************************************

+

+   This compression algorithm is based on the ideas of Lempel and Ziv,

+   with the modifications suggested by Storer and Szymanski. The algorithm 

+   is based on the use of a ring buffer, which initially contains zeros. 

+   We read several characters from the file into the buffer, and then 

+   search the buffer for the longest string that matches the characters 

+   just read, and output the length and position of the match in the buffer.

+

+   With a buffer size of 4096 bytes, the position can be encoded in 12

+   bits. If we represent the match length in four bits, the <position,

+   length> pair is two bytes long. If the longest match is no more than

+   two characters, then we send just one character without encoding, and

+   restart the process with the next letter. We must send one extra bit

+   each time to tell the decoder whether we are sending a <position,

+   length> pair or an unencoded character, and these flags are stored as

+   an eight bit mask every eight items.

+

+   This implementation uses binary trees to speed up the search for the

+   longest match.

+

+   Original code by Haruhiko Okumura, 4/6/1989.

+   12-2-404 Green Heights, 580 Nagasawa, Yokosuka 239, Japan.

+

+   Modified for use in the Allegro filesystem by Shawn Hargreaves.

+

+   Use, distribute, and modify this code freely.

+*/

+

+

+

+/* pack_inittree:

+ *  For i = 0 to N-1, rson[i] and lson[i] will be the right and left 

+ *  children of node i. These nodes need not be initialized. Also, dad[i] 

+ *  is the parent of node i. These are initialized to N, which stands for 

+ *  'not used.' For i = 0 to 255, rson[N+i+1] is the root of the tree for 

+ *  strings that begin with character i. These are initialized to N. Note 

+ *  there are 256 trees.

+ */

+static void pack_inittree(PACK_DATA *dat)

+{

+   int i;

+

+   for (i=N+1; i<=N+256; i++)

+      dat->rson[i] = N;

+

+   for (i=0; i<N; i++)

+      dat->dad[i] = N;

+}

+

+

+

+/* pack_insertnode:

+ *  Inserts a string of length F, text_buf[r..r+F-1], into one of the trees 

+ *  (text_buf[r]'th tree) and returns the longest-match position and length 

+ *  via match_position and match_length. If match_length = F, then removes 

+ *  the old node in favor of the new one, because the old one will be 

+ *  deleted sooner. Note r plays double role, as tree node and position in 

+ *  the buffer. 

+ */

+static void pack_insertnode(int r, PACK_DATA *dat)

+{

+   int i, p, cmp;

+   unsigned char *key;

+   unsigned char *text_buf = dat->text_buf;

+

+   cmp = 1;

+   key = &text_buf[r];

+   p = N + 1 + key[0];

+   dat->rson[r] = dat->lson[r] = N;

+   dat->match_length = 0;

+

+   for (;;) {

+

+      if (cmp >= 0) {

+	 if (dat->rson[p] != N)

+	    p = dat->rson[p];

+	 else {

+	    dat->rson[p] = r;

+	    dat->dad[r] = p;

+	    return;

+	 }

+      }

+      else {

+	 if (dat->lson[p] != N)

+	    p = dat->lson[p];

+	 else {

+	    dat->lson[p] = r;

+	    dat->dad[r] = p;

+	    return;

+	 }

+      }

+

+      for (i = 1; i < F; i++)

+	 if ((cmp = key[i] - text_buf[p + i]) != 0)

+	    break;

+

+      if (i > dat->match_length) {

+	 dat->match_position = p;

+	 if ((dat->match_length = i) >= F)

+	    break;

+      }

+   }

+

+   dat->dad[r] = dat->dad[p];

+   dat->lson[r] = dat->lson[p];

+   dat->rson[r] = dat->rson[p];

+   dat->dad[dat->lson[p]] = r;

+   dat->dad[dat->rson[p]] = r;

+   if (dat->rson[dat->dad[p]] == p)

+      dat->rson[dat->dad[p]] = r;

+   else

+      dat->lson[dat->dad[p]] = r;

+   dat->dad[p] = N;                 /* remove p */

+}

+

+

+

+/* pack_deletenode:

+ *  Removes a node from a tree.

+ */

+static void pack_deletenode(int p, PACK_DATA *dat)

+{

+   int q;

+

+   if (dat->dad[p] == N)

+      return;     /* not in tree */

+

+   if (dat->rson[p] == N)

+      q = dat->lson[p];

+   else

+      if (dat->lson[p] == N)

+	 q = dat->rson[p];

+      else {

+	 q = dat->lson[p];

+	 if (dat->rson[q] != N) {

+	    do {

+	       q = dat->rson[q];

+	    } while (dat->rson[q] != N);

+	    dat->rson[dat->dad[q]] = dat->lson[q];

+	    dat->dad[dat->lson[q]] = dat->dad[q];

+	    dat->lson[q] = dat->lson[p];

+	    dat->dad[dat->lson[p]] = q;

+	 }

+	 dat->rson[q] = dat->rson[p];

+	 dat->dad[dat->rson[p]] = q;

+      }

+

+   dat->dad[q] = dat->dad[p];

+   if (dat->rson[dat->dad[p]] == p)

+      dat->rson[dat->dad[p]] = q;

+   else

+      dat->lson[dat->dad[p]] = q;

+

+   dat->dad[p] = N;

+}

+

+

+

+/* pack_write:

+ *  Called by flush_buffer(). Packs size bytes from buf, using the pack 

+ *  information contained in dat. Returns 0 on success.

+ */

+static int pack_write(PACKFILE *file, PACK_DATA *dat, int size, unsigned char *buf, int last)

+{

+   int i = dat->i;

+   int c = dat->c;

+   int len = dat->len;

+   int r = dat->r;

+   int s = dat->s;

+   int last_match_length = dat->last_match_length;

+   int code_buf_ptr = dat->code_buf_ptr;

+   unsigned char mask = dat->mask;

+   int ret = 0;

+

+   if (dat->state==2)

+      goto pos2;

+   else

+      if (dat->state==1)

+	 goto pos1;

+

+   dat->code_buf[0] = 0;

+      /* code_buf[1..16] saves eight units of code, and code_buf[0] works

+	 as eight flags, "1" representing that the unit is an unencoded

+	 letter (1 byte), "0" a position-and-length pair (2 bytes).

+	 Thus, eight units require at most 16 bytes of code. */

+

+   code_buf_ptr = mask = 1;

+

+   s = 0;

+   r = N - F;

+   pack_inittree(dat);

+

+   for (len=0; (len < F) && (size > 0); len++) {

+      dat->text_buf[r+len] = *(buf++);

+      if (--size == 0) {

+	 if (!last) {

+	    dat->state = 1;

+	    goto getout;

+	 }

+      }

+      pos1:

+	 ; 

+   }

+

+   if (len == 0)

+      goto getout;

+

+   for (i=1; i <= F; i++)

+      pack_insertnode(r-i,dat);

+	    /* Insert the F strings, each of which begins with one or

+	       more 'space' characters. Note the order in which these

+	       strings are inserted. This way, degenerate trees will be

+	       less likely to occur. */

+

+   pack_insertnode(r,dat);

+	    /* Finally, insert the whole string just read. match_length

+	       and match_position are set. */

+

+   do {

+      if (dat->match_length > len)

+	 dat->match_length = len;  /* match_length may be long near the end */

+

+      if (dat->match_length <= THRESHOLD) {

+	 dat->match_length = 1;  /* not long enough match: send one byte */

+	 dat->code_buf[0] |= mask;    /* 'send one byte' flag */

+	 dat->code_buf[code_buf_ptr++] = dat->text_buf[r]; /* send uncoded */

+      }

+      else {

+	 /* send position and length pair. Note match_length > THRESHOLD */

+	 dat->code_buf[code_buf_ptr++] = (unsigned char) dat->match_position;

+	 dat->code_buf[code_buf_ptr++] = (unsigned char)

+				     (((dat->match_position >> 4) & 0xF0) |

+				      (dat->match_length - (THRESHOLD + 1)));

+      }

+

+      if ((mask <<= 1) == 0) {                  /* shift mask left one bit */

+	 if ((file->passpos) && (file->flags & PACKFILE_FLAG_OLD_CRYPT)) {

+	    dat->code_buf[0] ^= *file->passpos;

+	    file->passpos++;

+	    if (!*file->passpos)

+	       file->passpos = file->passdata;

+	 };

+

+	 for (i=0; i<code_buf_ptr; i++)         /* send at most 8 units of */

+	    pack_putc(dat->code_buf[i], file);  /* code together */

+

+	 if (pack_ferror(file)) {

+	    ret = EOF;

+	    goto getout;

+	 }

+	 dat->code_buf[0] = 0;

+	 code_buf_ptr = mask = 1;

+      }

+

+      last_match_length = dat->match_length;

+

+      for (i=0; (i < last_match_length) && (size > 0); i++) {

+	 c = *(buf++);

+	 if (--size == 0) {

+	    if (!last) {

+	       dat->state = 2;

+	       goto getout;

+	    }

+	 }

+	 pos2:

+	 pack_deletenode(s,dat);    /* delete old strings and */

+	 dat->text_buf[s] = c;      /* read new bytes */

+	 if (s < F-1)

+	    dat->text_buf[s+N] = c; /* if the position is near the end of

+				       buffer, extend the buffer to make

+				       string comparison easier */

+	 s = (s+1) & (N-1);

+	 r = (r+1) & (N-1);         /* since this is a ring buffer,

+				       increment the position modulo N */

+

+	 pack_insertnode(r,dat);    /* register the string in

+				       text_buf[r..r+F-1] */

+      }

+

+      while (i++ < last_match_length) {   /* after the end of text, */

+	 pack_deletenode(s,dat);          /* no need to read, but */

+	 s = (s+1) & (N-1);               /* buffer may not be empty */

+	 r = (r+1) & (N-1);

+	 if (--len)

+	    pack_insertnode(r,dat); 

+      }

+

+   } while (len > 0);   /* until length of string to be processed is zero */

+

+   if (code_buf_ptr > 1) {         /* send remaining code */

+      if ((file->passpos) && (file->flags & PACKFILE_FLAG_OLD_CRYPT)) {

+	 dat->code_buf[0] ^= *file->passpos;

+	 file->passpos++;

+	 if (!*file->passpos)

+	    file->passpos = file->passdata;

+      };

+

+      for (i=0; i<code_buf_ptr; i++) {

+	 pack_putc(dat->code_buf[i], file);

+	 if (pack_ferror(file)) {

+	    ret = EOF;

+	    goto getout;

+	 }

+      }

+   }

+

+   dat->state = 0;

+

+   getout:

+

+   dat->i = i;

+   dat->c = c;

+   dat->len = len;

+   dat->r = r;

+   dat->s = s;

+   dat->last_match_length = last_match_length;

+   dat->code_buf_ptr = code_buf_ptr;

+   dat->mask = mask;

+

+   return ret;

+}

+

+

+

+/* pack_read:

+ *  Called by refill_buffer(). Unpacks from dat into buf, until either

+ *  EOF is reached or s bytes have been extracted. Returns the number of

+ *  bytes added to the buffer

+ */

+static int pack_read(PACKFILE *file, UNPACK_DATA *dat, int s, unsigned char *buf)

+{

+   int i = dat->i;

+   int j = dat->j;

+   int k = dat->k;

+   int r = dat->r;

+   int c = dat->c;

+   unsigned int flags = dat->flags;

+   int size = 0;

+

+   if (dat->state==2)

+      goto pos2;

+   else

+      if (dat->state==1)

+	 goto pos1;

+

+   r = N-F;

+   flags = 0;

+

+   for (;;) {

+      if (((flags >>= 1) & 256) == 0) {

+	 if ((c = pack_getc(file)) == EOF)

+	    break;

+

+	 if ((file->passpos) && (file->flags & PACKFILE_FLAG_OLD_CRYPT)) {

+	    c ^= *file->passpos;

+	    file->passpos++;

+	    if (!*file->passpos)

+	       file->passpos = file->passdata;

+	 };

+

+	 flags = c | 0xFF00;        /* uses higher byte to count eight */

+      }

+

+      if (flags & 1) {

+	 if ((c = pack_getc(file)) == EOF)

+	    break;

+	 dat->text_buf[r++] = c;

+	 r &= (N - 1);

+	 *(buf++) = c;

+	 if (++size >= s) {

+	    dat->state = 1;

+	    goto getout;

+	 }

+	 pos1:

+	    ; 

+      }

+      else {

+	 if ((i = pack_getc(file)) == EOF)

+	    break;

+	 if ((j = pack_getc(file)) == EOF)

+	    break;

+	 i |= ((j & 0xF0) << 4);

+	 j = (j & 0x0F) + THRESHOLD;

+	 for (k=0; k <= j; k++) {

+	    c = dat->text_buf[(i + k) & (N - 1)];

+	    dat->text_buf[r++] = c;

+	    r &= (N - 1);

+	    *(buf++) = c;

+	    if (++size >= s) {

+	       dat->state = 2;

+	       goto getout;

+	    }

+	    pos2:

+	       ; 

+	 }

+      }

+   }

+

+   dat->state = 0;

+

+   getout:

+

+   dat->i = i;

+   dat->j = j;

+   dat->k = k;

+   dat->r = r;

+   dat->c = c;

+   dat->flags = flags;

+

+   return size;

+}

+

+

+

+

+/* _al_file_isok:

+ *  Helper function to check if it is safe to access a file on a floppy

+ *  drive. This really only applies to the DOS library, so we don't bother

+ *  with it.

+ */

+int _al_file_isok(const char *filename)

+{

+   return TRUE;

+}

+

+

+

+/* _al_file_exists:

+ *  Checks whether the specified file exists.

+ */

+int _al_file_exists(const char *filename, int attrib, int *aret)

+{

+   struct _finddata_t info;

+   long handle;

+

+   errno = 0;

+

+   if ((handle = _findfirst(filename, &info)) < 0) {

+      return FALSE;

+   }

+

+   _findclose(handle);

+

+   if (aret)

+      *aret = info.attrib;

+

+   info.attrib &= (FA_HIDDEN | FA_SYSTEM | FA_LABEL | FA_DIREC);

+

+   if ((info.attrib & attrib) != info.attrib)

+      return FALSE;

+

+   return TRUE;

+}

+

+

+

+/* _al_file_size:

+ *  Measures the size of the specified file.

+ */

+long _al_file_size(const char *filename)

+{

+   struct _finddata_t info;

+   long handle;

+

+   errno = 0;

+

+   if ((handle = _findfirst(filename, &info)) < 0) {

+      return 0;

+   }

+

+   _findclose(handle);

+

+   if (info.attrib & (FA_SYSTEM | FA_LABEL | FA_DIREC))

+      return 0;

+

+   return info.size;

+}

+

+

+

+/* _al_file_time:

+ *  Returns the timestamp of the specified file.

+ */

+time_t _al_file_time(const char *filename)

+{

+   struct _finddata_t info;

+   long handle;

+

+   errno = 0;

+

+   if ((handle = _findfirst(filename, &info)) < 0) {

+      return 0;

+   }

+

+   _findclose(handle);

+

+   if (info.attrib & (FA_SYSTEM | FA_LABEL | FA_DIREC))

+      return 0;

+

+   return info.time_write;

+}

+

+

+

+/* information structure for use by the directory scanning routines */

+typedef struct FFIND_INFO {

+   struct _finddata_t info;

+   long handle;

+   int attrib;

+} FFIND_INFO;

+

+

+

+/* _al_findfirst:

+ *  Initiates a directory search.

+ */

+void *_al_findfirst(const char *name, int attrib, char *nameret, int *aret)

+{

+   FFIND_INFO *info;

+   int a;

+

+   info = malloc(sizeof(FFIND_INFO));

+

+   if (!info) {

+      errno = ENOMEM;

+      return NULL;

+   }

+

+   info->attrib = attrib;

+

+   errno = 0;

+

+   if ((info->handle = _findfirst(name, &info->info)) < 0) {

+      free(info);

+      return NULL;

+   }

+

+   a = info->info.attrib & (FA_HIDDEN | FA_SYSTEM | FA_LABEL | FA_DIREC);

+

+   if ((a & attrib) != a) {

+      if (_al_findnext(info, nameret, aret) != 0) {

+	 _findclose(info->handle);

+	 free(info);

+	 return NULL;

+      }

+      else

+	 return info;

+   }

+

+   strcpy(nameret, info->info.name);

+

+   if (aret)

+      *aret = info->info.attrib;

+

+   return info;

+}

+

+

+

+/* _al_findnext:

+ *  Retrieves the next file from a directory search.

+ */

+int _al_findnext(void *dta, char *nameret, int *aret)

+{

+   FFIND_INFO *info = (FFIND_INFO *) dta;

+   int a;

+

+   do {

+      if (_findnext(info->handle, &info->info) != 0) {

+	 return -1;

+      }

+

+      a = info->info.attrib & (FA_HIDDEN | FA_SYSTEM | FA_LABEL | FA_DIREC);

+

+   } while ((a & info->attrib) != a);

+

+   strcpy(nameret, info->info.name);

+

+   if (aret)

+      *aret = info->info.attrib;

+

+   return 0;

+}

+

+

+

+/* _al_findclose:

+ *  Cleans up after a directory search.

+ */

+void _al_findclose(void *dta)

+{

+   FFIND_INFO *info = (FFIND_INFO *) dta;

+

+   _findclose(info->handle);

+   free(info);

+}

+

+

+

+/* _al_getdrive:

+ *  Returns the current drive number (0=A, 1=B, etc).

+ */

+int _al_getdrive()

+{

+   return _getdrive() - 1;

+}

+

+

+

+/* _al_getdcwd:

+ *  Returns the current directory on the specified drive.

+ */

+void _al_getdcwd(int drive, char *buf, int size)

+{

+   char tmp[256];

+

+   if (_getdcwd(drive+1, tmp, sizeof(tmp)))

+      strcpy(buf, tmp);

+   else

+      buf[0] = 0;

+}

+

diff --git a/plugins/dumb/dumb-kode54/winamp/out.h b/plugins/dumb/dumb-kode54/winamp/out.h
new file mode 100644
index 00000000..4dd42241
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/winamp/out.h
@@ -0,0 +1,71 @@
+/*  _______         ____    __         ___    ___

+ * \    _  \       \    /  \  /       \   \  /   /       '   '  '

+ *  |  | \  \       |  |    ||         |   \/   |         .      .

+ *  |  |  |  |      |  |    ||         ||\  /|  |

+ *  |  |  |  |      |  |    ||         || \/ |  |         '  '  '

+ *  |  |  |  |      |  |    ||         ||    |  |         .      .

+ *  |  |_/  /        \  \__//          ||    |  |

+ * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque

+ *                                                      /  \

+ *                                                     / .  \

+ * out.h - Winamp plug-in header file.                / / \  \

+ *                                                   | <  /   \_

+ * By Bob.                                           |  \/ /\   /

+ *                                                    \_  /  > /

+ *                                                      | \ / /

+ *                                                      |  ' /

+ *                                                       \__/

+ */

+

+#define OUT_VER 0x10

+

+typedef struct 

+{

+	int version;				// module version (OUT_VER)

+	char *description;			// description of module, with version string

+	int id;						// module id. each input module gets its own. non-nullsoft modules should

+								// be >= 65536. 

+

+	HWND hMainWindow;			// winamp's main window (filled in by winamp)

+	HINSTANCE hDllInstance;		// DLL instance handle (filled in by winamp)

+

+	void (*Config)(HWND hwndParent); // configuration dialog 

+	void (*About)(HWND hwndParent);  // about dialog

+

+	void (*Init)();				// called when loaded

+	void (*Quit)();				// called when unloaded

+

+	int (*Open)(int samplerate, int numchannels, int bitspersamp, int bufferlenms, int prebufferms); 

+					// returns >=0 on success, <0 on failure

+					// NOTENOTENOTE: bufferlenms and prebufferms are ignored in most if not all output plug-ins. 

+					//    ... so don't expect the max latency returned to be what you asked for.

+					// returns max latency in ms (0 for diskwriters, etc)

+					// bufferlenms and prebufferms must be in ms. 0 to use defaults. 

+					// prebufferms must be <= bufferlenms

+

+	void (*Close)();	// close the ol' output device.

+

+	int (*Write)(char *buf, int len);	

+					// 0 on success. Len == bytes to write (<= 8192 always). buf is straight audio data. 

+					// 1 returns not able to write (yet). Non-blocking, always.

+

+	int (*CanWrite)();	// returns number of bytes possible to write at a given time. 

+						// Never will decrease unless you call Write (or Close, heh)

+

+	int (*IsPlaying)(); // non0 if output is still going or if data in buffers waiting to be

+						// written (i.e. closing while IsPlaying() returns 1 would truncate the song

+

+	int (*Pause)(int pause); // returns previous pause state

+

+	void (*SetVolume)(int volume); // volume is 0-255

+	void (*SetPan)(int pan); // pan is -128 to 128

+

+	void (*Flush)(int t);	// flushes buffers and restarts output at time t (in ms) 

+							// (used for seeking)

+

+	int (*GetOutputTime)(); // returns played time in MS

+	int (*GetWrittenTime)(); // returns time written in MS (used for synching up vis stuff)

+

+} Out_Module;

+

+

diff --git a/plugins/dumb/dumb-kode54/winamp/resource.h b/plugins/dumb/dumb-kode54/winamp/resource.h
new file mode 100644
index 00000000..eee566da
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/winamp/resource.h
@@ -0,0 +1,36 @@
+//{{NO_DEPENDENCIES}}

+// Microsoft Developer Studio generated include file.

+// Used by config.rc

+//

+#define IDD_CONFIG                      102

+#define IDC_8BPS                        1000

+#define IDC_16BPS                       1001

+#define IDC_STEREO                      1002

+#define IDC_ALIASING                    1003

+#define IDC_LINEAR                      1004

+#define IDC_LINEAR_LOW_PASS             1005

+#define IDC_QUADRATIC                   1006

+#define IDC_CUBIC                       1007

+#define IDC_THREAD_PRI                  1008

+#define IDC_11KHZ                       1009

+#define IDC_22KHZ                       1010

+#define IDC_44KHZ                       1011

+#define IDC_48KHZ                       1012

+#define IDC_OK                          1013

+#define IDC_CANCEL                      1014

+#define IDC_BUFFERSIZE                  1015

+#define IDC_BUFFERSIZE2                 1016

+#define IDC_DEFAULT                     1017

+#define IDC_NICEST                      1018

+#define IDC_FASTEST                     1019

+

+// Next default values for new objects

+// 

+#ifdef APSTUDIO_INVOKED

+#ifndef APSTUDIO_READONLY_SYMBOLS

+#define _APS_NEXT_RESOURCE_VALUE        102

+#define _APS_NEXT_COMMAND_VALUE         40001

+#define _APS_NEXT_CONTROL_VALUE         1020

+#define _APS_NEXT_SYMED_VALUE           101

+#endif

+#endif

diff --git a/plugins/dumb/dumb-kode54/winamp/winamp.dsp b/plugins/dumb/dumb-kode54/winamp/winamp.dsp
new file mode 100644
index 00000000..25c82ab8
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/winamp/winamp.dsp
@@ -0,0 +1,141 @@
+# Microsoft Developer Studio Project File - Name="winamp" - Package Owner=<4>

+# Microsoft Developer Studio Generated Build File, Format Version 6.00

+# ** DO NOT EDIT **

+

+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102

+

+CFG=winamp - Win32 Debug

+!MESSAGE This is not a valid makefile. To build this project using NMAKE,

+!MESSAGE use the Export Makefile command and run

+!MESSAGE 

+!MESSAGE NMAKE /f "winamp.mak".

+!MESSAGE 

+!MESSAGE You can specify a configuration when running NMAKE

+!MESSAGE by defining the macro CFG on the command line. For example:

+!MESSAGE 

+!MESSAGE NMAKE /f "winamp.mak" CFG="winamp - Win32 Debug"

+!MESSAGE 

+!MESSAGE Possible choices for configuration are:

+!MESSAGE 

+!MESSAGE "winamp - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")

+!MESSAGE "winamp - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")

+!MESSAGE 

+

+# Begin Project

+# PROP AllowPerConfigDependencies 0

+# PROP Scc_ProjName ""

+# PROP Scc_LocalPath ""

+CPP=cl.exe

+MTL=midl.exe

+RSC=rc.exe

+

+!IF  "$(CFG)" == "winamp - Win32 Release"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 0

+# PROP BASE Output_Dir "Release"

+# PROP BASE Intermediate_Dir "Release"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 0

+# PROP Output_Dir ""

+# PROP Intermediate_Dir "Release"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "WINAMP_EXPORTS" /YX /FD /c

+# ADD CPP /nologo /G5 /MD /W3 /O2 /Ob2 /I "../include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "WINAMP_EXPORTS" /D "WINAMP_PLUGIN" /YX /FD /c

+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32

+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32

+# ADD BASE RSC /l 0x409 /d "NDEBUG"

+# ADD RSC /l 0x409 /d "NDEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib advapi32.lib dumb.lib /nologo /dll /machine:I386 /out:"in_duh.dll"

+# Begin Special Build Tool

+SOURCE="$(InputPath)"

+PostBuild_Desc=UPX

+PostBuild_Cmds=g:\tools\upx\upx --best in_duh.dll

+# End Special Build Tool

+

+!ELSEIF  "$(CFG)" == "winamp - Win32 Debug"

+

+# PROP BASE Use_MFC 0

+# PROP BASE Use_Debug_Libraries 1

+# PROP BASE Output_Dir "Debug"

+# PROP BASE Intermediate_Dir "Debug"

+# PROP BASE Target_Dir ""

+# PROP Use_MFC 0

+# PROP Use_Debug_Libraries 1

+# PROP Output_Dir ""

+# PROP Intermediate_Dir "Debug"

+# PROP Ignore_Export_Lib 0

+# PROP Target_Dir ""

+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "WINAMP_EXPORTS" /YX /FD /GZ /c

+# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "../include ." /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "WINAMP_EXPORTS" /D "WINAMP_PLUGIN" /YX /FD /GZ /c

+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32

+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32

+# ADD BASE RSC /l 0x409 /d "_DEBUG"

+# ADD RSC /l 0x409 /d "_DEBUG"

+BSC32=bscmake.exe

+# ADD BASE BSC32 /nologo

+# ADD BSC32 /nologo

+LINK32=link.exe

+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept

+# ADD LINK32 kernel32.lib user32.lib gdi32.lib advapi32.lib dumb.lib /nologo /dll /profile /debug /machine:I386 /out:"in_duh.dll"

+# SUBTRACT LINK32 /nodefaultlib

+

+!ENDIF 

+

+# Begin Target

+

+# Name "winamp - Win32 Release"

+# Name "winamp - Win32 Debug"

+# Begin Group "Source Files"

+

+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"

+# Begin Source File

+

+SOURCE=.\gui.c

+# End Source File

+# Begin Source File

+

+SOURCE=.\in_duh.c

+# End Source File

+# End Group

+# Begin Group "Header Files"

+

+# PROP Default_Filter "h;hpp;hxx;hm;inl"

+# Begin Source File

+

+SOURCE=..\include\dumb.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\gui.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\IN2.H

+# End Source File

+# Begin Source File

+

+SOURCE=.\in_duh.h

+# End Source File

+# Begin Source File

+

+SOURCE=.\OUT.H

+# End Source File

+# End Group

+# Begin Group "Resource Files"

+

+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"

+# Begin Source File

+

+SOURCE=.\config.rc

+# End Source File

+# End Group

+# End Target

+# End Project

diff --git a/plugins/dumb/dumb-kode54/winamp/winamp.dsw b/plugins/dumb/dumb-kode54/winamp/winamp.dsw
new file mode 100644
index 00000000..98a23156
--- /dev/null
+++ b/plugins/dumb/dumb-kode54/winamp/winamp.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00

+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!

+

+###############################################################################

+

+Project: "winamp"=.\winamp.dsp - Package Owner=<4>

+

+Package=<5>

+{{{

+}}}

+

+Package=<4>

+{{{

+}}}

+

+###############################################################################

+

+Global:

+

+Package=<5>

+{{{

+}}}

+

+Package=<3>

+{{{

+}}}

+

+###############################################################################

+