#include <vbf/vbf_util.h>

// to do:
// - read_line_*()

int
vbf_read_u64(vbf_t *vbf, int endianess, u64 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, (char*)val, sizeof(u64), &size) < 0)
	{
		return status;
	}

	if (size != sizeof(u64))
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		*val = ((*val & 0xff00000000000000) >> 56) +
			   ((*val & 0x00ff000000000000) >> 40) +
			   ((*val & 0x0000ff0000000000) >> 24) +
			   ((*val & 0x000000ff00000000) >>  8) +
			   ((*val & 0x00000000ff000000) <<  8) +
			   ((*val & 0x0000000000ff0000) << 24) +
			   ((*val & 0x000000000000ff00) << 40) +
			   ((*val & 0x00000000000000ff) << 56);
	}

	return 0;
}

int
vbf_read_i64(vbf_t *vbf, int endianess, i64 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(i64), &size) < 0)
	{
		return status;
	}

	if (size != sizeof(i64))
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		*val = ((*val & 0xff00000000000000) >> 56) +
			   ((*val & 0x00ff000000000000) >> 40) +
			   ((*val & 0x0000ff0000000000) >> 24) +
			   ((*val & 0x000000ff00000000) >>  8) +
			   ((*val & 0x00000000ff000000) <<  8) +
			   ((*val & 0x0000000000ff0000) << 24) +
			   ((*val & 0x000000000000ff00) << 40) +
			   ((*val & 0x00000000000000ff) << 56);
	}

	return 0;
}

int
vbf_read_u32(vbf_t *vbf, int endianess, u32 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(u32), &size) < 0)
	{
		return status;
	}

	if (size != sizeof(u32))
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		*val = ((*val & 0xff000000) >> 24) +
			   ((*val & 0x00ff0000) >>  8) +
			   ((*val & 0x0000ff00) <<  8) +
			   ((*val & 0x000000ff) << 24);
	}

	return 0;
}

int
vbf_read_i32(vbf_t *vbf, int endianess, i32 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(i32), &size) < 0)
	{
		return status;
	}

	if (size != sizeof(i32))
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		*val = ((*val & 0xff000000) >> 24) +
			   ((*val & 0x00ff0000) >>  8) +
			   ((*val & 0x0000ff00) <<  8) +
			   ((*val & 0x000000ff) << 24);
	}

	return 0;
}

int
vbf_read_u16(vbf_t *vbf, int endianess, u16 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(u16), &size) < 0)
	{
		return status;
	}

	if (size != sizeof(u16))
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		*val = ((*val & 0xff00) >> 8) +
			   ((*val & 0x00ff) << 8);
	}

	return 0;
}

int
vbf_read_i16(vbf_t *vbf, int endianess, i16 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(i16), &size) < 0)
	{
		return status;
	}

	if (size != sizeof(i16))
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		*val = ((*val & 0xff00) >> 8) +
			   ((*val & 0x00ff) << 8);
	}

	return 0;
}

int
vbf_read_u8(vbf_t *vbf, int endianess, u8 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(u8), &size) < 0)
	{
		return status;
	}

	if (size != sizeof(u8))
	{
		return VBF_ERR_GENERIC;
	}

	return 0;
}

int
vbf_read_i8(vbf_t *vbf, int endianess, i8 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(i8), &size) < 0)
	{
		return status;
	}

	if (size != sizeof(i8))
	{
		return VBF_ERR_GENERIC;
	}

	return 0;
}

int
vbf_read_float32(vbf_t *vbf, int endianess, float32 *val)
{
	return vbf_read_u32(vbf, endianess, (u32*)val);
}

int
vbf_read_float64(vbf_t *vbf, int endianess, float64 *val)
{
	return vbf_read_u64(vbf, endianess, (u64*)val);
}

int
vbf_read_array_u64(vbf_t *vbf, int endianess, int num, u64 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, (char*)val, sizeof(u64) * num, &size) < 0)
	{
		return status;
	}

	if ((unsigned int)size != sizeof(u64) * num)
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		while(num--)
		{
			*val = ((*val & 0xff00000000000000) >> 56) +
				   ((*val & 0x00ff000000000000) >> 40) +
				   ((*val & 0x0000ff0000000000) >> 24) +
				   ((*val & 0x000000ff00000000) >>  8) +
				   ((*val & 0x00000000ff000000) <<  8) +
				   ((*val & 0x0000000000ff0000) << 24) +
				   ((*val & 0x000000000000ff00) << 40) +
				   ((*val & 0x00000000000000ff) << 56);
			val++;
		}
	}

	return 0;
}

int
vbf_read_array_i64(vbf_t *vbf, int endianess, int num, i64 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(i64) * num, &size) < 0)
	{
		return status;
	}

	if ((unsigned int)size != sizeof(i64) * num)
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		while(num--)
		{
			*val = ((*val & 0xff00000000000000) >> 56) +
				   ((*val & 0x00ff000000000000) >> 40) +
				   ((*val & 0x0000ff0000000000) >> 24) +
				   ((*val & 0x000000ff00000000) >>  8) +
				   ((*val & 0x00000000ff000000) <<  8) +
				   ((*val & 0x0000000000ff0000) << 24) +
				   ((*val & 0x000000000000ff00) << 40) +
				   ((*val & 0x00000000000000ff) << 56);
			val++;
		}
	}

	return 0;
}

int
vbf_read_array_u32(vbf_t *vbf, int endianess, int num, u32 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(u32) * num, &size) < 0)
	{
		return status;
	}

	if ((unsigned int)size != sizeof(u32) * num)
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		while(num--)
		{
			*val = ((*val & 0xff000000) >> 24) +
				   ((*val & 0x00ff0000) >>  8) +
				   ((*val & 0x0000ff00) <<  8) +
				   ((*val & 0x000000ff) << 24);
			val++;
		}
	}

	return 0;
}

int
vbf_read_array_i32(vbf_t *vbf, int endianess, int num, i32 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(i32) * num, &size) < 0)
	{
		return status;
	}

	if ((unsigned int)size != sizeof(i32) * num)
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		while(num--)
		{
			*val = ((*val & 0xff000000) >> 24) +
				   ((*val & 0x00ff0000) >>  8) +
				   ((*val & 0x0000ff00) <<  8) +
				   ((*val & 0x000000ff) << 24);
			val++;
		}
	}

	return 0;
}

int
vbf_read_array_u16(vbf_t *vbf, int endianess, int num, u16 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(u16) * num, &size) < 0)
	{
		return status;
	}

	if ((unsigned int)size != sizeof(u16) * num)
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		while(num--)
		{
			*val = ((*val & 0xff00) >> 8) +
				   ((*val & 0x00ff) << 8);
			val++;
		}
	}

	return 0;
}

int
vbf_read_array_i16(vbf_t *vbf, int endianess, int num, i16 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(i16) * num, &size) < 0)
	{
		return status;
	}

	if ((unsigned int)size != sizeof(i16) * num)
	{
		return VBF_ERR_GENERIC;
	}

#ifdef SYS_SMALL_ENDIAN
	if (endianess == VBF_BIG_ENDIAN)
#else
	if (endianess == VBF_SMALL_ENDIAN)
#endif
	{
		while(num--)
		{
			*val = ((*val & 0xff00) >> 8) +
				   ((*val & 0x00ff) << 8);
		}
	}

	return 0;
}

int
vbf_read_array_u8(vbf_t *vbf, int endianess, int num, u8 *val)
{
	vbf_size_t size;
	int status;

	if (status = vbf_read(vbf, val, sizeof(u8) * num, &size) < 0)
	{
		return status;
	}

	if ((unsigned int)size != sizeof(u8) * num)
	{
		return VBF_ERR_GENERIC;
	}

	return 0;
}

int
vbf_read_array_i8(vbf_t *vbf, int endianess, int num, i8 *val)
{
	return vbf_read_array_u8(vbf, endianess, num, (u8*)val);
}

int
vbf_read_array_float32(vbf_t *vbf, int endianess, int num, float32 *val)
{
	return vbf_read_array_u32(vbf, endianess, num, (u32*)val);
}

int
vbf_read_array_float64(vbf_t *vbf, int endianess, int num, float64 *val)
{
	return vbf_read_array_u64(vbf, endianess, num, (u64*)val);
}

int
vbf_read_line_char(vbf_t *vbf, char *buf, int max, int *read)
{
	return VBF_ERR_GENERIC;
}

int
vbf_read_line_wide_char(vbf_t *vbf, int endianess, wide_char *buf, int max, int *read)
{
	return VBF_ERR_GENERIC;
}
 

#include <vbf/vbf.h>

/*

to do
-----

- equivalent of ungetc(...) ??

*/

static int vbf_raw_read(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size);
static int vbf_raw_write(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size);
static int vbf_raw_ioctl(struct vbf_s *vbf, int command, void *buffer, vbf_size_t size, vbf_size_t *out_size);
static int vbf_raw_seek_rel(struct vbf_s *vbf, vbf_size_t new_pos);
static int vbf_raw_close(struct vbf_s *vbf);

int
vbf_create(vbf_t *vbf)
{
	vbf->data   = 0;
	vbf->mode   = 0;
	vbf->length = 0;
	vbf->pos    = 0;

	vbf->raw_read     = vbf_raw_read;
	vbf->raw_write    = vbf_raw_write;
	vbf->raw_ioctl    = vbf_raw_ioctl;
	vbf->raw_seek_rel = vbf_raw_seek_rel;
	vbf->raw_close    = vbf_raw_close;

	return 0;
}

int
vbf_destroy(vbf_t *vbf)
{
	if (vbf->mode & VBF_ATTR_OPEN)
	{
		return vbf_close(vbf);
	}

	return 0;
}

int
vbf_seek_beg(vbf_t *vbf, vbf_size_t pos)
{
	vbf_size_t new_pos;

	if (vbf->mode & VBF_ATTR_OPEN == 0)
	{
		return VBF_ERR_NOT_OPEN;
	}

	if (vbf->mode & VBF_ATTR_SEEK == 0)
	{
		return VBF_ERR_NO_SEEK;
	}

	if (vbf->mode & VBF_ATTR_LENGTH == 0)
	{
		return VBF_ERR_NO_LENGTH;
	}

	if (pos < 0 || pos > vbf->length)
	{
		return VBF_ERR_BAD_POS;
	}

	new_pos = pos - vbf->pos;

	if (!new_pos)
	{
		return 0;
	}

	return vbf->raw_seek_rel(vbf, new_pos);
}

int
vbf_seek_cur(vbf_t *vbf, vbf_size_t pos)
{
	vbf_size_t abs_pos;

	if (vbf->mode & VBF_ATTR_OPEN == 0)
	{
		return VBF_ERR_NOT_OPEN;
	}

	if (vbf->mode & VBF_ATTR_SEEK == 0)
	{
		return VBF_ERR_NO_SEEK;
	}

	if (!pos)
	{
		return 0;
	}

	if (vbf->mode & VBF_ATTR_LENGTH)
	{
		abs_pos = pos + vbf->pos;

		if (abs_pos < 0 || abs_pos > vbf->length)
		{
			return VBF_ERR_BAD_POS;
		}
	}

	return vbf->raw_seek_rel(vbf, pos);
}

int
vbf_seek_end(vbf_t *vbf, vbf_size_t pos)
{
	return vbf_seek_beg(vbf, vbf->length + pos);
}

int
vbf_tell(vbf_t *vbf, vbf_size_t *pos)
{
	if (vbf->mode & VBF_ATTR_OPEN == 0)
	{
		return VBF_ERR_NOT_OPEN;
	}

	if (vbf->mode & VBF_ATTR_LENGTH == 0)
	{
		return VBF_ERR_NO_LENGTH;
	}

	*pos = vbf->pos;

	return 0;
}

int
vbf_size(vbf_t *vbf, vbf_size_t *size)
{
	if (vbf->mode & VBF_ATTR_OPEN == 0)
	{
		return VBF_ERR_NOT_OPEN;
	}
	
	if (vbf->mode & VBF_ATTR_LENGTH == 0)
	{
		return VBF_ERR_NO_LENGTH;
	}

	*size = vbf->length;

	return 0;
}

int
vbf_mode(vbf_t *vbf, int *mode)
{
	if (vbf->mode & VBF_ATTR_OPEN == 0)
	{
		return VBF_ERR_NOT_OPEN;
	}

	*mode = vbf->mode;

	return 0;
}

int
vbf_read(vbf_t *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	if (vbf->mode & VBF_ATTR_OPEN == 0)
	{
		return VBF_ERR_NOT_OPEN;
	}

	if (vbf->mode & VBF_ATTR_READ == 0)
	{
		return VBF_ERR_NO_READ;
	}

	if (vbf->mode & VBF_ATTR_LENGTH)
	{
		if (vbf->pos + size > vbf->length)
		{
			size = vbf->length - vbf->pos;
		}
	}

	return vbf->raw_read(vbf, buffer, size, out_size);
}

int
vbf_write(vbf_t *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	if (vbf->mode & VBF_ATTR_OPEN == 0)
	{
		return VBF_ERR_NOT_OPEN;
	}

	if (vbf->mode & VBF_ATTR_WRITE == 0)
	{
		return VBF_ERR_NO_WRITE;
	}

	if (vbf->mode & VBF_ATTR_LENGTH && !(vbf->mode & VBF_ATTR_APPEND))
	{
		if (vbf->pos + size > vbf->length)
		{
			size = vbf->length - vbf->pos;
		}
	}

	return vbf->raw_write(vbf, buffer, size, out_size);
}

int
vbf_ioctl(vbf_t *vbf, int command, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	if (vbf->mode & VBF_ATTR_OPEN == 0)
	{
		return VBF_ERR_NOT_OPEN;
	}

	return vbf->raw_ioctl(vbf, command, buffer, size, out_size);
}

int
vbf_close(vbf_t *vbf)
{
	if (vbf->mode & VBF_ATTR_OPEN == 0)
	{
		return VBF_ERR_NOT_OPEN;
	}

	return vbf->raw_close(vbf);
}

static int
vbf_raw_read(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	return VBF_ERR_GENERIC;
}

static int
vbf_raw_write(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	return VBF_ERR_GENERIC;
}

static int
vbf_raw_ioctl(struct vbf_s *vbf, int command, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	return VBF_ERR_GENERIC;
}

static int
vbf_raw_seek_rel(struct vbf_s *vbf, vbf_size_t new_pos)
{
	return VBF_ERR_GENERIC;
}

static int
vbf_raw_close(struct vbf_s *vbf)
{
	vbf->mode = 0;

	return 0;
}
 

#include <vbf/vbf_std.h>

/*

to do
-----

- detection of attributes

*/

static int vbf_std_raw_read(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size);
static int vbf_std_raw_write(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size);
static int vbf_std_raw_ioctl(struct vbf_s *vbf, int command, void *buffer, vbf_size_t size, vbf_size_t *out_size);
static int vbf_std_raw_seek_rel(struct vbf_s *vbf, vbf_size_t new_pos);
static int vbf_std_raw_close(struct vbf_s *vbf);

int
vbf_std_open(vbf_t *vbf, FILE *file)
{
	vbf_create(vbf);

	vbf->mode = VBF_ATTR_LENGTH | VBF_ATTR_SEEK |
				VBF_ATTR_OPEN   | VBF_ATTR_READ;

	vbf->data = file;

	fseek(file, 0, SEEK_END);
	vbf->length = ftell(file);
	fseek(file, 0, SEEK_SET);

	vbf->raw_read     = vbf_std_raw_read;
	vbf->raw_write    = vbf_std_raw_write;
	vbf->raw_ioctl    = vbf_std_raw_ioctl;
	vbf->raw_seek_rel = vbf_std_raw_seek_rel;
	vbf->raw_close    = vbf_std_raw_close;

	return 0;
}

static int
vbf_std_raw_read(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	if (!size)
	{
		return 0;
	}

	fread(buffer, size, 1, (FILE*)vbf->data);
	vbf->pos += size;

	if (out_size)
	{
		*out_size = size;
	}

	return 0;
}

static int
vbf_std_raw_write(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	return 0;
}

static int
vbf_std_raw_ioctl(struct vbf_s *vbf, int command, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	return VBF_ERR_GENERIC;
}

static int
vbf_std_raw_seek_rel(struct vbf_s *vbf, vbf_size_t new_pos)
{
	fseek((FILE*)vbf->data, new_pos, SEEK_CUR);
	vbf->pos += new_pos;

	return 0;
}

static int
vbf_std_raw_close(struct vbf_s *vbf)
{
	vbf->mode = 0;

	return 0;
}
 

#include <vbf/vbf_mem.h>

/*

to do
-----

- add support of all attributes

*/

static int vbf_mem_raw_read(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size);
static int vbf_mem_raw_write(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size);
static int vbf_mem_raw_ioctl(struct vbf_s *vbf, int command, void *buffer, vbf_size_t size, vbf_size_t *out_size);
static int vbf_mem_raw_seek_rel(struct vbf_s *vbf, vbf_size_t new_pos);
static int vbf_mem_raw_close(struct vbf_s *vbf);

static void __copy_memory__(char *src, char *dst, vbf_size_t size)
{
	while(size-- > 0)
	{
		*(dst++) = *(src++);
	}
}

int
vbf_mem_open(vbf_t *vbf, void *buffer, vbf_size_t size)
{
	vbf_create(vbf);

	vbf->mode = VBF_ATTR_LENGTH | VBF_ATTR_SEEK |
				VBF_ATTR_OPEN   | VBF_ATTR_READ;

	vbf->length = size;
	vbf->data = buffer;

	vbf->raw_read     = vbf_mem_raw_read;
	vbf->raw_write    = vbf_mem_raw_write;
	vbf->raw_ioctl    = vbf_mem_raw_ioctl;
	vbf->raw_seek_rel = vbf_mem_raw_seek_rel;
	vbf->raw_close    = vbf_mem_raw_close;

	return 0;
}

static int
vbf_mem_raw_read(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	__copy_memory__((char*)vbf->data + vbf->pos, (char*)buffer, size);
	vbf->pos += size;

	if (out_size)
	{
		*out_size = size;
	}

	return 0;
}

static int
vbf_mem_raw_write(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	return 0;
}

static int
vbf_mem_raw_ioctl(struct vbf_s *vbf, int command, void *buffer, vbf_size_t size, vbf_size_t *out_size)
{
	return VBF_ERR_GENERIC;
}

static int
vbf_mem_raw_seek_rel(struct vbf_s *vbf, vbf_size_t new_pos)
{
	vbf->pos += new_pos;

	return 0;
}

static int
vbf_mem_raw_close(struct vbf_s *vbf)
{
	vbf->mode = 0;

	return 0;
}
 

#include <mpl/biquad.h>
#include <math.h>

#define LN2O2 0.34657359027997265470861606072909

void
mpl__biquad_lp(mpl__biquad_coeff_t *biquad, float32 omega, float32 bandwidth)
{
	float64 sn, cs, al, a0, a1, a2, b0, b1, b2, ooa0;

	sn = sin(omega);
	cs = cos(omega);
	al = sn * sinh(LN2O2 * bandwidth * omega / sn);

	b0 = (1 - cs) * 0.5;
	b1 = 1 - cs;
	b2 = (1 - cs) * 0.5;
	a0 = 1 + al;
	a1 = -2 * cs;
	a2 = 1 - al;

	ooa0 = 1.0f / a0;

	biquad->a0 = b0 * ooa0;
	biquad->a1 = b1 * ooa0;
	biquad->a2 = b2 * ooa0;
	biquad->b1 = -a1 * ooa0;
	biquad->b2 = -a2 * ooa0;
}

void
mpl__biquad_bp(mpl__biquad_coeff_t *biquad, float32 omega, float32 bandwidth)
{
	float64 sn, cs, al, a0, a1, a2, b0, b1, b2, ooa0;

	sn = sin(omega);
	cs = cos(omega);
	al = sn * sinh(LN2O2 * bandwidth * omega / sn);

	b0 = al;
	b1 = 0;
	b2 = -al;
	a0 = 1 + al;
	a1 = -2 * cs;
	a2 = 1 - al;

	ooa0 = 1.0f / a0;

	biquad->a0 = b0 * ooa0;
	biquad->a1 = b1 * ooa0;
	biquad->a2 = b2 * ooa0;
	biquad->b1 = -a1 * ooa0;
	biquad->b2 = -a2 * ooa0;
}

void
mpl__biquad_hp(mpl__biquad_coeff_t *biquad, float32 omega, float32 bandwidth)
{
	float64 sn, cs, al, a0, a1, a2, b0, b1, b2, ooa0;

	sn = sin(omega);
	cs = cos(omega);
	al = sn * sinh(LN2O2 * bandwidth * omega / sn);

	b0 = (1 + cs) * 0.5;
	b1 = -(1 + cs);
	b2 = (1 + cs) * 0.5;
	a0 = 1 + al;
	a1 = -2 * cs;
	a2 = 1 - al;

	ooa0 = 1.0f / a0;

	biquad->a0 = b0 * ooa0;
	biquad->a1 = b1 * ooa0;
	biquad->a2 = b2 * ooa0;
	biquad->b1 = -a1 * ooa0;
	biquad->b2 = -a2 * ooa0;
}

void
mpl__biquad_no(mpl__biquad_coeff_t *biquad, float32 omega, float32 bandwidth)
{
	float64 sn, cs, al, a0, a1, a2, b0, b1, b2, ooa0;

	sn = sin(omega);
	cs = cos(omega);
	al = sn * sinh(LN2O2 * bandwidth * omega / sn);

	b0 = 1;
	b1 = -2 * cs;
	b2 = 1;
	a0 = 1 + al;
	a1 = b1;
	a2 = 1 - al;

	ooa0 = 1.0f / a0;

	biquad->a0 = b0 * ooa0;
	biquad->a1 = b1 * ooa0;
	biquad->a2 = b2 * ooa0;
	biquad->b1 = -a1 * ooa0;
	biquad->b2 = -a2 * ooa0;
}

void
mpl__biquad_peq(mpl__biquad_coeff_t *biquad, float32 omega, float32 bandwidth, float32 dbgain)
{
	float64 sn, cs, al, a, a0, a1, a2, b0, b1, b2, ooa, ooa0;

	sn = sin(omega);
	cs = cos(omega);
	a  = pow(10, dbgain * 0.025);
	ooa = 1.0 / a;
	al = sn * sinh(LN2O2 * bandwidth * omega / sn);

	b0 = 1 + al * a;
	b1 = -2 * cs;
	b2 = 1 - al * a;
	a0 = 1 + al * ooa;
	a1 = b1;
	a2 = 1 - al * ooa;

	ooa0 = 1.0f / a0;

	biquad->a0 = b0 * ooa0;
	biquad->a1 = b1 * ooa0;
	biquad->a2 = b2 * ooa0;
	biquad->b1 = -a1 * ooa0;
	biquad->b2 = -a2 * ooa0;
}

void
mpl__biquad_ls(mpl__biquad_coeff_t *biquad, float32 omega, float32 dbgain, float32 slope)
{
	float64 sn, cs, be, a, a0, a1, a2, b0, b1, b2, ooa0, ap1, am1;

	sn  = sin(omega);
	cs  = cos(omega);
	a   = pow(10, dbgain * 0.025);
	ap1 = a + 1;
	am1 = a - 1;
	be  = sqrt((a * a + 1) / slope - am1 * am1);

	b0 = a * (ap1 - am1 * cs + be * sn);
	b1 = 2* a * (am1 - ap1 * cs);
	b2 = a * (ap1 - am1 * cs - be * sn);
	a0 = ap1 + am1 * cs + be * sn;
	a1 = -2 * (am1 + ap1 * cs);
	a2 = ap1 + am1 * cs - be * sn;

	ooa0 = 1.0f / a0;

	biquad->a0 = b0 * ooa0;
	biquad->a1 = b1 * ooa0;
	biquad->a2 = b2 * ooa0;
	biquad->b1 = -a1 * ooa0;
	biquad->b2 = -a2 * ooa0;
}

void
mpl__biquad_hs(mpl__biquad_coeff_t *biquad, float32 omega, float32 dbgain, float32 slope)
{
	float64 sn, cs, be, a, a0, a1, a2, b0, b1, b2, ooa0, ap1, am1;

	sn  = sin(omega);
	cs  = cos(omega);
	a   = pow(10, dbgain * 0.025);
	ap1 = a + 1;
	am1 = a - 1;
	be  = sqrt((a * a + 1) / slope - am1 * am1);

	b0 = a * (ap1 + am1 * cs + be * sn);
	b1 = -2 * a * (am1 + ap1 * cs);
	b2 = a * (ap1 + am1 * cs - be * sn);
	a0 = ap1 - am1 * cs + be * sn;
	a1 = 2 * (am1 - ap1 * cs);
	a2 = ap1 - am1 * cs - be * sn;

	ooa0 = 1.0f / a0;

	biquad->a0 = b0 * ooa0;
	biquad->a1 = b1 * ooa0;
	biquad->a2 = b2 * ooa0;
	biquad->b1 = -a1 * ooa0;
	biquad->b2 = -a2 * ooa0;
}
 

#include <mpl/snddev.h>

// dev

int
mpl__snd_dev_set_vol(mpl__snd_dev_t *dev, float32 vol, float32 pan_lr, float32 pan_fb)
{
	return dev->set_vol(dev->internal_data, vol, pan_lr, pan_fb);
}

int
mpl__snd_dev_get_vol(mpl__snd_dev_t *dev, float32 *vol, float32 *pan_lr, float32 *pan_fb)
{
	return dev->get_vol(dev->internal_data, vol, pan_lr, pan_fb);
}

int
mpl__snd_dev_set_output_options(mpl__snd_dev_t *dev, mpl__snd_dev_output_t opt)
{
	return dev->set_output_options(dev->internal_data, opt);
}

int
mpl__snd_dev_get_output_options(mpl__snd_dev_t *dev, mpl__snd_dev_output_t *opt)
{
	return dev->get_output_options(dev->internal_data, opt);
}

int
mpl__snd_dev_set_latency(mpl__snd_dev_t *dev, int latency)
{
	return dev->set_latency(dev->internal_data, latency);
}

int
mpl__snd_dev_get_latency(mpl__snd_dev_t *dev)
{
	return dev->get_latency(dev->internal_data);
}

int
mpl__snd_dev_set_option(mpl__snd_dev_t *dev, char *option, char *value)
{
	return dev->set_option(dev->internal_data, option, value);
}

int
mpl__snd_dev_get_option(mpl__snd_dev_t *dev, char *option, char **value)
{
	return dev->get_option(dev->internal_data, option, value);
}

int
mpl__snd_dev_get_proc(mpl__snd_dev_t *dev, char *name, void_func_t *proc)
{
	return dev->get_proc(dev->internal_data, name, proc);
}

int
mpl__snd_dev_create_mixer(mpl__snd_dev_t *dev, mpl__snd_mixer_t **mixer, mpl__snd_mixer_opt_t opt)
{
	return dev->create_mixer(dev->internal_data, mixer, opt);
}

int
mpl__snd_dev_destroy_mixer(mpl__snd_dev_t *dev, mpl__snd_mixer_t *mixer)
{
	return dev->destroy_mixer(dev->internal_data, mixer);
}

int
mpl__snd_dev_create_stream(mpl__snd_dev_t *dev, mpl__snd_stream_t **stream, mpl__snd_stream_opt_t opt)
{
	return dev->create_stream(dev->internal_data, stream, opt);
}

int
mpl__snd_dev_destroy_stream(mpl__snd_dev_t *dev, mpl__snd_stream_t *stream)
{
	return dev->destroy_stream(dev->internal_data, stream);
}

// mixer

int
mpl__snd_mixer_reset(mpl__snd_mixer_t *mixer)
{
	return mixer->reset(mixer->internal_data);
}

int
mpl__snd_mixer_pause(mpl__snd_mixer_t *mixer)
{
	return mixer->pause(mixer->internal_data);
}

int
mpl__snd_mixer_stop(mpl__snd_mixer_t *mixer)
{
	return mixer->stop(mixer->internal_data);
}

int
mpl__snd_mixer_upload_sample(mpl__snd_mixer_t *mixer, mpl__snd_mixer_smp_t sample)
{
	return mixer->upload_sample(mixer->internal_data, sample);
}

int
mpl__snd_mixer_destroy_sample(mpl__snd_mixer_t *mixer, int handle)
{
	return mixer->destroy_sample(mixer->internal_data, handle);
}

int
mpl__snd_mixer_set_vol(mpl__snd_mixer_t *mixer, float32 vol, float32 pan_lr, float32 pan_fb)
{
 	return mixer->set_vol(mixer->internal_data, vol, pan_lr, pan_fb);
}

int
mpl__snd_mixer_get_vol(mpl__snd_mixer_t *mixer, float32 *vol, float32 *pan_lr, float32 *pan_fb)
{
	return mixer->get_vol(mixer->internal_data, vol, pan_lr, pan_fb);
}

int
mpl__snd_mixer_get_output_options(mpl__snd_mixer_t *mixer, mpl__snd_dev_output_t *opt)
{
	return mixer->get_output_options(mixer->internal_data, opt);
}

int
mpl__snd_mixer_get_latency(mpl__snd_mixer_t *mixer)
{
	return mixer->get_latency(mixer->internal_data);
}

int
mpl__snd_mixer_get_num_channels(mpl__snd_mixer_t *mixer)
{
	return mixer->get_num_channels(mixer->internal_data);
}

int
mpl__snd_mixer_get_num_active_channels(mpl__snd_mixer_t *mixer)
{
	return mixer->get_num_active_channels(mixer->internal_data);
}

int
mpl__snd_mixer_get_free_channel(mpl__snd_mixer_t *mixer)
{
	return mixer->get_free_channel(mixer->internal_data);
}

int
mpl__snd_mixer_is_channel_active(mpl__snd_mixer_t *mixer, int ch)
{
	return mixer->is_channel_active(mixer->internal_data, ch);
}

int
mpl__snd_mixer_set_channel_vol(mpl__snd_mixer_t *mixer, int ch, float32 vol, float32 pan_lr, float32 pan_fb)
{
	return mixer->set_channel_vol(mixer->internal_data, ch, vol, pan_lr, pan_fb);
}

int
mpl__snd_mixer_set_channel_freq(mpl__snd_mixer_t *mixer, int ch, float freq)
{
	return mixer->set_channel_freq(mixer->internal_data, ch, freq);
}

int
mpl__snd_mixer_set_channel_pos(mpl__snd_mixer_t *mixer, int ch, double pos, int dir)
{
	return mixer->set_channel_pos(mixer->internal_data, ch, pos, dir);
}

int
mpl__snd_mixer_play_channel(mpl__snd_mixer_t *mixer, int ch, int handle, float32 freq, float32 vol, float32 pan_lr, float32 pan_fb, float64 pos, int dir)
{
	return mixer->play_channel(mixer->internal_data, ch, handle, freq, vol, pan_lr, pan_fb, pos, dir);
}

int
mpl__snd_mixer_stop_channel(mpl__snd_mixer_t *mixer, int ch)
{
	return mixer->stop_channel(mixer->internal_data, ch);
}

int
mpl__snd_mixer_set_option(mpl__snd_mixer_t *mixer, char *option, char *value)
{
	return mixer->set_option(mixer->internal_data, option, value);
}

int
mpl__snd_mixer_get_option(mpl__snd_mixer_t *mixer, char *option, char **value)
{
	return mixer->get_option(mixer->internal_data, option, value);
}

int
mpl__snd_mixer_get_proc(mpl__snd_mixer_t *mixer, char *name, void_func_t *proc)
{
	return mixer->get_proc(mixer->internal_data, name, proc);
}

int
mpl__snd_mixer_set_call_back(mpl__snd_mixer_t *mixer, mpl__snd_call_back_t call_back)
{
	return mixer->set_call_back(mixer->internal_data, call_back);
}

// stream

int
mpl__snd_stream_set_vol(mpl__snd_stream_t *stream, float32 vol, float32 pan_lr, float32 pan_fb)
{
	return stream->set_vol(stream->internal_data, vol, pan_lr, pan_fb);
}

int
mpl__snd_stream_get_vol(mpl__snd_stream_t *stream, float32 *vol, float32 *pan_lr, float32 *pan_fb)
{
	return stream->get_vol(stream->internal_data, vol, pan_lr, pan_fb);
}

int
mpl__snd_stream_get_output_options(mpl__snd_stream_t *stream, mpl__snd_dev_output_t *opt)
{
	return stream->get_output_options(stream->internal_data, opt);
}

int
mpl__snd_stream_set_input_format(mpl__snd_stream_t *stream, mpl__snd_stream_format_t *opt)
{
	return stream->set_input_format(stream->internal_data, opt);
}

int
mpl__snd_stream_get_input_format(mpl__snd_stream_t *stream, mpl__snd_stream_format_t *opt)
{
	return stream->get_input_format(stream->internal_data, opt);
}

int
mpl__snd_stream_get_latency(mpl__snd_stream_t *stream)
{
	return stream->get_latency(stream->internal_data);
}

int
mpl__snd_stream_get_buffer_size(mpl__snd_stream_t *stream)
{
	return stream->get_buffer_size(stream->internal_data);
}

int
mpl__snd_stream_set_option(mpl__snd_stream_t *stream, char *option, char *value)
{
	return stream->set_option(stream->internal_data, option, value);
}

int
mpl__snd_stream_get_option(mpl__snd_stream_t *stream, char *option, char **value)
{
	return stream->get_option(stream->internal_data, option, value);
}

int
mpl__snd_stream_get_proc(mpl__snd_stream_t *stream, char *name, void_func_t *proc)
{
	return stream->get_proc(stream->internal_data, name, proc);
}

int
mpl__snd_stream_write(mpl__snd_stream_t *stream, void *data, int length)
{
	return stream->write(stream->internal_data, data, length);
}

int
mpl__snd_stream_set_call_back(mpl__snd_stream_t *stream, mpl__snd_call_back_t call_back)
{
	return stream->set_call_back(stream->internal_data, call_back);
}
 

#include <mpl/ml.h>

int
mpl__ml_load(mpl__ml_t *ml, vbf_t *file, mpl__md_t **md)
{
	return ml->load(ml->internal_data, file, md);
}

int
mpl__ml_destroy(mpl__ml_t *ml, mpl__md_t *md)
{
	return ml->destroy(ml->internal_data, md);
}

int
mpl__ml_create_mp(mpl__ml_t *ml, mpl__md_t *md, mpl__msg_box_t *mb, mpl__mp_t **mp)
{
	return ml->create_mp(ml->internal_data, md, mb, mp);
}

int
mpl__ml_destroy_mp(mpl__ml_t *ml, mpl__mp_t **mp)
{
	return ml->destroy_mp(ml->internal_data, mp);
}

int
mpl__ml_set_option(mpl__ml_t *ml, char *option, char *value)
{
	return ml->set_option(ml->internal_data, option, value);
}

int
mpl__ml_get_option(mpl__ml_t *ml, char *option, char **value)
{
	return ml->get_option(ml->internal_data, option, value);
}

int
mpl__ml_get_proc(mpl__ml_t *ml, char *name, void_func_t *proc)
{
	return ml->get_proc(ml->internal_data, name, proc);
}
 

#include <mpl/mp.h>

int
mpl__mp_set_dev(mpl__mp_t *mp, mpl__snd_dev_t *dev)
{
	return mp->set_dev(mp->internal_data, dev);
}

int
mpl__mp_reset(mpl__mp_t *mp)
{
	return mp->reset(mp->internal_data);
}

int
mpl__mp_play(mpl__mp_t *mp)
{
	return mp->play(mp->internal_data);
}

int
mpl__mp_stop(mpl__mp_t *mp)
{
	return mp->stop(mp->internal_data);
}

int
mpl__mp_set_loop(mpl__mp_t *mp, int loop)
{
	return mp->set_loop(mp->internal_data, loop);
}

int
mpl__mp_set_pos(mpl__mp_t *mp, int pos)
{
	return mp->set_pos(mp->internal_data, pos);
}

int
mpl__mp_get_pos(mpl__mp_t *mp)
{
	return mp->get_pos(mp->internal_data);
}

int
mpl__mp_set_vol(mpl__mp_t *mp, float32 vol)
{
	return mp->set_vol(mp->internal_data, vol);
}

int
mpl__mp_get_vol(mpl__mp_t *mp, float32 *vol)
{
	return mp->get_vol(mp->internal_data, vol);
}

int
mpl__mp_set_option(mpl__mp_t *mp, char *option, char *value)
{
	return mp->set_option(mp->internal_data, option, value);
}

int
mpl__mp_get_option(mpl__mp_t *mp, char *option, char **value)
{
	return mp->get_option(mp->internal_data, option, value);
}

int
mpl__mp_get_proc(mpl__mp_t *mp, char *name, void_func_t *proc)
{
	return mp->get_proc(mp->internal_data, name, proc);
}
 

#include <mpl/mx.h>

int
mpl__mixer_set_output_options(mpl__mixer_t *mx, mpl__snd_dev_output_t *opt, int latency)
{
	return mx->set_output_options(mx->internal_data, opt, latency);
}

int
mpl__mixer_set_options(mpl__mixer_t *mx, mpl__mixer_opt_t *opt)
{
	return mx->set_options(mx->internal_data, opt);
}

int
mpl__mixer_get_options(mpl__mixer_t *mx, mpl__mixer_opt_t *opt)
{
	return mx->get_options(mx->internal_data, opt);
}

int
mpl__mixer_get_proc(mpl__mixer_t *mx, char *name, void_func_t *func)
{
	return mx->get_proc(mx->internal_data, name, func);
}

int 
mpl__mixer_get_interface(mpl__mixer_t *mx, mpl__snd_mixer_t **mixer)
{
	return mx->get_interface(mx->internal_data, mixer);
}

int
mpl__mixer_set_vol(mpl__mixer_t *mx, float32 vol, float32 pan_lr, float32 pan_fb)
{
	return mx->set_vol(mx->internal_data, vol, pan_lr, pan_fb);
}

int
mpl__mixer_mix(mpl__mixer_t *mx, void *buffer, int length)
{
	return mx->mix(mx->internal_data, buffer, length);
}

int
mpl__mixer_get_num_active_channels(mpl__mixer_t *mx)
{
	return mx->get_num_active_channels(mx->internal_data);
}
 

#include <mpl/dsp_std.h>
#include <mpl/sys/mem.h>

/*
	to do
	-----

    - optimize (especially 24 bit adding)
	- dsp_convert_format() -> 24_bit
    - dsp_resample()
*/

int
mpl__dsp_add(void *src, void *dst, int size, int ch_num, float32 vol, int format)
{
	int num;

	num = size * ch_num;

	switch(format)
	{
	case MPL__SND_DEV_FMT_8BIT:
		while(num--)
		{
			((i8*)dst)[num] += (i8) (((i8*)src)[num] * vol);
		}
		break;
	case MPL__SND_DEV_FMT_16BIT:
		while(num--)
		{
			((i16*)dst)[num] += (i16) (((i16*)src)[num] * vol);
		}
		break;
	case MPL__SND_DEV_FMT_24BIT:
		while(num--)
		{
//			*((i32*)dst) = ((*((i32*)dst) & 0xffffff) + (i32)((*((i32*)src) & 0xffffff) * vol)) & 0xffffff;

//			((i8*)src) += 3;
//			((i8*)dst) += 3;
		}
		break;
	case MPL__SND_DEV_FMT_32BIT:
		while(num--)
		{
			((i32*)dst)[num] += (i32) (((i32*)src)[num] * vol);
		}
		break;
	case MPL__SND_DEV_FMT_FLOAT_32BIT:
		while(num--)
		{
			((float32*)dst)[num] += ((float32*)src)[num] * vol;
		}
		break;
	default:
		return -1;
	}

	return 0;
}

int
mpl__dsp_sub(void *src, void *dst, int size, int ch_num, float32 vol, int format)
{
	return mpl__dsp_add(src, dst, size, ch_num, -vol, format);
}

int
mpl__dsp_move(void *src, void *dst, int size, int ch_num, float32 vol, int format)
{
	switch(format)
	{
	case MPL__SND_DEV_FMT_8BIT:
		break;
	case MPL__SND_DEV_FMT_16BIT:
		size *= 2;
		break;
	case MPL__SND_DEV_FMT_24BIT:
		size *= 3;
		break;
	case MPL__SND_DEV_FMT_32BIT:
		size *= 4;
		break;
	case MPL__SND_DEV_FMT_FLOAT_32BIT:
		size *= 4;
		break;
	default:
		return -1;
	}

	size *= ch_num;

	mpl__mem_copy(src, dst, size);

	return 0;
}

int
mpl__dsp_conv_format(void *src, void *dst, int src_format, int dst_format, int size, int ch_num, float32 vol)
{
	float32 *buf;
    int cnt;
 
    if (dst_format != MPL__SND_DEV_FMT_FLOAT_32BIT)
    {
        if (mpl__mem_alloc(4 * size * ch_num, (void**)&buf) < MPL__ERR_OK)
        {
             return MPL__ERR_NOMEM;
        }
    }
    else
    {
        buf = (float32*) dst;
    }

    cnt = size * ch_num;

	switch(src_format)
	{
	case MPL__SND_DEV_FMT_8BIT:
        vol *= 1.0f / 256.0f;
		while(cnt--)
		{
			buf[cnt] = ((i8*)src)[cnt] * vol;
		}
		break;
	case MPL__SND_DEV_FMT_16BIT:
        vol *= 1.0f / 65536.0f;
		while(cnt--)
		{
			buf[cnt] = ((i16*)src)[cnt] * vol;
		}
		break;
	case MPL__SND_DEV_FMT_24BIT:
/*        vol *= 1.0f / 16777216.0f;
		while(cnt--)
		{
			buf[cnt] = (((i32*)src)[cnt] & 0xffffff) * vol;

			((i8*)src) += 3;
		}*/
		break;
	case MPL__SND_DEV_FMT_32BIT:
        vol *= 1.0f / 4294967296.0f;
		while(cnt--)
		{
			buf[cnt] = ((i32*)src)[cnt] * vol;
		}
		break;
	case MPL__SND_DEV_FMT_FLOAT_32BIT:
		while(cnt--)
		{
			buf[cnt] = ((float32*)src)[cnt] * vol;
		}
		break;
	}

    if (dst_format == MPL__SND_DEV_FMT_FLOAT_32BIT)
    {
        return MPL__ERR_OK;
    }

    cnt = size * ch_num;

	switch(dst_format)
	{
	case MPL__SND_DEV_FMT_8BIT:
        vol = 256.0f;
		while(cnt--)
		{
			((i8*)dst)[cnt] = (i8)(buf[cnt] * vol);
		}
		break;
	case MPL__SND_DEV_FMT_16BIT:
        vol = 65536.0f;
		while(cnt--)
		{
			((i16*)dst)[cnt] = (i16)(buf[cnt] * vol);
		}
		break;
	case MPL__SND_DEV_FMT_24BIT:
        vol = 16777216.0f;
		while(cnt--)
		{
            // how to implement it portable?!?
		}
		break;
	case MPL__SND_DEV_FMT_32BIT:
        vol = 4294967296.0f;
		while(cnt--)
		{
			((i32*)dst)[cnt] = (i32)(buf[cnt] * vol);
		}
		break;
	}

	mpl__mem_free(buf);

	return MPL__ERR_OK;
}
 

#include <mpl/string.h>

int
mpl__string_cmp_char(char *str1, char *str2)
{
	while(*str2 != '\0' && *str1 == *str2)
	{
		str1++;
		str2++;
	}

	if (*str1 == *str2)
	{
		return MPL__STRING_EQUAL;
	}

	return MPL__STRING_UNEQUAL;
}

int
mpl__string_cmp_wide_char(wide_char *str1, wide_char *str2)
{
	while(*str2 != '\0' && *str1 == *str2)
	{
		str1++;
		str2++;
	}

	if (*str1 == *str2)
	{
		return MPL__STRING_EQUAL;
	}

	return MPL__STRING_UNEQUAL;
}
 

#include <mpl/sd_std.h>
#include <mpl/sys/mem.h>

static int cmd_set_vol(void *data, float32 vol, float32 pan_lr, float32 pan_fb);
static int cmd_get_vol(void *data, float32 *vol, float32 *pan_lr, float32 *pan_fb);
static int cmd_set_output_options(void *data, mpl__snd_dev_output_t opt);
static int cmd_get_output_options(void *data, mpl__snd_dev_output_t *opt);
static int cmd_set_latency(void *data, int latency);
static int cmd_get_latency(void *data);
static int cmd_set_option(void *data, char *option, char *value);
static int cmd_get_option(void *data, char *option, char **value);
static int cmd_get_proc(void *data, char *name, void_func_t *proc);
static int cmd_create_mixer(void *data, mpl__snd_mixer_t **mixer, mpl__snd_mixer_opt_t opt);
static int cmd_destroy_mixer(void *data, mpl__snd_mixer_t *mixer);
static int cmd_create_stream(void *data, mpl__snd_stream_t **stream, mpl__snd_stream_opt_t opt);
static int cmd_destroy_stream(void *data, mpl__snd_stream_t *stream);

static int
cmd_set_vol(void *data, float32 vol, float32 pan_lr, float32 pan_fb)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_get_vol(void *data, float32 *vol, float32 *pan_lr, float32 *pan_fb)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_set_output_options(void *data, mpl__snd_dev_output_t opt)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_get_output_options(void *data, mpl__snd_dev_output_t *opt)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_set_latency(void *data, int latency)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_get_latency(void *data)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_set_option(void *data, char *option, char *value)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_get_option(void *data, char *option, char **value)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_get_proc(void *data, char *name, void_func_t *proc)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_create_mixer(void *data, mpl__snd_mixer_t **mixer, mpl__snd_mixer_opt_t opt)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_destroy_mixer(void *data, mpl__snd_mixer_t *mixer)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_create_stream(void *data, mpl__snd_stream_t **stream, mpl__snd_stream_opt_t opt)
{
	return MPL__ERR_GENERIC;
}

static int
cmd_destroy_stream(void *data, mpl__snd_stream_t *stream)
{
	return MPL__ERR_GENERIC;
}

int
mpl__sd_std_create(mpl__snd_dev_t **sd, int  (*mx_create)(mpl__mixer_t **mixer), void (*mx_destroy)(mpl__mixer_t *mixer))
{
	int result;

	result = mpl__mem_alloc(sizeof(mpl__snd_dev_t), (void**)sd);

	if (result < MPL__ERR_OK)
	{
		return result;
	}

	(*sd)->create_mixer       = cmd_create_mixer;
	(*sd)->create_stream      = cmd_create_stream;
	(*sd)->destroy_mixer      = cmd_destroy_mixer;
	(*sd)->destroy_stream     = cmd_destroy_stream;
	(*sd)->get_latency        = cmd_get_latency;
	(*sd)->get_option         = cmd_get_option;
	(*sd)->get_output_options = cmd_get_output_options;
	(*sd)->get_proc           = cmd_get_proc;
	(*sd)->get_vol            = cmd_get_vol;
	(*sd)->set_latency        = cmd_set_latency;
	(*sd)->set_option         = cmd_set_option;
	(*sd)->set_output_options = cmd_set_output_options;
	(*sd)->set_vol            = cmd_set_vol;

	return MPL__ERR_GENERIC;
}

void
mpl__sd_std_destroy(mpl__snd_dev_t *sd)
{
}
 

#include <mpl/sys/mem.h>
#include <mpl/ml_xm.h>

static int
clip_to(int value, int min, int max)
{
	if (value < min)
	{
		return min;
	}

	if (value > max)
	{
		return max;
	}

	return value;
}

int
mpl__xm_destruct(mpl__xm_t *xm)
{
	int cnt1, cnt2;

	if (xm)
	{
		if (xm->inst)
		{
			for(cnt1 = 0; cnt1 < xm->inst_num; cnt1++)
			{
				if (xm->inst[cnt1].smp_num)
				{
					for(cnt2 = 0; cnt2 < xm->inst[cnt1].smp_num; cnt2++)
					{
						if (xm->inst[cnt1].smp[cnt2].data)
						{
							mpl__mem_free(xm->inst[cnt1].smp[cnt2].data);
						}
					}

					mpl__mem_free(xm->inst[cnt1].smp);
				}
			}

			mpl__mem_free(xm->inst);
		}

		if (xm->pat_num)
		{
			for(cnt1 = 0; cnt1 < xm->pat_num; cnt1++)
			{
				if (xm->pat[cnt1])
				{
					mpl__mem_free(xm->pat[cnt1]);
				}
			}
		}
	}

	return 0;
}

#define return_false(err) { mpl__xm_destruct(xm); return err; }
#define seek_to(a)	{if (vbf_seek_beg(file, a) < 0) return_false(MPL__ERR_GENERIC);}
#define read_i8() {if (vbf_read_i8(file, VBF_SMALL_ENDIAN, &tmp_i8) < 0) return_false(MPL__ERR_GENERIC);}
#define read_u8() {if (vbf_read_u8(file, VBF_SMALL_ENDIAN, &tmp_u8) < 0) return_false(MPL__ERR_GENERIC);}
#define read_u16() {if (vbf_read_u16(file, VBF_SMALL_ENDIAN, &tmp_u16) < 0) return_false(MPL__ERR_GENERIC);}
#define read_u32() {if (vbf_read_u32(file, VBF_SMALL_ENDIAN, &tmp_u32) < 0) return_false(MPL__ERR_GENERIC);}

int
mpl__xm_load(vbf_t *file, mpl__xm_t *xm)
{
	int mode, attr;
	u8 ID[] = "Extended Module: ", raw[32], tmp_u8;
	i8 tmp_i8;
	u16 tmp_u16;
	u32 tmp_u32;
	vbf_size_t tmp_size, pos;
	u32 h_size, packed_pat_size, ctrl, smp_index;
	i32 cnt1, cnt2, cnt3;
	mpl__xm_sample_t *smp;
	mpl__xm_inst_t *inst;

	if (vbf_mode(file, &mode) < 0)
	{
		return MPL__ERR_GENERIC;
	}

	attr = VBF_ATTR_OPEN | VBF_ATTR_READ | VBF_ATTR_LENGTH | VBF_ATTR_SEEK;

	if ((mode & attr) != attr)
	{
		return MPL__ERR_GENERIC;
	}
	
	mpl__mem_set_zero(xm, sizeof(mpl__xm_t));

	seek_to(0);

	if (vbf_read(file, raw, 17, &tmp_size) < 0 || tmp_size < 17)
	{
		return MPL__ERR_GENERIC;
	}

	for(cnt1 = 0; cnt1 < 17; cnt1++)
	{
		if (raw[cnt1] != ID[cnt1])
		{
			return MPL__ERR_GENERIC;
		}
	}

	seek_to(37);

	read_u8();

	if (tmp_u8 != 0x1A)
	{
		return_false(MPL__ERR_GENERIC);
	}

//	to do
//	if (vbf_read_u16(vbf, VBF_SMALL_ENDIAN, tmp_u16) < 0 || tmp_u16 != 0x104)
//	{
//		return_false;
//	}

	seek_to(17);

	if (vbf_read(file, xm->title, 20, &tmp_size) < 0 || tmp_size < 20)
	{
		return_false(MPL__ERR_GENERIC);
	}

	xm->title[20] = 0;

	if (vbf_seek_beg(file, 38) < 0)
	{
		return_false(MPL__ERR_GENERIC);
	}

	if (vbf_read(file, xm->tracker, 20, &tmp_size) < 0 || tmp_size < 20)
	{
		return_false(MPL__ERR_GENERIC);
	}

	xm->tracker[20] = 0;

	seek_to(60);
	read_u32();
	h_size = tmp_u32;

	read_u16();
	xm->length      = tmp_u16;
	read_u16();
	xm->restart_pos = tmp_u16;
	read_u16();
	xm->ch_num      = tmp_u16;
	read_u16();
	xm->pat_num     = tmp_u16;
	read_u16();
	xm->inst_num    = tmp_u16;
	read_u8();
	xm->freq_table  = tmp_u8 & 1;
	read_u8();
	read_u16();
	xm->speed       = tmp_u16;
	read_u16();
	xm->bpm         = tmp_u16;

	seek_to(80);

	for(cnt1 = 0; cnt1 < 256; cnt1++)
	{
		read_u8();
		xm->order[cnt1] = tmp_u8;
	}

	pos = 60 + h_size;
	seek_to(pos);

	for(cnt1 = 0; cnt1 < xm->pat_num; cnt1++)
	{
		read_u32();
		h_size = tmp_u32;
		read_u8();
		read_u16();
		xm->pat_length[cnt1] = tmp_u16;
		read_u16();
		packed_pat_size = tmp_u16;

		if (mpl__mem_alloc(xm->pat_length[cnt1] * xm->ch_num * sizeof(mpl__xm_cell_t),
			(void**)&xm->pat[cnt1]) <= MPL__ERR_GENERIC)
		{
			return_false(MPL__ERR_NOMEM);
		}
		pos += h_size;
		seek_to(pos);

		if (!packed_pat_size)
		{
			for(cnt2 = 0; cnt2 < xm->pat_length[cnt1] * xm->ch_num; cnt2++)
			{
					xm->pat[cnt1][cnt2].key    = MPL__XM_NO_NOTE;
					xm->pat[cnt1][cnt2].inst   = 0;
					xm->pat[cnt1][cnt2].volume = 0;
					xm->pat[cnt1][cnt2].effect = 0;
					xm->pat[cnt1][cnt2].param  = 0;
			}
		}
		else
		{
			for(cnt2 = 0; cnt2 < xm->pat_length[cnt1] * xm->ch_num; cnt2++)
			{
				read_u8();
				ctrl = tmp_u8;

				if (ctrl & 0x80)
				{
					if (ctrl & 1) { read_u8(); } else { tmp_u8 = MPL__XM_NO_NOTE; }
					xm->pat[cnt1][cnt2].key    = tmp_u8 && tmp_u8 < MPL__XM_NO_NOTE ? tmp_u8 : MPL__XM_NO_NOTE;
					if (ctrl & 2) { read_u8(); } else { tmp_u8 = 0; }
					xm->pat[cnt1][cnt2].inst   = tmp_u8;
					if (ctrl & 4) { read_u8(); } else { tmp_u8 = 0; }
					xm->pat[cnt1][cnt2].volume = tmp_u8;
					if (ctrl & 8) { read_u8(); } else { tmp_u8 = 0; }
					xm->pat[cnt1][cnt2].effect = tmp_u8;
					if (ctrl & 16) { read_u8(); } else { tmp_u8 = 0; }
					xm->pat[cnt1][cnt2].param  = tmp_u8;
				}
				else
				{
					xm->pat[cnt1][cnt2].key    = ctrl && ctrl < MPL__XM_NO_NOTE ? ctrl : MPL__XM_NO_NOTE;
					read_u8();
					xm->pat[cnt1][cnt2].inst   = tmp_u8;
					read_u8();
					xm->pat[cnt1][cnt2].volume = tmp_u8;
					read_u8();
					xm->pat[cnt1][cnt2].effect = tmp_u8;
					read_u8();
					xm->pat[cnt1][cnt2].param  = tmp_u8;
				}
			}
		}

		pos += packed_pat_size;
		seek_to(pos);
	}

	if (mpl__mem_alloc(sizeof(mpl__xm_inst_t) * xm->inst_num, (void**)&xm->inst) <= MPL__ERR_GENERIC)
	{
		return_false(MPL__ERR_NOMEM);
	}

	mpl__mem_set_zero(xm->inst, sizeof(mpl__xm_inst_t) * xm->inst_num);

	smp_index = 0;

	for(cnt1 = 0; cnt1 < xm->inst_num; cnt1++)
	{
		vbf_tell(file, &pos);

		read_u32();
		h_size = tmp_u32;

		inst = xm->inst + cnt1;

		if (vbf_read(file, inst->name, 22, &tmp_size) < 0 || tmp_size < 22) return_false(MPL__ERR_GENERIC);
		inst->name[22] = 0;

		read_u8();
		read_u16();
		inst->smp_num = tmp_u16;

		if (inst->smp_num)
		{
			read_u32();
			for(cnt2 = 0; cnt2 < 96; cnt2++)
			{
				read_u8();
				inst->note2smp[cnt2] = tmp_u8;
			}

			for(cnt2 = 0; cnt2 < 12; cnt2++)
			{
				read_u16();
				inst->vol_env[cnt2].x = tmp_u16;
				read_u16();
				inst->vol_env[cnt2].y = tmp_u16;
			}

			for(cnt2 = 0; cnt2 < 12; cnt2++)
			{
				read_u16();
				inst->pan_env[cnt2].x = tmp_u16;
				read_u16();
				inst->pan_env[cnt2].y = tmp_u16;
			}

			read_u8();
			inst->vol_num      = tmp_u8;
			read_u8();
			inst->pan_num      = tmp_u8;
			read_u8();
			inst->vol_sus      = tmp_u8;
			read_u8();
			inst->vol_loop_beg = tmp_u8;
			read_u8();
			inst->vol_loop_end = tmp_u8;
			read_u8();
			inst->pan_sus      = tmp_u8;
			read_u8();
			inst->pan_loop_beg = tmp_u8;
			read_u8();
			inst->pan_loop_end = tmp_u8;
			read_u8();
			inst->vol_type     = tmp_u8;
			read_u8();
			inst->pan_type     = tmp_u8;

			read_u8();
			inst->vib_type     = tmp_u8;
			read_u8();
			inst->vib_sweep    = tmp_u8;
			read_u8();
			inst->vib_depth    = tmp_u8;
			read_u8();
			inst->vib_rate     = tmp_u8;

			read_u16();
			inst->vol_fade_out = 2 * tmp_u16;
		}

		pos += h_size;
		seek_to(pos);

		if (inst->smp_num)
		{
			if (mpl__mem_alloc(sizeof(mpl__xm_sample_t) * inst->smp_num, (void**)&inst->smp) <= MPL__ERR_GENERIC)
			{
				return_false(MPL__ERR_NOMEM);
			}

			mpl__mem_set_zero(inst->smp, sizeof(mpl__xm_sample_t) * inst->smp_num);
		}

		for(cnt2 = 0; cnt2 < inst->smp_num; cnt2++)
		{
			smp = inst->smp + cnt2;

			read_u32();
			smp->length = tmp_u32;
			read_u32();
			smp->loop_begin = tmp_u32;
			read_u32();
			smp->loop_end = tmp_u32;

			if (smp->loop_begin >= smp->length)
			{
				smp->loop_begin = 0;
			}

			smp->loop_end += smp->loop_begin;

			if (smp->loop_end > smp->length)
			{
				smp->loop_end = smp->length;
			}

			read_u8();
			smp->vol = tmp_u8;
			read_i8();
			smp->finetune = tmp_i8;
			read_u8();
			smp->format = tmp_u8;
			read_u8();
			smp->pan = tmp_u8;
			read_i8();
			smp->rel_note = tmp_i8;

			if (smp->loop_begin == smp->loop_end)
			{
				smp->format &= ~(MPL__XM_SMP_LOOP | MPL__XM_SMP_BIDI_LOOP);
			}

			if (smp->format & MPL__XM_SMP_16BIT)
			{
				smp->length     >>= 1;
				smp->loop_begin >>= 1;
				smp->loop_end   >>= 1;
			}

			read_u8();

			if (vbf_read(file, smp->name, 22, &tmp_size) < 0 || tmp_size < 22)
			{
				return_false(MPL__ERR_GENERIC);
			}

			smp->name[22] = 0;

			smp->index = smp_index++;

			if (smp->index >= 300)
			{
				return_false(MPL__ERR_GENERIC);
			}
		}

		for(cnt2 = 0; cnt2 < inst->smp_num; cnt2++)
		{
			smp = inst->smp + cnt2;

			if (smp->length == 0)
			{
				continue;
			}

			if (mpl__mem_alloc(smp->length * (1 + (smp->format & MPL__XM_SMP_16BIT ? 1 : 0)), &smp->data) <= MPL__ERR_GENERIC)
			{
				return_false(MPL__ERR_NOMEM);
			}

			if (smp->format & MPL__XM_SMP_16BIT)
			{
				i16 *cur = (i16*)smp->data;

				if (vbf_read_array_i16(file, VBF_SMALL_ENDIAN, smp->length, cur) < 0)
				{
					return_false(MPL__ERR_GENERIC);
				}

				for(cnt3 = 1; cnt3 < smp->length; cnt3++)
				{
					cur[cnt3] += cur[cnt3 - 1];
				}
			}
			else
			{
				i8 *cur = (i8*)smp->data;

				if (vbf_read(file, cur, smp->length, &tmp_size) < 0 || tmp_size < smp->length)
				{
					return_false(MPL__ERR_GENERIC);
				}

				for(cnt3 = 1; cnt3 < smp->length; cnt3++)
				{
					cur[cnt3] += cur[cnt3 - 1];
				}
			}
		}
	}

	xm->smp_index_num = smp_index;

	return MPL__ERR_OK;
}

#undef return_false
#undef seek_to
#undef read_i8
#undef read_u8
#undef read_u16
#undef read_u32
 

/*

bugs
----

- does MPL__XM_EFF_SMP_OFFSET retrigger?
- cpplay.xm - ahhhhhhhhhh
- crash while playing Enter_the_Merregnon.xm (traxinspace Merregnon compo)
- -27-.xm by floppi -> wrong frequencies
- instrument loading ???
- note delay (btw note delay also has to retrigger if issued with no note!)
- retrig ??
- key off
- do_vol() -> case XM_VOL_EFF_VIB
- note with invalid sample number has to stop current sample

to do
-----

- multi threading !!
- new_note()


*/

#include <mpl/sys/mem.h>
#include <mpl/string.h>
#include <mpl/mp_xm.h>
#include <math.h>

static int sinus_table[32]=
{
  0, 24, 49, 74, 97,120,141,161,
180,197,212,224,235,244,250,253,
255,253,250,244,235,224,212,197,
180,161,141,120, 97, 74, 49, 24
};

static int mp_cmd_reset(void *internal_data);

static int
clip_to(int value, int min, int max)
{
	if (value < min)
	{
		return min;
	}

	if (value > max)
	{
		return max;
	}

	return value;
}

static int
linear_note_to_period(int note, int fine_tune)
{
	return (int)(7680.0f - note * 64.0f - fine_tune * 0.5f);
}

static float32
linear_period_to_freq(int per)
{
	return (float32)(8363.0 * pow(2.0, (4608.0 - per) * 0.00130208333333));
}

static int
note_to_period(int note, int fine_tune)
{
	float32 period, diff;

	period = (float32) pow(2.0f, (132.0f - note) * 0.08333333333f) * 13.375f;

	if (fine_tune < 0 && note)
	{
		diff = period - (float32)pow(2.0f, (132.0f - note + 1) * 0.08333333333f) * 13.375f;
		diff *= (float32)fabs(fine_tune);
		diff /= -128;
	}
	else
	{
		diff = (float32)pow(2.0f, (132.0f - note - 1) * 0.08333333333f) * 13.375f - period;
		diff *= fine_tune;
		diff /= 128;
	}

	period += diff;

	return (int)period;
}

static float32
period_to_freq(int per)
{
	return 14317056.0f / per;
}

static mpl__xm_cell_t*
get_row(mpl__mp_xm_t *pl)
{
	return pl->xm->pat[pl->xm->order[pl->pat_cur]] + pl->row_cur * pl->xm->ch_num;
}

static void run_tick(mpl__mp_xm_t *player, int param);

static void
update_ctrl(mpl__mp_xm_t *pl)
{
	float32 vol, pan, freq;
	mpl__snd_dev_output_t opt;
	mpl__mp_xm_chan_t *p_ch;
	int cur;

	mpl__snd_mixer_get_output_options(pl->mixer, &opt);

	for(cur = 0; cur < pl->xm->ch_num; cur++)
	{

		p_ch = pl->ch + cur;

		p_ch->active = mpl__snd_mixer_is_channel_active(pl->mixer, cur);

		if (!p_ch->active & !(p_ch->ctrl & MPL__XM_CTRL_START))
		{
			continue;
		}

		if (!p_ch->p_smp)
		{
			continue;
		}

		if (p_ch->ctrl & MPL__XM_CTRL_STOP)
		{
			mpl__snd_mixer_stop_channel(pl->mixer, cur);

			p_ch->active = 0;
			p_ch->ctrl = 0;

			continue;
		}


		if (p_ch->ctrl & (MPL__XM_CTRL_START | MPL__XM_CTRL_VOL))
		{
			p_ch->vol = clip_to(p_ch->vol, 0, 64);

			vol = (float32)clip_to(p_ch->vol + p_ch->vol_delta, 0, 128);
			vol = vol * p_ch->env_vol * p_ch->fade_out_vol;
			vol = vol * (1.0f / (64.0f * 65536.0f * 64.0f));

			p_ch->pan = clip_to(p_ch->pan, 0, 255);

			pan = clip_to(p_ch->pan + p_ch->pan_delta + (p_ch->env_pan << 2) - 128, 16, 239) * (1.0f / 255.0f);
		}
	
		if (p_ch->ctrl & (MPL__XM_CTRL_START | MPL__XM_CTRL_PER))
		{
			p_ch->per = clip_to(p_ch->per, 56, 100000);


			if (pl->xm->freq_table & MPL__XM_FREQ_TABLE_LINEAR)
			{
				freq = linear_period_to_freq(clip_to(p_ch->per + p_ch->per_delta, 56, 100000));
			}
			else
			{
				freq = period_to_freq(clip_to(p_ch->per + p_ch->per_delta, 56, 100000));
			}

			if (freq < 50)
			{
				freq = 50;
			}
		}

		if (p_ch->ctrl & MPL__XM_CTRL_START)
		{
			if (pl->smp_handle[p_ch->p_smp->index] < 0)
			{
				continue;
			}

			mpl__snd_mixer_play_channel(pl->mixer, cur, pl->smp_handle[p_ch->p_smp->index], freq, vol, pan, 0.5f, p_ch->smp_offset, MPL__SND_DEV_DIR_FORWARDS);

			p_ch->smp_offset = 0;
			p_ch->ctrl = 0;
		}

		if (p_ch->ctrl & MPL__XM_CTRL_PER)
		{
			mpl__snd_mixer_set_channel_freq(pl->mixer, cur, freq);
		}

		if (p_ch->ctrl & MPL__XM_CTRL_VOL)
		{
			mpl__snd_mixer_set_channel_vol(pl->mixer, cur, vol, pan, 0.5f);
		}

		p_ch->ctrl = 0;
	}

	if (pl->ctrl & MPL__XM_PL_CTRL_VOL)
	{
		pl->glob_vol = clip_to(pl->glob_vol, 0, 64);

		vol = pl->vol * pl->glob_vol * (1.0f / 64.0f);

		mpl__snd_mixer_set_vol(pl->mixer, vol, 0.5f, 0.5f);
	}

	if (pl->ctrl & MPL__XM_PL_CTRL_BPM)
	{
		mpl__snd_call_back_t cb;

		cb.func   = (mpl__snd_call_back_func_t)run_tick;
		cb.data   = pl;
		cb.param  = 0;
		cb.period = 2500.0f / pl->bpm;

		mpl__snd_mixer_set_call_back(pl->mixer, cb);
	}

	pl->ctrl = 0;
}

static long
get_random()
{
	static long seed = 37842;
    unsigned long low, high;

	low  = 16807 * (seed & 0xFFFF);
	high = 16807 * (long)((unsigned long)seed >> 16);

	low = low + ((high & 0x7FFF) << 16);

	if (low > 2147483647L)
	{
		low = (low & 2147483647L) + 1;
	}

	low = low + (high >> 15);

	if (low > 2147483647L)
	{
		low = (low & 2147483647L) + 1;
	}

	return seed = (long)low;
}

static void
do_vibrato(mpl__mp_xm_chan_t *p_ch, int exp, int update_pos)
{
	int delta, temp;

	temp = p_ch->vib_pos & 31;

	switch (p_ch->wave_control & 3)
	{
		case 0:
			delta = (int)(fabs(sin(p_ch->vib_pos * 0.0981747704246f) * 256.0f));
			break;
		case 1:
/*			temp <<= 3;

			if (p_ch->vib_pos < 0)
			{
				temp = 255 - temp;
			}

			delta = temp;
			break;
		case 2:
		case 3:
			delta = get_random() & 0xff;*/
			break;
	};

	delta *= p_ch->vib_depth;
	delta >>= 7;
	delta <<= exp;

	p_ch->ctrl |= MPL__XM_CTRL_PER;

	if (p_ch->vib_pos >= 0)
	{
		p_ch->per_delta = -delta;
	}
	else
	{
		p_ch->per_delta = delta;
	}

	if (!update_pos)
	{
		return;
	}

	p_ch->vib_pos += p_ch->vib_speed;

	if (p_ch->vib_pos > 31)
	{
		p_ch->vib_pos -= 64;
	}
}

static void
do_inst_vibrato(mpl__mp_xm_chan_t *p_ch)
{
	int delta;

	if (!p_ch->p_inst)
	{
		return;
	}

	switch (p_ch->wave_control & 3)
	{
		case 0:
			delta = (int)((sin(p_ch->inst_vib_pos * 0.0245437f)) * 64.0f);
			break;
		case 1:
			delta = 64;
			if (p_ch->inst_vib_pos > 127)
			{
				delta = -64;
			}
			break;
		case 2:
		case 3:
			delta = (get_random() & 0x8f) - 64;
			break;
	};

	delta *= p_ch->p_inst->vib_depth;

	if (p_ch->p_inst->vib_sweep)
	{
		delta = delta * p_ch->inst_vib_sweep_pos / p_ch->p_inst->vib_sweep;
	}

	delta >>= 6;

	p_ch->per_delta += delta;
	p_ch->ctrl      |= MPL__XM_CTRL_PER;

	if (++p_ch->inst_vib_sweep_pos > p_ch->p_inst->vib_sweep)
	{
		p_ch->inst_vib_sweep_pos = p_ch->p_inst->vib_sweep;
	}

	p_ch->inst_vib_pos += p_ch->p_inst->vib_rate;

	if (p_ch->inst_vib_pos > 255)
	{
		p_ch->inst_vib_pos -= 256;
	}
}


static void
do_tremolo(mpl__mp_xm_chan_t *p_ch)
{
    int delta;

    switch((p_ch->wave_control >> 4) & 3)
	{
	case 0:
		delta = sinus_table[p_ch->tremolo_pos&31];
		break;
	case 1:
		delta = p_ch->tremolo_pos < 32 ?
				p_ch->tremolo_pos << 3 :
				255 - (p_ch->tremolo_pos << 3);
		break;
	case 2:
		delta = 255;
		break;
	case 3:
		delta = get_random() & 0xff;
		break;
    };

    delta *= p_ch->tremolo_depth;
	delta >>= 6;

    if (p_ch->tremolo_pos < 32)
	{
		delta = -delta;
	}

	p_ch->vol_delta = delta;
	p_ch->ctrl     |= MPL__XM_CTRL_VOL;

    p_ch->tremolo_pos += p_ch->tremolo_speed;

	while(p_ch->tremolo_pos >= 64)
	{
		p_ch->tremolo_pos -= 64;
	}
}



static void
do_porta(mpl__mp_xm_chan_t *p_ch)
{
	if (p_ch->porta_period)
	{
		p_ch->per  += clip_to(p_ch->porta_period - p_ch->per, -p_ch->porta_speed, p_ch->porta_speed);
		p_ch->ctrl |= MPL__XM_CTRL_PER;
	}
}

static void
do_tremor(mpl__mp_xm_chan_t *p_ch)
{
	if ((p_ch->tremor_spd >> 4) + (p_ch->tremor_spd & 15) == 0)
	{
		p_ch->tremor_pos = 0;
		return;
	}

	p_ch->tremor_pos %= (p_ch->tremor_spd >> 4) + (p_ch->tremor_spd & 15);

	if (p_ch->tremor_pos < (p_ch->tremor_spd >> 4))
	{
		p_ch->vol_delta = 0;
	}
	else
	{
		p_ch->vol_delta = -p_ch->vol;
	}

	p_ch->ctrl |= MPL__XM_CTRL_VOL;

	p_ch->tremor_pos++;
}

static void
do_env_vol(mpl__mp_xm_chan_t *p_ch)
{
	mpl__xm_point_t *cur, *next;
	int pos, tick_inc = 1, divide;

	if (!p_ch->p_inst->vol_num)
	{
		return;
	}

	pos = 0;

	if (p_ch->p_inst->vol_num > 1)
	{
		while(p_ch->env_vol_tick >= p_ch->p_inst->vol_env[pos + 1].x && pos < p_ch->p_inst->vol_num - 1)
		{
			pos++;
		}
	}

	if (p_ch->env_vol_tick == p_ch->p_inst->vol_env[pos].x)
	{
		if ((p_ch->p_inst->vol_type & MPL__XM_ENV_LOOP) &&
			pos == p_ch->p_inst->vol_loop_end)
		{
			pos                = p_ch->p_inst->vol_loop_beg;
			p_ch->env_vol_tick = p_ch->p_inst->vol_env[pos].x;
		}

		if ((p_ch->p_inst->vol_type & MPL__XM_ENV_SUSTAIN) && pos == p_ch->p_inst->vol_sus && !p_ch->key_off)
		{
			tick_inc = 0;
		}

		if (pos == p_ch->p_inst->vol_num - 1)
		{
			tick_inc = 0;
		}
	}

	cur  = p_ch->p_inst->vol_env + pos;
	next = cur;

	if (p_ch->p_inst->vol_num > 1 && pos < p_ch->p_inst->vol_num - 1)
	{
		next++;
	}

	divide = next->x - cur->x;

	if (divide > 1)
	{
		p_ch->env_vol = cur->y + (next->y - cur->y) * (p_ch->env_vol_tick - cur->x) / divide;
	}
	else
	{
		p_ch->env_vol = cur->y;
	}

	p_ch->ctrl |= MPL__XM_CTRL_VOL;

	if (tick_inc)
	{
		p_ch->env_vol_tick++;
	}
}

static void
do_env_pan(mpl__mp_xm_chan_t *p_ch)
{
	mpl__xm_point_t *cur, *next;
	int pos, tick_inc = 1, divide;

	if (!p_ch->p_inst->pan_num)
	{
		p_ch->env_pan_tick++;
		return;
	}

	pos = 0;

	if (p_ch->p_inst->pan_num > 1)
	{
		while(p_ch->env_pan_tick >= p_ch->p_inst->pan_env[pos + 1].x  && pos < p_ch->p_inst->pan_num - 1)
		{
			pos++;
		}
	}

	if (p_ch->env_pan_tick == p_ch->p_inst->pan_env[pos].x)
	{
		if ((p_ch->p_inst->pan_type & MPL__XM_ENV_LOOP) &&
			pos == p_ch->p_inst->pan_loop_end)
		{
			pos                = p_ch->p_inst->pan_loop_beg;
			p_ch->env_pan_tick = p_ch->p_inst->pan_env[pos].x;
		}

		if ((p_ch->p_inst->pan_type & MPL__XM_ENV_SUSTAIN) && pos == p_ch->p_inst->pan_sus && !p_ch->key_off)
		{
			tick_inc = 0;
		}

		if (pos == p_ch->p_inst->pan_num - 1)
		{
			tick_inc = 0;
		}
	}

	cur  = p_ch->p_inst->pan_env + pos;
	next = cur;

	if (p_ch->p_inst->pan_num > 1 && pos < p_ch->p_inst->pan_num - 1)
	{
		next++;
	}

	divide = next->x - cur->x;

	if (divide > 1)
	{
		p_ch->env_pan = cur->y + (next->y - cur->y) * (p_ch->env_pan_tick - cur->x) / divide;
	}
	else
	{
		p_ch->env_pan = cur->y;
	}

	p_ch->ctrl |= MPL__XM_CTRL_VOL;

	if (tick_inc)
	{
		p_ch->env_pan_tick++;
	}
}

static void
do_vol_slide(mpl__mp_xm_chan_t *p_ch, int slide_value)
{
	int param_x, param_y;

	param_x = slide_value >> 4;
	param_y = slide_value & 0xf;

	if (param_x)
	{
		p_ch->vol += param_x;
	}
	else
	{
		if (param_y)
		{
			p_ch->vol -= param_y;
		}
	}

	p_ch->ctrl |= MPL__XM_CTRL_VOL;
}

static void
do_vol(mpl__mp_xm_t *pl, mpl__mp_xm_chan_t *p_ch, int vol)
{
	if (vol < 0x10)
	{
		return;
	}

	if (vol <= 0x50 && !pl->tick_cur)
	{
		p_ch->vol   = vol - 0x10;
		p_ch->ctrl |= MPL__XM_CTRL_VOL;
	}

	switch(vol & 0xf0)
	{
	case MPL__XM_VOL_EFF_VOL_SLIDE_DOWN:
		if (pl->tick_cur)
		{
			p_ch->vol  = p_ch->vol - (vol & 0xf);
			p_ch->ctrl |= MPL__XM_CTRL_VOL;
		}
		break;
	case MPL__XM_VOL_EFF_VOL_SLIDE_UP:
		if (pl->tick_cur)
		{
			p_ch->vol  = p_ch->vol + (vol & 0xf);
			p_ch->ctrl |= MPL__XM_CTRL_VOL;
		}
		break;
	case MPL__XM_VOL_EFF_FINE_VOL_SLIDE_DOWN:
		if (!pl->tick_cur)
		{
			p_ch->vol  = p_ch->vol - (vol & 0xf);
			p_ch->ctrl |= MPL__XM_CTRL_VOL;
		}
		break;
	case MPL__XM_VOL_EFF_FINE_VOL_SLIDE_UP:
		if (!pl->tick_cur)
		{
			p_ch->vol  = p_ch->vol + (vol & 0xf);
			p_ch->ctrl |= MPL__XM_CTRL_VOL;
		}
		break;
	case MPL__XM_VOL_EFF_VIB_SPEED:
		if (!pl->tick_cur)
		{
			p_ch->vib_speed = vol & 0xf;
		}
		break;
	case MPL__XM_VOL_EFF_VIB:
		if (!pl->tick_cur)
		{
			p_ch->vib_depth = vol & 0xf;
			do_vibrato(p_ch, 2, 1);
		}
		else
		{
			do_vibrato(p_ch, 2, 0);
		}

		break;
	case MPL__XM_VOL_EFF_PAN:
		if (!pl->tick_cur)
		{
			p_ch->pan = (vol & 0xf) << 4;
			p_ch->ctrl |= MPL__XM_CTRL_VOL;
		}
		break;
	case MPL__XM_VOL_EFF_PAN_SLIDE_LEFT:
		p_ch->pan   = p_ch->pan - (vol & 0xf);
		p_ch->ctrl |= MPL__XM_CTRL_VOL;
		break;
	case MPL__XM_VOL_EFF_PAN_SLIDE_RIGHT:
		p_ch->pan   = p_ch->pan + (vol & 0xf);
		p_ch->ctrl |= MPL__XM_CTRL_VOL;
		break;
	case MPL__XM_VOL_EFF_PORTA:
		if (vol & 0xf)
		{
			p_ch->porta_speed = (vol & 0xf) << 6;
		}
/*
		if (pl->tick_cur)
		{
			do_porta(p_ch);
		}
		else
		{
			p_ch->porta_period = p_ch->dst_per;
		}*/
		break;
	}
}

static void
new_smp(mpl__mp_xm_chan_t *p_ch)
{
	if (!p_ch->p_smp || p_ch->key == MPL__XM_NO_NOTE)
	{
		return;
	}

	p_ch->vol                = p_ch->p_smp->vol;
	p_ch->env_vol            = 64;
	p_ch->env_vol_tick       = 0;
	p_ch->fade_out_vol       = 65536;
	p_ch->pan                = p_ch->p_smp->pan;
	p_ch->env_pan            = 32;
	p_ch->env_pan_tick       = 0;
	p_ch->key_off            = 0;
	p_ch->inst_vib_sweep_pos = 0;
	p_ch->inst_vib_pos       = 0;
	p_ch->retrig_vol_slide   = 1;

	if ((p_ch->wave_control & 0xf) < 4)
	{
		p_ch->vib_pos = 0;
	}

	if ((p_ch->wave_control >> 4) < 4)
	{
		p_ch->tremolo_pos = 0;
	}

	p_ch->ctrl |= MPL__XM_CTRL_VOL;
}

static void
retrig(mpl__mp_xm_chan_t *p_ch)
{
	if (!p_ch->p_smp || p_ch->key == MPL__XM_NO_NOTE)
	{
		return;
	}

	p_ch->env_vol            = 64;
	p_ch->env_vol_tick       = 0;
	p_ch->fade_out_vol       = 65536;

	p_ch->env_pan            = 32;
	p_ch->env_pan_tick       = 0;

	p_ch->inst_vib_sweep_pos = 0;
	p_ch->inst_vib_pos       = 0;

	if ((p_ch->wave_control & 0xf) < 4)
	{
		p_ch->vib_pos = 0;
	}

	if ((p_ch->wave_control >> 4) < 4)
	{
		p_ch->tremolo_pos = 0;
	}

	p_ch->ctrl |= MPL__XM_CTRL_START | MPL__XM_CTRL_VOL;
}

static void
new_note(mpl__mp_xm_chan_t *p_ch)
{
}

static void
update_row(mpl__mp_xm_t *pl)
{
	int ch;
	mpl__xm_cell_t *row_cur, *cell;
	mpl__xm_t *xm;
	mpl__mp_xm_chan_t *p_ch;
	mpl__msg_t msg;
	int pattern_jump, pattern_break, porta;
	int param, param_x, param_y;
	int old_vol, old_pan, old_per;

	xm = pl->xm;

	if (pl->pat_cur >= xm->length)
	{
		if (pl->loop == MPL__MP_LOOP_NONE)
		{
			mp_cmd_reset(pl);

			if (pl->mb)
			{
				msg.msg = MPL__MP_MSG_END;

				mpl__msg_box_send(pl->mb, &msg);
			}

			return;
		}

		pl->bpm = xm->bpm;
		pl->speed = xm->speed;
		pl->row_cur = 0;
		pl->pat_cur = 0;
		pl->delay = 0;

		if (pl->loop != MPL__MP_LOOP_FOREVER)
		{
			pl->loop--;
		}

		if (pl->mb)
		{
			msg.msg = MPL__MP_MSG_RESTART;

			mpl__msg_box_send(pl->mb, &msg);
		}
	}

	pattern_jump = 0;
	pattern_break = 0;

	pl->row_next = pl->row_cur + 1;

	row_cur = get_row(pl);

	for(ch = 0; ch < pl->xm->ch_num; ch++)
	{
		cell = &row_cur[ch];
		p_ch  = &pl->ch[ch];

		if (ch == 4)
		{
			ch = ch;
		}

		porta = cell->effect == MPL__XM_EFF_PORTA || 
				cell->effect == MPL__XM_EFF_PORTA_VOL_SLIDE ||
				(cell->volume & 0xf0) == MPL__XM_VOL_EFF_PORTA;

		if (cell->key < MPL__XM_KEY_OFF && !porta)
		{
			p_ch->key = cell->key - 1;
		}

		if (cell->inst)
		{
			p_ch->inst = cell->inst;
		}

		if (cell->key < MPL__XM_KEY_OFF && cell->inst && !porta)
		{
			if (cell->inst <= xm->inst_num)
			{
				int note2smp;

				p_ch->p_inst = xm->inst + p_ch->inst - 1;

				note2smp = p_ch->p_inst->note2smp[p_ch->key];

				if (note2smp >= p_ch->p_inst->smp_num)
				{
					p_ch->inst = 0;
					p_ch->p_inst = 0;
					p_ch->p_smp = 0;
				}
				else
				{
					p_ch->p_smp  = p_ch->p_inst->smp + note2smp;
				}
			}
			else
			{
				p_ch->inst = 0;
				p_ch->p_inst = 0;
				p_ch->p_smp = 0;
			}
		}

		if (p_ch->eff == MPL__XM_EFF_TREMOLO && cell->effect != MPL__XM_EFF_TREMOLO)
		{
			p_ch->vol += p_ch->vol_delta;
		}

		p_ch->vol_delta = 0;
		p_ch->per_delta = 0;

		if (p_ch->p_inst)
		{
			if (cell->key < MPL__XM_KEY_OFF)
			{
				int period;

				p_ch->real_key = cell->key + p_ch->p_smp->rel_note - 1;

				if (xm->freq_table & MPL__XM_FREQ_TABLE_LINEAR)
				{
					period = linear_note_to_period(p_ch->real_key, pl->smp_fine_tune[p_ch->p_smp->index]);
				}
				else
				{
					period = note_to_period(p_ch->real_key, pl->smp_fine_tune[p_ch->p_smp->index]);
				}

				if (porta)
				{
					p_ch->dst_per = period;
				}
				else
				{
					p_ch->per   = period;
					p_ch->ctrl |= MPL__XM_CTRL_START;
				}

			}

			if (cell->inst)
			{
				new_smp(p_ch);
			}
		}

		old_vol = p_ch->vol;
		old_pan = p_ch->pan;
		old_per = p_ch->per;

		do_vol(pl, p_ch, cell->volume);

		if (cell->key == MPL__XM_KEY_OFF || cell->effect == MPL__XM_EFF_KEY_OFF)
		{
			p_ch->key_off = 1;
		}

		if (cell->effect == 0 && cell->param == 0)
		{
			goto no_effects;
		}

		param   = cell->param;
		param_x = param >> 4;
		param_y = param & 0xf;

		switch(cell->effect)
		{
		case MPL__XM_EFF_ARPEGGIO:
			break;
		case MPL__XM_EFF_PORTA_UP:
			if (param)
			{
				p_ch->porta_up = param << 2;
			}
			break;
		case MPL__XM_EFF_PORTA_DOWN:
			if (param)
			{
				p_ch->porta_down = param << 2;
			}
			break;
		case MPL__XM_EFF_PORTA:
			if (param)
			{
				p_ch->porta_speed = param << 2;
			}
			p_ch->porta_period = p_ch->dst_per;
			break;
		case MPL__XM_EFF_VIB:
			if (param_x)
			{
				p_ch->vib_speed = param_x;
			}
			if (param_y)
			{
				p_ch->vib_depth = param_y;
			}
			do_vibrato(p_ch, 2, 0);
			break;
		case MPL__XM_EFF_PORTA_VOL_SLIDE:
			if (param)
			{
				p_ch->porta_vol_slide = param;
			}
			p_ch->porta_period = p_ch->dst_per;
			break;
		case MPL__XM_EFF_VIB_VOL_SLIDE:
			if (param)
			{
				p_ch->vib_vol_slide = param;
			}
			do_vibrato(p_ch, 2, 0);
			break;
		case MPL__XM_EFF_TREMOLO:
			if (cell->param & 0xf0)
			{
				p_ch->tremolo_speed = param_x;
			}
			if (cell->param & 0xf)
			{
				p_ch->tremolo_depth = param_y;
			}
			break;
		case MPL__XM_EFF_PAN:
			p_ch->pan   = param;
			p_ch->ctrl |= MPL__XM_CTRL_VOL;
			break;
		case MPL__XM_EFF_SMP_OFFSET:
			p_ch->smp_offset = param << 8;
			p_ch->ctrl      |= MPL__XM_CTRL_START;
			break;
		case MPL__XM_EFF_VOL_SLIDE:
			if (param)
			{
				p_ch->vol_slide = param;
			}
			break;
		case MPL__XM_EFF_POS_JUMP:
			if (param < xm->length)
			{
				pl->pat_next = param;
				pattern_jump = 1;
			}
			break;
		case MPL__XM_EFF_VOL:
			p_ch->vol   = param;
			p_ch->ctrl |= MPL__XM_CTRL_VOL;
			break;
		case MPL__XM_EFF_PAT_BREAK:
			pl->row_next  = param_x * 10 + param_y;
			pattern_break = 1;
			break;
		case MPL__XM_EFF_MOD_EXT:
			switch(param_x)
			{
			case MPL__XM_EXT_EFF_FINE_PORTA_UP:
				if (param_y)
				{
					p_ch->fporta_up = param_y << 2;
				}
				p_ch->per -= p_ch->fporta_up;
				break;
			case MPL__XM_EXT_EFF_FINE_PORTA_DOWN:
				if (param_y)
				{
					p_ch->fporta_down = param_y << 2;
				}
				p_ch->per += p_ch->fporta_down;
				break;
			case MPL__XM_EXT_EFF_GLISSANDO:
				// *fart*
				break;
			case MPL__XM_EXT_EFF_VIB_WAVE:
				p_ch->wave_control &= 0xf0;
				p_ch->wave_control |= param_y;
				break;
			case MPL__XM_EXT_EFF_FINE_TUNE:
				if (p_ch->p_smp)
				{
					pl->smp_fine_tune[p_ch->p_smp->index] = param_y;
				}
				break;
			case MPL__XM_EXT_EFF_PAT_LOOP:
				if (param_y == 0)
				{
					p_ch->loop_row = pl->row_cur;
				}
				else
				{
					if (!p_ch->loop_num)
					{
						p_ch->loop_num = param_y;
					}
					else
					{
						p_ch->loop_num--;
					}
					if (p_ch->loop_num)
					{
						pl->row_next = p_ch->loop_row - 1;
					}
				}
				break;
			case MPL__XM_EXT_EFF_TREMOLO_WAVE:
				p_ch->wave_control &= 0xf;
				p_ch->wave_control |= param_y << 4;
				break;
			case MPL__XM_EXT_EFF_PAN:
				p_ch->pan   = param_y << 4;
				p_ch->ctrl |= MPL__XM_CTRL_VOL;
				break;
			case MPL__XM_EXT_EFF_RETRIG:
				break;
			case MPL__XM_EXT_EFF_FINE_VOL_SLIDE_UP:
				if (param_y)
				{
					p_ch->fvol_slide_up = param_y;
				}
				p_ch->vol  += p_ch->fvol_slide_up;
				p_ch->ctrl |= MPL__XM_CTRL_VOL;
				break;
			case MPL__XM_EXT_EFF_FINE_VOL_SLIDE_DOWN:
				if (param_y)
				{
					p_ch->fvol_slide_down = param_y;
				}
				p_ch->vol  -= p_ch->fvol_slide_up;
				p_ch->ctrl |= MPL__XM_CTRL_VOL;
				break;
			case MPL__XM_EXT_EFF_NOTE_CUT:
				break;
			case MPL__XM_EXT_EFF_NOTE_DELAY:
/*				p_ch->vol   = old_vol;
				p_ch->pan   = old_pan;
				p_ch->per   = old_per;
				p_ch->ctrl &= ~(MPL__XM_CTRL_START|MPL__XM_CTRL_VOL|MPL__XM_CTRL_PER);*/
				break;
			case MPL__XM_EXT_EFF_PAT_DELAY:
				pl->delay = param_y * pl->speed;
				break;
			default:
				break;
			}
			break;
		case MPL__XM_EFF_SPEED:
			if (param < 32)
			{
				pl->speed = param;
			}
			else
			{
				pl->bpm        = param;
				pl->ctrl      |= MPL__XM_PL_CTRL_BPM;
			}
			break;
		case MPL__XM_EFF_GLOB_VOL:
			pl->glob_vol = param;
			pl->ctrl    |= MPL__XM_PL_CTRL_VOL;
			break;
		case MPL__XM_EFF_GLOB_VOL_SLIDE:
			pl->glob_vol_slide = param;
			pl->ctrl          |= MPL__XM_PL_CTRL_VOL;
			break;
		case MPL__XM_EFF_KEY_OFF:
			break;
		case MPL__XM_EFF_ENV_POS:
			if (p_ch->p_inst)
			{
				if (p_ch->p_inst->vol_type & MPL__XM_ENV_ON)
				{
					p_ch->env_vol_tick = param;
				}
			}
			break;
		case MPL__XM_EFF_PAN_SLIDE:
			if (param)
			{
				p_ch->pan_slide = param;
			}
			break;
		case MPL__XM_EFF_RETRIG_VOL_SLIDE:
			if (param)
			{
				p_ch->retrig_vol_slide = param;
			}
			break;
		case MPL__XM_EFF_TREMOR:
			if (param)
			{
				p_ch->tremor_spd = param;
			}
			do_tremor(p_ch);
			break;
		case MPL__XM_EFF_EXTRA_FINE_PORTA:
			switch(param_x)
			{
			case 1:
				if (param_y)
				{
					p_ch->efporta_up = param_y;
				}
				p_ch->per  -= p_ch->efporta_up;
				p_ch->ctrl |= MPL__XM_CTRL_PER;
				break;
			case 2:
				if (param_y)
				{
					p_ch->efporta_down = param_y;
				}
				p_ch->per  += p_ch->efporta_down;
				p_ch->ctrl |= MPL__XM_CTRL_PER;
				break;
			default:
				break;
			}
			break;
		default:
			break;
		}
no_effects:
		if (p_ch->p_inst)
		{
			if (p_ch->p_inst->vol_type & MPL__XM_ENV_ON)
			{
				do_env_vol(p_ch);
			}
			else
			{
				if (p_ch->key_off)
				{
					p_ch->env_vol = 0;
				}
			}

			if (p_ch->p_inst->pan_type & MPL__XM_ENV_ON)
			{
				do_env_pan(p_ch);
			}

			if (p_ch->key_off)
			{
				p_ch->fade_out_vol = clip_to(p_ch->fade_out_vol - p_ch->p_inst->vol_fade_out, 0, 65536);
				p_ch->ctrl        |= MPL__XM_CTRL_VOL;
			}
		}

		do_inst_vibrato(p_ch);
	}

	if (pattern_break && !pattern_jump)
	{
		pl->pat_next++;
	}

	if (!pattern_break && pattern_jump)
	{
		pl->row_next=0;
	}

	if (pl->row_next >= xm->pat_length[xm->order[pl->pat_cur]])
	{
		pl->row_next = 0;
		pl->pat_next++;
	}
}

void
update_effects(mpl__mp_xm_t *pl)
{
	int ch;
	mpl__xm_cell_t *row_cur, *cell;
	mpl__xm_t *xm;
	mpl__mp_xm_chan_t *p_ch;

	xm = pl->xm;
	row_cur = get_row(pl);

	for(ch = 0; ch < xm->ch_num; ch++)
	{
		int param, param_x, param_y;

		cell = &row_cur[ch];
		p_ch = &pl->ch[ch];

		p_ch->per_delta = 0;
		p_ch->vol_delta = 0;

		do_vol(pl, p_ch, cell->volume);

		if (cell->effect == 0 && cell->param == 0)
		{
			goto no_effects;
		}

		param   = cell->param;
		param_x = param >> 4;
		param_y = param & 0xf;

		switch(cell->effect)
		{
		case MPL__XM_EFF_ARPEGGIO:
			switch(pl->tick_cur % 3)
			{
			case 1:
				if (p_ch->p_smp)
				{
					if (xm->freq_table & MPL__XM_FREQ_TABLE_LINEAR)
					{
						p_ch->per_delta = param_x << 6;
					}
					else
					{
						p_ch->per_delta = note_to_period(p_ch->real_key + param_x, pl->smp_fine_tune[p_ch->p_smp->index]) - note_to_period(p_ch->real_key, pl->smp_fine_tune[p_ch->p_smp->index]);
					}

					p_ch->ctrl |= MPL__XM_CTRL_PER;
				}
				break;
			case 2:
				if (p_ch->p_smp)
				{
					if (xm->freq_table & MPL__XM_FREQ_TABLE_LINEAR)
					{
						p_ch->per_delta = param_y << 6;
					}
					else
					{
						p_ch->per_delta = note_to_period(p_ch->real_key + param_y, pl->smp_fine_tune[p_ch->p_smp->index]) - note_to_period(p_ch->real_key, pl->smp_fine_tune[p_ch->p_smp->index]);
					}
					p_ch->ctrl |= MPL__XM_CTRL_PER;
				}
				break;
			default:
				p_ch->ctrl |= MPL__XM_CTRL_PER;
				break;
			}
			break;
		case MPL__XM_EFF_PORTA_UP:
			p_ch->per  -= p_ch->porta_up;
			p_ch->ctrl |= MPL__XM_CTRL_PER;
			break;
		case MPL__XM_EFF_PORTA_DOWN:
			p_ch->per  += p_ch->porta_down;
			p_ch->ctrl |= MPL__XM_CTRL_PER;
			break;
		case MPL__XM_EFF_PORTA:
			do_porta(p_ch);
			break;
		case MPL__XM_EFF_VIB:
			do_vibrato(p_ch, 2, 1);
			break;
		case MPL__XM_EFF_PORTA_VOL_SLIDE:
			do_porta(p_ch);
			do_vol_slide(p_ch, p_ch->porta_vol_slide);
			break;
		case MPL__XM_EFF_VIB_VOL_SLIDE:
			do_vibrato(p_ch, 2, 1);
			do_vol_slide(p_ch, p_ch->vib_vol_slide);
			break;
		case MPL__XM_EFF_TREMOLO:
			do_tremolo(p_ch);
			break;
		case MPL__XM_EFF_PAN:
			break;
		case MPL__XM_EFF_SMP_OFFSET:
			break;
		case MPL__XM_EFF_VOL_SLIDE:
			do_vol_slide(p_ch, p_ch->vol_slide);
			break;
		case MPL__XM_EFF_POS_JUMP:
			break;
		case MPL__XM_EFF_VOL:
			break;
		case MPL__XM_EFF_PAT_BREAK:
			break;
		case MPL__XM_EFF_MOD_EXT:
			switch(param & 0xf0)
			{
			case MPL__XM_EXT_EFF_FINE_PORTA_UP:
				break;
			case MPL__XM_EXT_EFF_FINE_PORTA_DOWN:
				break;
			case MPL__XM_EXT_EFF_GLISSANDO:
				break;
			case MPL__XM_EXT_EFF_VIB_WAVE:
				break;
			case MPL__XM_EXT_EFF_FINE_TUNE:
				break;
			case MPL__XM_EXT_EFF_PAT_LOOP:
				break;
			case MPL__XM_EXT_EFF_TREMOLO_WAVE:
				break;
			case MPL__XM_EXT_EFF_PAN:
				break;
			case MPL__XM_EXT_EFF_RETRIG:
				if (!param_y)
				{
					return;
				}
				if (!(pl->tick_cur % param_y))
				{
					retrig(p_ch);
				}
				break;
			case MPL__XM_EXT_EFF_FINE_VOL_SLIDE_UP:
				break;
			case MPL__XM_EXT_EFF_FINE_VOL_SLIDE_DOWN:
				break;
			case MPL__XM_EXT_EFF_NOTE_CUT:
				if (pl->tick_cur == param_y)
				{
					p_ch->ctrl |= MPL__XM_CTRL_STOP;
				}
				break;
			case MPL__XM_EXT_EFF_NOTE_DELAY:
/*				if (pl->tick_cur == param_y)
				{
					if (p_ch->p_smp)
					{
						new_smp(p_ch);
						do_vol(pl, p_ch, cell->volume);
						p_ch->ctrl |= XM_CTRL_START|XM_CTRL_PER|XM_CTRL_VOL;
					}
				}
				else
				{
					p_ch->ctrl &= ~(XM_CTRL_START|XM_CTRL_PER|XM_CTRL_VOL);
				}*/
				break;
			case MPL__XM_EXT_EFF_PAT_DELAY:
				break;
			default:
				break;
			}
			break;
		case MPL__XM_EFF_SPEED:
			break;
		case MPL__XM_EFF_GLOB_VOL:
			break;
		case MPL__XM_EFF_GLOB_VOL_SLIDE:
			param_x = pl->glob_vol_slide >> 4;
			param_y = pl->glob_vol_slide & 0xf;
			if (param_x)
			{
				pl->glob_vol += param_x;
			}
			else
			{
				if (param_y)
				{
					pl->glob_vol -= param_y;
				}
			}
			pl->ctrl |= MPL__XM_PL_CTRL_VOL;
			break;
		case MPL__XM_EFF_KEY_OFF:
			if (pl->tick_cur == param)
			{
				p_ch->key_off = 1;
			}
			break;
		case MPL__XM_EFF_ENV_POS:
			break;
		case MPL__XM_EFF_PAN_SLIDE:
			param_x = p_ch->pan_slide >> 4;
			param_y = p_ch->pan_slide & 0xf;
			if (param_x)
			{
				p_ch->pan += param_x;
			}
			else
			{
				if (param_y)
				{
					p_ch->pan -= param_y;
				}
			}
			p_ch->ctrl |= MPL__XM_CTRL_VOL;
			break;
		case MPL__XM_EFF_RETRIG_VOL_SLIDE:
			if (!(p_ch->retrig_vol_slide & 0xf))
			{
				break;
			}
			if (pl->tick_cur % (p_ch->retrig_vol_slide & 0xf))
			{
				break;
			}

			retrig(p_ch);

			switch(p_ch->retrig_vol_slide & 0xf0)
			{
			case 0x10: p_ch->vol -= 1;	break;
			case 0x90: p_ch->vol += 1; break;
			case 0x20: p_ch->vol -= 2; break;
			case 0xA0: p_ch->vol += 2; break;
			case 0x30: p_ch->vol -= 4; break;
			case 0xB0: p_ch->vol += 4; break;
			case 0x40: p_ch->vol -= 8; break;
			case 0xC0: p_ch->vol += 8; break;
			case 0x50: p_ch->vol -= 16; break;
			case 0xD0: p_ch->vol += 16; break;
			case 0x60: p_ch->vol = (p_ch->vol << 1) / 3; break;
			case 0xE0: p_ch->vol = (p_ch->vol * 3) >> 1; break;
			case 0x70: p_ch->vol >>= 1; break;
			case 0xF0: p_ch->vol <<= 1; break;
			}

			p_ch->ctrl |= MPL__XM_CTRL_VOL;

			break;
		case MPL__XM_EFF_TREMOR:
			do_tremor(p_ch);
			break;
		case MPL__XM_EFF_EXTRA_FINE_PORTA:
			break;
		default:
			break;
		}

no_effects:

		if (p_ch->p_inst)
		{
			if (p_ch->key_off)
			{
				p_ch->fade_out_vol = clip_to(p_ch->fade_out_vol - p_ch->p_inst->vol_fade_out, 0, 65536);
				p_ch->ctrl        |= MPL__XM_CTRL_VOL;
			}

			if (p_ch->p_inst->vol_type & MPL__XM_ENV_ON)
			{
				do_env_vol(p_ch);
			}
			else
			{
				if (p_ch->key_off)
				{
					p_ch->env_vol = 0;
				}
			}

			if (p_ch->p_inst->pan_type & MPL__XM_ENV_ON)
			{
				do_env_pan(p_ch);
			}
		}

		do_inst_vibrato(p_ch);
	}
}

static void
run_tick(mpl__mp_xm_t *pl, int param)
{
	if (!pl->xm->length)
	{
		return;
	}

	if (pl->tick_cur >= pl->speed)
	{
		pl->tick_cur = 0;

		if (!pl->delay)
		{
			pl->pat_cur = pl->pat_next;
			pl->row_cur	= pl->row_next;
			update_row(pl);
		}
		else
		{
			pl->delay--;
		}
	}
	else
	{
		update_effects(pl);
	}

	update_ctrl(pl);

	pl->tick_cur++;
}

////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
///  interface  ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////

static int
mp_cmd_reset(void *internal_data)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;
	mpl__mp_xm_chan_t *p_ch;
	int ch, inst, smp;

	pl->bpm            = pl->xm->bpm;
	pl->ctrl          |= MPL__XM_PL_CTRL_BPM;
	pl->speed          = pl->xm->speed;
	pl->tick_cur       = pl->speed;
	pl->pat_cur        = 0;
	pl->pat_next       = 0;
	pl->row_cur        = 0;
	pl->row_next       = 0;
	pl->delay          = 0;
	pl->glob_vol       = 64;
	pl->glob_vol_slide = 0;
	pl->delay          = 0;

	mpl__mem_set_zero(pl->ch, sizeof(mpl__mp_xm_chan_t) * 32);

	for(inst = 0; inst < pl->xm->inst_num; inst++)
	{
		for(smp = 0; smp < pl->xm->inst[inst].smp_num; smp++)
		{
			pl->smp_fine_tune[pl->xm->inst[inst].smp[smp].index] = pl->xm->inst[inst].smp[smp].finetune;
		}
	}

	for(ch = 0; ch < 64; ch++)
	{
		p_ch = pl->ch + ch;

		p_ch->pan = 0x80;
		p_ch->key = MPL__XM_NO_NOTE;
	}

	if (pl->dev)
	{
		if (!pl->paused)
		{
			mpl__snd_mixer_pause(pl->mixer);

			pl->paused = 1;
		}

		mpl__snd_mixer_stop(pl->mixer);

		run_tick(pl, 0);
	}

	return 0;
}

static int
mp_cmd_set_dev(void *internal_data, mpl__snd_dev_t *dev)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;
	mpl__snd_mixer_opt_t opt;
	mpl__snd_dev_output_t output;
	mpl__snd_mixer_smp_t upload;
	int inst, smp, cur;
	mpl__xm_sample_t *p_smp;

	if (pl->dev)
	{
		mpl__snd_dev_destroy_mixer(pl->dev, pl->mixer);

		pl->dev = 0;
		pl->mixer = 0;
	}

	if (!dev)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (mpl__snd_dev_get_output_options(dev, &output) < 0)
	{
		return MPL__ERR_GENERIC;
	}

	opt.latency = MPL__SND_DEV_LATENCY_HIGH;
	opt.ch_num  = pl->xm->ch_num;
	opt.smp_num = pl->xm->smp_index_num;

	if (mpl__snd_dev_create_mixer(dev, &pl->mixer, opt) < 0)
	{
		return MPL__ERR_GENERIC;
	}

	pl->dev = dev;

	for (cur = 0; cur < pl->xm->smp_index_num; cur++)
	{
		pl->smp_handle[cur] = -1;
	}

	for(inst = 0; inst < pl->xm->inst_num; inst++)
	{
		for(smp = 0; smp < pl->xm->inst[inst].smp_num; smp++)
		{
			p_smp = pl->xm->inst[inst].smp + smp;

			if (p_smp->length < 4)
			{
				continue;
			}

			upload.format = p_smp->format & MPL__XM_SMP_16BIT ? MPL__SND_DEV_FMT_16BIT : MPL__SND_DEV_FMT_8BIT;
			upload.channels = 1;
			upload.freq = 8363;
			upload.loop = p_smp->loop_begin;
			upload.data = p_smp->data;

			switch(p_smp->format & 3)
			{
			default:
			case MPL__XM_SMP_NO_LOOP:
				upload.loopmode = MPL__SND_DEV_FMT_NONLOOPING;
				upload.length   = p_smp->length;
				break;
			case MPL__XM_SMP_LOOP:
				upload.loopmode = MPL__SND_DEV_FMT_LOOPING;
				upload.length   = p_smp->loop_end;
				break;
			case MPL__XM_SMP_BIDI_LOOP:
				upload.loopmode = MPL__SND_DEV_FMT_BIDILOOPING;
				upload.length   = p_smp->loop_end;
				break;
			}

			upload.vol    = 1.0f;
			upload.pan_lr = 0.5f;
			upload.pan_fb = 0.5f;

			pl->smp_handle[p_smp->index] = mpl__snd_mixer_upload_sample(pl->mixer, upload);

			if (pl->smp_handle[p_smp->index] < 0)
			{
				mpl__snd_dev_destroy_mixer(pl->dev, pl->mixer);

				pl->dev   = 0;
				pl->mixer = 0;

				return MPL__ERR_GENERIC;
			}
		}
	}

	pl->ctrl          |= MPL__XM_PL_CTRL_BPM;

	if (pl->paused)
	{
		mpl__snd_mixer_pause(pl->mixer);
	}

	run_tick(pl, 0);

	return 0;
}

static int
mp_cmd_play(void *internal_data)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;

	if (!pl->dev)
	{
		return MPL__ERR_GENERIC;
	}

	if (pl->paused)
	{
		mpl__snd_mixer_pause(pl->mixer);
		pl->paused = 0;

		return MPL__ERR_OK;
	}

	return MPL__ERR_GENERIC;
}

static int
mp_cmd_stop(void *internal_data)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;

	if (!pl->dev)
	{
		return MPL__ERR_GENERIC;
	}

	if (!pl->paused)
	{
		mpl__snd_mixer_pause(pl->mixer);
		pl->paused = 1;

		return MPL__ERR_OK;
	}

	return MPL__ERR_GENERIC;
}

static int
mp_cmd_set_loop(void *internal_data, int loop)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;

	if (loop < 0 && loop != MPL__MP_LOOP_FOREVER)
	{
		return MPL__ERR_GENERIC;
	}

	pl->loop = loop;

	return MPL__ERR_OK;
}

static int
mp_cmd_set_pos(void *internal_data, int pos)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;
	int pat_next, row_next;
	int cur = 0;

	pat_next = pos >> 24;
	row_next = pos & 0xfff;

	if (pat_next < 0 || pat_next >= pl->xm->length)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (row_next < 0 || row_next >= pl->xm->pat_length[pat_next])
	{
		return MPL__ERR_BAD_PARAM;
	}

	pl->pat_next = pat_next;
	pl->row_next = row_next;

	for(cur = 0; cur < pl->xm->ch_num; cur++)
	{
		pl->ch[cur].loop_num = 0;
	}

	return 0;
}

static int
mp_cmd_get_pos(void *internal_data)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;

	return (pl->pat_cur << 24) + pl->row_cur;
}

static int
mp_cmd_set_vol(void *internal_data, float32 vol)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;

	pl->vol = vol;

	pl->glob_vol = clip_to(pl->glob_vol, 0, 64);

	vol = pl->vol * pl->glob_vol * (1.0f / 64.0f);

	mpl__snd_mixer_set_vol(pl->mixer, vol, 0.5f, 0.5f);

	return 0;
}

static int
mp_cmd_get_vol(void *internal_data, float32 *vol)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;

	*vol = pl->vol;

	return 0;
}

static int
mp_cmd_set_option(void *internal_data, char *option, char *value)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;

	return MPL__ERR_GENERIC;
}

static int
mp_cmd_get_option(void *internal_data, char *option, char **value)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;

	return MPL__ERR_GENERIC;
}

static int
mp_cmd_get_proc(void *internal_data, char *name, void_func_t *proc)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)internal_data;

	return MPL__ERR_GENERIC;
}

////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
///  creation  /////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////

int
mpl__mp_xm_construct(mpl__xm_t *xm, mpl__mp_t *mp, mpl__msg_box_t *mb)
{
	mpl__mp_xm_t *pl;

	if (mpl__mem_alloc(sizeof(mpl__mp_xm_t), (void**)&pl) <= MPL__ERR_GENERIC)
	{
		return MPL__ERR_NOMEM;
	}

	mpl__mem_set_zero(pl, sizeof(mpl__mp_xm_t));

	pl->xm     = xm;
	pl->vol    = 0.5f;
	pl->mb     = mb;
	pl->paused = 1;

	mp_cmd_reset(pl);

	mp->get_option = mp_cmd_get_option;
	mp->get_pos    = mp_cmd_get_pos;
	mp->get_proc   = mp_cmd_get_proc;
	mp->get_vol    = mp_cmd_get_vol;
	mp->play       = mp_cmd_play;
	mp->reset      = mp_cmd_reset;
	mp->set_dev    = mp_cmd_set_dev;
	mp->set_loop   = mp_cmd_set_loop;
	mp->set_option = mp_cmd_set_option;
	mp->set_pos    = mp_cmd_set_pos;
	mp->set_vol    = mp_cmd_set_vol;
	mp->stop       = mp_cmd_stop;

	mp->internal_data = pl;

	return 0;
}

int
mpl__mp_xm_destruct(mpl__mp_t *mp)
{
	mpl__mp_xm_t *pl = (mpl__mp_xm_t*)mp->internal_data;

	if (pl->mixer)
	{
		mpl__snd_dev_destroy_mixer(pl->dev, pl->mixer);
	}

	mpl__mem_free(mp->internal_data);

	return 0;
}
 

#include <mpl/sys/critsect.h>
#include <mpl/sys/mem.h>

int
mpl__cs_create(mpl__critical_section_t **cs)
{
	int result;

	result = mpl__mem_alloc(sizeof(mpl__critical_section_t), (void**)cs);

	if (result <= MPL__ERR_GENERIC)
	{
		return result;
	}

	result = mpl__cs_construct(*cs);

	if (result <= MPL__ERR_GENERIC)
	{
		return result;
	}

	return 0;
}

int
mpl__cs_destroy(mpl__critical_section_t *cs)
{
	mpl__cs_destruct(cs);
	mpl__mem_free(cs);
	
	return 0;
}

int
mpl__cs_construct(mpl__critical_section_t *cs)
{
	InitializeCriticalSection(cs);

	return 0;
}

int
mpl__cs_destruct(mpl__critical_section_t *cs)
{
	DeleteCriticalSection(cs);

	return 0;
}

int
mpl__cs_enter(mpl__critical_section_t *cs)
{
	EnterCriticalSection(cs);

	return 0;
}

int
mpl__cs_leave(mpl__critical_section_t *cs)
{
	LeaveCriticalSection(cs);

	return 0;
}
 

#include <mpl/sys/msg_box.h>
#include <mpl/sys/mem.h>

int
mpl__msg_box_create(mpl__msg_box_t **mb, int max)
{
	int result;

	result = mpl__mem_alloc(sizeof(mpl__msg_box_t), (void**)mb);

	if (result <= MPL__ERR_GENERIC)
	{
		return result;
	}

	result = mpl__msg_box_construct(*mb, max);

	if (result <= MPL__ERR_GENERIC)
	{
		mpl__mem_free(*mb);

		return result;
	}

	return 0;
}

int
mpl__msg_box_destroy(mpl__msg_box_t *mb)
{
	mpl__msg_box_destruct(mb);

	mpl__mem_free(mb);

	return 0;
}

int
mpl__msg_box_construct(mpl__msg_box_t *mb, int max)
{
	int result;

	result = mpl__mem_alloc(sizeof(mpl__msg_t) * max, (void**)&mb->msg);
	
	if (result <= MPL__ERR_GENERIC)
	{
		return result;
	}

	mb->first = 0;
	mb->last  = 0;
	mb->cnt   = 0;
	mb->max   = max;

	result = mpl__cs_construct(&mb->cs);

	if (result <= MPL__ERR_GENERIC)
	{
		mpl__mem_free(mb->msg);

		return result;
	}

	return 0;
}

int
mpl__msg_box_destruct(mpl__msg_box_t *mb)
{
	mpl__cs_destruct(&mb->cs);

	mpl__mem_free(mb->msg);

	return 0;
}

int
mpl__msg_box_send(mpl__msg_box_t *mb, mpl__msg_t *msg)
{
	mpl__cs_enter(&mb->cs);

	if (mb->cnt >= mb->max)
	{
		return MPL__ERR_MSG_BOX_FULL;
	}

	mb->msg[mb->last] = *msg;

	if (++mb->last >= mb->max)
	{
		mb->last = 0;
	}

	mb->cnt++;

	mpl__cs_leave(&mb->cs);

	return 0;
}

int
mpl__msg_box_receive(mpl__msg_box_t *mb, mpl__msg_t *msg)
{
	mpl__cs_enter(&mb->cs);

	if (mb->cnt == 0)
	{
		return MPL__ERR_MSG_BOX_EMPTY;
	}

	*msg = mb->msg[mb->first];

	if (++mb->first >= mb->max)
	{
		mb->first = 0;
	}

	mb->cnt--;

	mpl__cs_leave(&mb->cs);

	return 0;
}
 

 /*
	to do
	-----

	- statistics
	- slab allocator? (a lot faster than standard malloc implementation)
*/

#include <mpl/sys/mem.h>
#include <mpl/sys/critsect.h>
#include <stdlib.h>

static mpl__critical_section_t l_cs;

int
mpl__mem_alloc(mpl__mem_size_t size, void **mem)
{
	void *memblock;
	
//	mpl__cs_enter(&l_cs);
	memblock = malloc(size);
//	mpl__cs_leave(&l_cs);

	if (!memblock)
	{
		return MPL__ERR_NOMEM;
	}

	*mem = memblock;

	return 0;
}

int
mpl__mem_get_size(mpl__mem_size_t *size, void *mem)
{
	return MPL__ERR_GENERIC;
}

int
mpl__mem_resize(mpl__mem_size_t newsize, int onlyexpand, void **mem)
{
	return MPL__ERR_GENERIC;
}

int
mpl__mem_free(void *mem)
{
	mpl__cs_enter(&l_cs);
	free(mem);
	mpl__cs_leave(&l_cs);

	return 0;
}

int
mpl__mem_copy(void *src, void *dst, mpl__mem_size_t size)
{
	char *s, *d;
	int cnt;

	s = (char*) src;
	d = (char*) dst;

	if ((mpl__mem_size_t)src > (mpl__mem_size_t)dst)
	{
		cnt = 0;

		while(cnt < size)
		{
			d[cnt] = s[cnt];
			cnt++;
		}
	}
	else
	{
		while(size--)
		{
			d[size] = s[size];
		}
	}

	return 0;
}

int
mpl__mem_set_zero(void *mem, mpl__mem_size_t size)
{
	char *m;

	m = (char*) mem;

	while(size--)
	{
		m[size] = 0;
	}

	return 0;
}

int
mpl__mem_init()
{
	if (mpl__cs_construct(&l_cs) < MPL__ERR_GENERIC)
	{
		return MPL__ERR_GENERIC;
	}

	return 0;
}
 

#include <mpl/sys/mem.h>
#include <mpl/mx_std.h>
#include <mpl/string.h>
#include <mpl/dsp_std.h>

// formats: mono/stereo, 8/16/24/32/float

// to do
// - better error checks
// - more mixer functions? (four channels, etc.)
// - lagrange interpolation?
// - 24 bit mixing
// - extensions: "EXT_FILTER EXT_REVERB EXT_CHORUS EXT_FX"
// - quality improvement


#define RAMPING 0.02f

#define CHECK_FOR_ERRORS

static int command_reset(void *internal);
static int command_pause(void *internal);
static int command_stop(void *internal);
static int command_upload_sample(void *internal, mpl__snd_mixer_smp_t sample);
static int command_destroy_sample(void *internal, int handle);
static int command_set_sustain_loop(mpl__snd_mixer_t *sndmx, int handle, int begin, int end, int mode);
static int command_end_sustain(mpl__snd_mixer_t *sndmx, int ch);
static int command_set_vol(void *internal, float32 vol, float32 pan_lr, float32 pan_fb);
static int command_get_vol(void *internal, float32 *vol, float32 *pan_lr, float32 *pan_fb);
static int command_get_output_options(void *internal, mpl__snd_dev_output_t *opt);
static int command_get_latency(void *internal);
static int command_get_num_channels(void *internal);
static int command_get_num_active_channels(void *internal);
static int command_get_free_channel(void *internal);
static int command_is_channel_active(void *internal, int ch);
static int command_get_free_channel(void *internal);
static int command_is_channel_active(void *internal, int ch);
static int command_set_channel_vol(void *internal, int ch, float32 vol, float32 pan_lr, float32 pan_fb);
static int command_set_channel_freq(void *internal, int ch, float32 freq);
static int command_set_channel_pos(void *internal, int ch, float64 pos, int dir);
static int command_play_channel(void *internal, int ch, int handle, float32 freq, float32 vol, float32 pan_lr, float32 pan_fb, float64 pos, int dir);
static int command_stop_channel(void *internal, int ch);
static int command_set_option(void *internal, char *option, char *value);
static int command_get_option(void *internal, char *option, char **value);
static int command_get_proc(void *internal, char *name, void_func_t *proc);
static int command_set_call_back(void *internal, mpl__snd_call_back_t call_back);

static int mixer_command_set_output_options(void *internal, mpl__snd_dev_output_t *opt, int latency);
static int mixer_command_set_options(void *internal, mpl__mixer_opt_t *opt);
static int mixer_command_get_options(void *internal, mpl__mixer_opt_t *opt);
static int mixer_command_get_proc(void *internal, char *name, void_func_t *func);
static int mixer_command_set_vol(void *internal, float32 vol, float32 pan_lr, float32 pan_fb);
static int mixer_command_mix(void *internal, void *buffer, int length);
static int mixer_command_get_num_active_channels(void *internal);

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// no interpolation
//#define __INTERPOLATE__(valm1, val0, val1, val2, t) (val0)
// linear interpolation
//#define __INTERPOLATE__(valm1, val0, val1, val2, t) (val0 + (val1 - val0) * t)
// spline interpolation
#define __INTERPOLATE__(valm1, val0, val1, val2, t) (((((3.0f * (val0 - val1) - valm1 + val2) * 0.5f) * t + (2.0f * val1 + valm1 - (5.0f * val0 + val2) * 0.5f)) * t + ((val1 - valm1) * 0.5f)) * t + val0)
#define __RAMP___(a,b,c, d) {if (b) {a+=c;b--;if(!b) a=d;}}
#define __RAMP__ {__RAMP___(p_ch->vol_left, p_ch->vol_left_ramp_num, p_ch->vol_left_ramp, p_ch->vol_left_dst) __RAMP___(p_ch->vol_right, p_ch->vol_right_ramp_num, p_ch->vol_right_ramp, p_ch->vol_right_dst) __RAMP___(p_ch->vol_center, p_ch->vol_center_ramp_num, p_ch->vol_center_ramp, p_ch->vol_center_dst)}

void
mix_inner_loop(mpl__mx_std_t *mx, int ch, float64 step, float32 *buf, int pos, int num)
{
	mpl__mx_std_smp_t *p_smp;
	mpl__mx_std_ch_t *p_ch;
	float32 *smp, tmp, pos_fract;
	int pos_int;

	p_ch  = mx->ch + ch;
	p_smp = mx->smp + p_ch->smp;
	smp   = (float32*)p_smp->smp.data;

	switch(2 * (mx->output.channels - 1) + p_smp->smp.channels)
	{
	case 1:
		while(num--)
		{
			pos_int   = (int)p_ch->pos;
			pos_fract = (float32)(p_ch->pos - pos_int);

			buf[pos++] += __INTERPOLATE__(smp[pos_int],     smp[pos_int + 1],
				                          smp[pos_int + 2], smp[pos_int + 3],
										  pos_fract) * p_ch->vol_center;

			__RAMP__

			p_ch->pos += step;
		}
		break;
	case 2:
		while(num--)
		{
			pos_int   = (int)p_ch->pos;
			pos_fract = (float32)(p_ch->pos - pos_int);
			pos_int <<= 1;

			buf[pos]   += __INTERPOLATE__(smp[pos_int],     smp[pos_int + 2],
				                          smp[pos_int + 4], smp[pos_int + 6],
										  pos_fract) * p_ch->vol_left;

			buf[pos++] += __INTERPOLATE__(smp[pos_int + 1], smp[pos_int + 3],
				                          smp[pos_int + 5], smp[pos_int + 7],
										  pos_fract) * p_ch->vol_right;

			__RAMP__

			p_ch->pos += step;
		}
		break;
	case 3:
		pos <<= 1;

		while(num--)
		{
			pos_int   = (int)p_ch->pos;
			pos_fract = (float32)(p_ch->pos - pos_int);

			tmp = __INTERPOLATE__(smp[pos_int],     smp[pos_int + 1],
				                  smp[pos_int + 2], smp[pos_int + 3],
				   			      pos_fract);

			buf[pos++] += tmp * p_ch->vol_left;
			buf[pos++] += tmp * p_ch->vol_right;

			__RAMP__

			p_ch->pos += step;
		}
		break;
	case 4:
		pos <<= 1;

		while(num--)
		{
			pos_int   = (int)p_ch->pos;
			pos_fract = (float32)(p_ch->pos - pos_int);
			pos_int <<= 1;

			buf[pos++] += __INTERPOLATE__(smp[pos_int],     smp[pos_int + 2],
				                          smp[pos_int + 4], smp[pos_int + 6],
										  pos_fract) * p_ch->vol_left;

			buf[pos++] += __INTERPOLATE__(smp[pos_int + 1], smp[pos_int + 3],
				                          smp[pos_int + 5], smp[pos_int + 7],
										  pos_fract) * p_ch->vol_right;

			__RAMP__

			p_ch->pos += step;
		}
		break;
	}
}

#undef __INTERPOLATE__
#undef __RAMP___
#undef __RAMP__

static void
patch_smp(mpl__mx_std_ch_t *p_ch, mpl__mx_std_smp_t *p_smp)
{
	float32 *data;

	if (p_ch->loop_mode != MPL__SND_DEV_FMT_LOOPING)
	{
		return;
	}

	data = (float32*)p_smp->smp.data;

	if (p_ch->pos < p_ch->loop_beg)
	{
		switch(p_smp->smp.channels)
		{
		case 1:
			p_ch->patch[0] = data[p_ch->loop_beg];
			break;
		case 2:
			p_ch->patch[0] = data[p_ch->loop_beg];
			p_ch->patch[1] = data[p_ch->loop_beg + 1];
			break;
		}
	}
	else
	{
		switch(p_smp->smp.channels)
		{
		case 1:
			p_ch->patch[0] = data[p_ch->loop_beg];

			data[p_ch->loop_beg] = data[p_ch->loop_end];
			break;
		case 2:
			p_ch->patch[0] = data[p_ch->loop_beg];
			p_ch->patch[1] = data[p_ch->loop_beg + 1];

			data[p_ch->loop_beg]     = data[p_ch->loop_end];
			data[p_ch->loop_beg + 1] = data[p_ch->loop_end + 1];
			break;
		}
	}

	switch(p_smp->smp.channels)
	{
	case 1:
		p_ch->patch[1] = data[p_ch->loop_end + 1];
		p_ch->patch[2] = data[p_ch->loop_end + 2];
		p_ch->patch[3] = data[p_ch->loop_end + 3];

		data[p_ch->loop_end + 1] = data[p_ch->loop_beg + 1];
		data[p_ch->loop_end + 2] = data[p_ch->loop_beg + 2];
		data[p_ch->loop_end + 3] = data[p_ch->loop_beg + 3];
		break;
	case 2:
		p_ch->patch[2] = data[p_ch->loop_end * 2 + 2];
		p_ch->patch[3] = data[p_ch->loop_end * 2 + 3];
		p_ch->patch[4] = data[p_ch->loop_end * 2 + 4];
		p_ch->patch[5] = data[p_ch->loop_end * 2 + 5];
		p_ch->patch[6] = data[p_ch->loop_end * 2 + 6];
		p_ch->patch[7] = data[p_ch->loop_end * 2 + 7];

		data[p_ch->loop_end * 2 + 2] = data[p_ch->loop_beg * 2 + 2];
		data[p_ch->loop_end * 2 + 3] = data[p_ch->loop_beg * 2 + 3];
		data[p_ch->loop_end * 2 + 4] = data[p_ch->loop_beg * 2 + 4];
		data[p_ch->loop_end * 2 + 5] = data[p_ch->loop_beg * 2 + 5];
		data[p_ch->loop_end * 2 + 4] = data[p_ch->loop_beg * 2 + 6];
		data[p_ch->loop_end * 2 + 5] = data[p_ch->loop_beg * 2 + 7];
		break;
	}
}

static void
undo_patch(mpl__mx_std_ch_t *p_ch, mpl__mx_std_smp_t *p_smp)
{
	float32 *data;

	if (p_ch->loop_mode != MPL__SND_DEV_FMT_LOOPING)
	{
		return;
	}

	data = (float32*)p_smp->smp.data;

	switch(p_smp->smp.channels)
	{
	case 1:
		data[p_ch->loop_beg]     = p_ch->patch[0];
		data[p_ch->loop_end + 1] = p_ch->patch[1];
		data[p_ch->loop_end + 2] = p_ch->patch[2];
		data[p_ch->loop_end + 3] = p_ch->patch[3];
		break;
	case 2:
		data[p_ch->loop_beg * 2]     = p_ch->patch[0];
		data[p_ch->loop_beg * 2]     = p_ch->patch[1];
		data[p_ch->loop_end * 2 + 2] = p_ch->patch[2];
		data[p_ch->loop_end * 2 + 3] = p_ch->patch[3];
		data[p_ch->loop_end * 2 + 4] = p_ch->patch[4];
		data[p_ch->loop_end * 2 + 5] = p_ch->patch[5];
		data[p_ch->loop_end * 2 + 6] = p_ch->patch[6];
		data[p_ch->loop_end * 2 + 7] = p_ch->patch[7];
		break;
	}
}

static int
calc_samples_left(mpl__mx_std_ch_t *p_ch, float64 fratio, float64 oofratio)
{
	int tmp;

	if (p_ch->dir == MPL__SND_DEV_DIR_FORWARDS)
	{
		tmp = (int)((p_ch->loop_end - p_ch->pos) * oofratio);

		if (p_ch->loop_mode != MPL__SND_DEV_FMT_BIDILOOPING)
		{
			if (tmp * fratio + p_ch->pos < p_ch->loop_end) 
			{
				tmp++;
			}
		}
	}
	else
	{
		if (p_ch->pos < p_ch->loop_beg)
		{
			tmp =  (int)(p_ch->pos * oofratio);
		}
		else
		{
			tmp = (int)((p_ch->pos - p_ch->loop_beg) * oofratio);
		}
	}

	if (tmp < 0)
	{
		tmp = 0;
	}

	return tmp;
}

static int
fix_loop(mpl__mx_std_ch_t *p_ch, float64 *step, float64 fratio, float64 oofratio)
{
	if (p_ch->loop_mode == MPL__SND_DEV_FMT_NONLOOPING)
	{
		return 0;
	}

	if (p_ch->loop_mode == MPL__SND_DEV_FMT_LOOPING)
	{
		while(!calc_samples_left(p_ch, fratio, oofratio))
		{
			p_ch->pos -= p_ch->loop_end - p_ch->loop_beg;
		}

		if ((int)p_ch->pos < 0)
		{
			
			p_ch->pos += fratio;
		}

		return 1;
	}

	if (p_ch->loop_mode == MPL__SND_DEV_FMT_BIDILOOPING)
	{
		*step     = - *step;
		p_ch->dir = (~p_ch->dir) & 1;

		return 1;
	}

	return 0;
}

#define PAN2VOL_LEFT(pan) ((pan) <= 0.5f ? 1.0f : (1.0f - (pan)) * 2.0f)
#define PAN2VOL_RIGHT(pan) ((pan) >= 0.5f ? 1.0f : (pan) * 2.0f)

static void
mix_channel(mpl__mx_std_t *mx, int ch, float32 *buf, i32 buf_pos, i32 num)
{
	i32 samples_left, cnt;
	float64 fratio, oofratio, step;
	float32 vol;
	mpl__mx_std_smp_t *p_smp;
	mpl__mx_std_ch_t *p_ch;

	p_ch  = mx->ch + ch;
	p_smp = mx->smp + p_ch->smp;

	fratio   = p_ch->freq / mx->output.freq;
	oofratio =          1 / fratio;

	step      = fratio * (p_ch->dir == MPL__SND_DEV_DIR_FORWARDS ? 1 : -1);

	if (ch < mx->ch_num)
	{
		vol                  = p_smp->smp.vol * p_ch->vol * mx->vol_global * mx->vol_local;
		p_ch->vol_left_dst   = vol * PAN2VOL_LEFT(p_ch->pan_lr + p_smp->smp.pan_lr + mx->pan_lr_global + mx->pan_lr_local - 1.5f);
		p_ch->vol_right_dst  = vol * PAN2VOL_RIGHT(p_ch->pan_lr + p_smp->smp.pan_lr + mx->pan_lr_global + mx->pan_lr_local - 1.5f);
		p_ch->vol_center_dst = vol;
	}
	else
	{
		p_ch->vol_left_dst   = 0;
		p_ch->vol_right_dst  = 0;
		p_ch->vol_center_dst = 0;
	}

	if (p_ch->vol_left_dst != p_ch->vol_left)
	{
		if (p_ch->vol_left_dst > p_ch->vol_left)
		{
			p_ch->vol_left_ramp = mx->ramp;
			p_ch->vol_left_ramp_num = (int)((p_ch->vol_left_dst - p_ch->vol_left) / mx->ramp);
		}
		else
		{
			p_ch->vol_left_ramp = -mx->ramp;
			p_ch->vol_left_ramp_num = (int)((p_ch->vol_left - p_ch->vol_left_dst) / mx->ramp);
		}
	}

	if (p_ch->vol_right_dst != p_ch->vol_right)
	{
		if (p_ch->vol_right_dst > p_ch->vol_right)
		{
			p_ch->vol_right_ramp = mx->ramp;
			p_ch->vol_right_ramp_num = (int)((p_ch->vol_right_dst - p_ch->vol_right) / mx->ramp);
		}
		else
		{
			p_ch->vol_right_ramp = -mx->ramp;
			p_ch->vol_right_ramp_num = (int)((p_ch->vol_right - p_ch->vol_right_dst) / mx->ramp);
		}
	}

	if (p_ch->vol_center_dst != p_ch->vol_center)
	{
		if (p_ch->vol_center_dst > p_ch->vol_center)
		{
			p_ch->vol_center_ramp = mx->ramp;
			p_ch->vol_center_ramp_num = (int)((p_ch->vol_center_dst - p_ch->vol_center) / mx->ramp);
		}
		else
		{
			p_ch->vol_center_ramp = -mx->ramp;
			p_ch->vol_center_ramp_num = (int)((p_ch->vol_center - p_ch->vol_center_dst) / mx->ramp);
		}
	}
	
	cnt = num;

	while(cnt)
	{
		samples_left = calc_samples_left(p_ch, fratio, oofratio);

		if (samples_left == 0)
		{
			if (!fix_loop(p_ch, &step, fratio, oofratio))
			{
				p_ch->playing = 0;

				return;
			}

			samples_left = calc_samples_left(p_ch, fratio, oofratio);
		}

		if (samples_left == 0)
		{
			p_ch->playing = 0;

			return;
		}

		samples_left = samples_left < cnt ? samples_left : cnt;

		if (samples_left < 0)
		{
			samples_left=0;
		}

		patch_smp(p_ch, p_smp);
		mix_inner_loop(mx, ch, step, buf, buf_pos, samples_left);
		undo_patch(p_ch, p_smp);

		if (p_ch->vol_left == 0 && p_ch->vol_right == 0 &&
			ch >= mx->ch_num)
		{
			p_ch->playing = 0;

			return;
		}

		cnt     -= samples_left;
		buf_pos += samples_left;
	}
}

static void
filter_dc(mpl__mx_std_t *mx, float32 *buf, int length)
{
	if(mx->output.channels > 1)
	{
		while(length--)
		{
			mx->dc_spd[0] = mx->dc_spd[0] + (*buf - mx->dc_pos[0]) * 0.000004567f;
			mx->dc_pos[0] = mx->dc_pos[0] + mx->dc_spd[0];
			*buf          = *buf - mx->dc_pos[0];
			buf++;
			mx->dc_spd[1] = mx->dc_spd[1] + (*buf - mx->dc_pos[1]) * 0.000004567f;
			mx->dc_pos[1] = mx->dc_pos[1] + mx->dc_spd[1];
			*buf          = *buf - mx->dc_pos[1];
			buf++;
		}
	}
	else
	{
		while(length--)
		{
			mx->dc_spd[0] = mx->dc_spd[0] + (*buf - mx->dc_pos[0]) * 0.000004567f;
			mx->dc_pos[0] = mx->dc_pos[0] + mx->dc_spd[0];
			*buf          = *buf - mx->dc_pos[0];
			buf++;
		}

		mx->dc_spd[1] = mx->dc_spd[0];
		mx->dc_pos[1] = mx->dc_pos[0];
	}
}

#undef PAN2VOL_LEFT
#undef PAN2VOL_RIGHT

static void
quantize(float32 *src, void *dest, int length, int format)
{
	i32 tmp_i32;
	i64 tmp_i64;


	switch(format)
	{
	case MPL__SND_DEV_FMT_8BIT:
		while(length--)
		{
			tmp_i32 = (i32)(src[length] * 128.0f);

			if (tmp_i32 < -128) tmp_i32 = -125;
			if (tmp_i32 > 127) tmp_i32 = 125;

			((i8*)dest)[length] = (i8)tmp_i32;
		}
		break;
	case MPL__SND_DEV_FMT_16BIT:
		while(length--)
		{
			tmp_i32 = (i32)(src[length] * 32768.0f);

			if (tmp_i32 < -32768) tmp_i32 = -32760;
			if (tmp_i32 > 32767) tmp_i32 = 32760;

			((i16*)dest)[length] = (i16)tmp_i32;
		}
		break;
	case MPL__SND_DEV_FMT_24BIT:
		// to do
		break;
	case MPL__SND_DEV_FMT_32BIT:
		while(length--)
		{
			tmp_i64 = (i64)(src[length] * 2147483648.0f);

			if (tmp_i64 < -(i64)2147483648) tmp_i64 = -(i64)2147483640;
			if (tmp_i64 > 2147483647)       tmp_i64 = 2147483640;

			((i32*)dest)[length] = (i32)tmp_i64;
		}
		break;
	case MPL__SND_DEV_FMT_FLOAT_32BIT:
		while(length--)
		{
			((float32*)dest)[length] = src[length];
		}
		break;
	}
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

static int
command_reset(void *internal)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;
	int smp, ch;

	for(ch = 0; ch < mx->ch_num * 2; ch++)
	{
		mx->ch[ch].playing = 0;
	}

	for(smp = 0; smp < mx->smp_num; smp++)
	{
		if (mx->smp[smp].smp.data)
		{
			mpl__mem_free(mx->smp[smp].smp.data);
		}

		mx->smp[smp].exists = 0;
	}

	mx->paused = 0;

	return 0;
}

static int
command_pause(void *internal)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	mx->paused ^= 1;

	return 0;
}

static int
command_stop(void *internal)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;
	int ch;

	for(ch = 0; ch < mx->ch_num; ch++)
	{
		mx->ch[ch + mx->ch_num] = mx->ch[ch];
		mx->ch[ch].playing      = 0;
	}

	return 0;
}

static int
command_upload_sample(void *internal, mpl__snd_mixer_smp_t sample)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;
	int smp, size;
	float32 *data;

	for(smp = 0; smp < mx->smp_num; smp++)
	{
		if (!mx->smp[smp].exists) break;
	}

	if (smp == mx->smp_num)
	{
		return MPL__ERR_GENERIC;
	}

#ifdef CHECK_FOR_ERRORS

	if (sample.channels != 1 &&
		sample.channels != 2)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (sample.format < MPL__SND_DEV_FMT_8BIT || sample.format > MPL__SND_DEV_FMT_FLOAT_32BIT)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (sample.loopmode != MPL__SND_DEV_FMT_NONLOOPING &&
		sample.loopmode != MPL__SND_DEV_FMT_LOOPING    &&
		sample.loopmode != MPL__SND_DEV_FMT_BIDILOOPING)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (sample.length == 0)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (sample.loopmode != MPL__SND_DEV_FMT_NONLOOPING && sample.loop >= sample.length)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (sample.pan_fb < 0.0f || sample.pan_fb > 1.0f ||
		sample.pan_lr < 0.0f || sample.pan_fb > 1.0f)
	{
		return MPL__ERR_BAD_PARAM;
	}

#endif

	size = sizeof(float32) * sample.channels;

	mx->smp[smp].smp = sample;

	mx->smp[smp].sus_loop_beg  = sample.loop;
	mx->smp[smp].sus_loop_end  = sample.length;
	mx->smp[smp].sus_loop_mode = sample.loopmode;

	if (mpl__mem_alloc(size * (sample.length + 4), &mx->smp[smp].smp.data) <= MPL__ERR_GENERIC)
	{
		return MPL__ERR_NOMEM;
	}

	data = (float32*) mx->smp[smp].smp.data;

	if (mpl__dsp_conv_format(sample.data, data + sample.channels,
		sample.format, MPL__SND_DEV_FMT_FLOAT_32BIT, sample.length,
		sample.channels, 1.0f) < MPL__ERR_OK)
	{
		mpl__mem_free((void*)data);

		return MPL__ERR_GENERIC;
	}


	switch(sample.channels)
	{
	case 1:
		data[0]                 = data[1];
		data[sample.length + 1] = data[sample.length];
		data[sample.length + 2] = data[sample.length];
		data[sample.length + 3] = data[sample.length];
		break;
	case 2:
		data[0]                 = data[2];
		data[1]                 = data[3];
		data[sample.length * 2 + 2] = data[sample.length * 2];
		data[sample.length * 2 + 3] = data[sample.length * 2 + 1];
		data[sample.length * 2 + 4] = data[sample.length * 2];
		data[sample.length * 2 + 5] = data[sample.length * 2 + 1];
		data[sample.length * 2 + 6] = data[sample.length * 2];
		data[sample.length * 2 + 7] = data[sample.length * 2 + 1];
		break;
	}

	mx->smp[smp].exists = 1;

	return smp;
}

static int
command_destroy_sample(void *internal, int handle)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;
	int ch;

#ifdef CHECK_FOR_ERRORS

	if (handle < 0 || handle >= mx->smp_num)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (!mx->smp[handle].exists)
	{
		return MPL__ERR_BAD_PARAM;
	}

	for(ch = 0; ch < mx->ch_num * 2; ch++)
	{
		if (mx->ch[ch].playing && mx->ch[ch].smp == handle)
		{
			return MPL__ERR_BAD_PARAM;
		}
	}
#endif

	mpl__mem_free(mx->smp[handle].smp.data);

	mx->smp[handle].exists = 0;

	return 0;
}

static int
command_set_sustain_loop(mpl__snd_mixer_t *sndmx, int handle, int begin, int end, int mode)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) sndmx->internal_data;
	mpl__mx_std_smp_t *smp;

#ifdef CHECK_FOR_ERRORS

	if (handle < 0 || handle >= mx->smp_num)
	{
		return MPL__ERR_BAD_PARAM;
	}

	smp = mx->smp + handle;

	if (!smp->exists)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (end > smp->smp.length)
	{
		return MPL__ERR_BAD_PARAM;
	}

#endif

	smp->sus_loop_beg  = begin;
	smp->sus_loop_end  = end;
	smp->sus_loop_mode = mode;

	return 0;
}

static int
command_end_sustain(mpl__snd_mixer_t *sndmx, int ch)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) sndmx->internal_data;
	mpl__mx_std_smp_t *smp;

#ifdef CHECK_FOR_ERRORS

	if (ch < 0 || ch >= mx->ch_num)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (!mx->ch[ch].playing)
	{
		return MPL__ERR_GENERIC;
	}

	smp = &mx->smp[mx->ch[ch].smp];

#endif

	mx->ch[ch].loop_beg  = smp->smp.loop;
	mx->ch[ch].loop_end  = smp->smp.length;
	mx->ch[ch].loop_mode = smp->smp.loopmode;

	return 0;
}

static int
command_set_vol(void *internal, float32 vol, float32 pan_lr, float32 pan_fb)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

#ifdef CHECK_FOR_ERRORS
	if (pan_lr < 0.0f || pan_lr > 1.0f ||
		pan_fb < 0.0f || pan_fb > 1.0f)
	{
		return MPL__ERR_BAD_PARAM;
	}
#endif

	mx->vol_local    = vol;
	mx->pan_lr_local = pan_lr;
	mx->pan_fb_local = pan_fb;

	return 0;
}

static int
command_get_vol(void *internal, float32 *vol, float32 *pan_lr, float32 *pan_fb)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	*vol    = mx->vol_local;
	*pan_lr = mx->pan_lr_local;
	*pan_fb = mx->pan_fb_local;

	return 0;
}

static int
command_get_output_options(void *internal, mpl__snd_dev_output_t *opt)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	*opt = mx->output;

	return 0;
}

static int
command_get_latency(void *internal)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	return mx->latency;
}

static int
command_get_num_channels(void *internal)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	return mx->ch_num;
}

static int
command_get_num_active_channels(void *internal)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;
	int ch, num;

	num = 0;

	for(ch = 0; ch < mx->ch_num; ch++)
	{
		if (mx->ch[ch].playing)
		{
			num++;
		}
	}

	return num;
}

static int
command_get_free_channel(void *internal)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;
	int ch;

	for(ch = 0; ch < mx->ch_num; ch++)
	{
		if (!mx->ch[ch].playing)
		{
			return ch;
		}
	}

	return MPL__ERR_GENERIC;
}

static int
command_is_channel_active(void *internal, int ch)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

#ifdef CHECK_FOR_ERRORS

	if (ch < 0 || ch >= mx->ch_num)
	{
		return MPL__ERR_BAD_PARAM;
	}

#endif

	return mx->ch[ch].playing != 0;
}

static int
command_set_channel_vol(void *internal, int ch, float32 vol, float32 pan_lr, float32 pan_fb)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

#ifdef CHECK_FOR_ERRORS

	if (ch < 0 || ch >= mx->ch_num)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (!mx->ch[ch].playing)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (pan_lr < 0.0f || pan_lr > 1.0f ||
		pan_fb < 0.0f || pan_fb > 1.0f)
	{
		return MPL__ERR_BAD_PARAM;
	}

#endif

	mx->ch[ch].vol    = vol;
	mx->ch[ch].pan_lr = pan_lr;

	return 0;
}

static int
command_set_channel_freq(void *internal, int ch, float32 freq)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

#ifdef CHECK_FOR_ERRORS

	if (ch < 0 || ch >= mx->ch_num)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (!mx->ch[ch].playing)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (freq <= 0 || freq > 1000000)
	{
		return MPL__ERR_BAD_PARAM;
	}

#endif

	mx->ch[ch].freq = freq;

	return -1;
}

static int
command_set_channel_pos(void *internal, int ch, float64 pos, int dir)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

#ifdef CHECK_FOR_ERRORS

	if (ch < 0 || ch >= mx->ch_num)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (!mx->ch[ch].playing)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (dir != MPL__SND_DEV_DIR_FORWARDS || dir != MPL__SND_DEV_DIR_BACKWARDS)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (pos < 0 || pos >= mx->ch[ch].loop_end)
	{
		return MPL__ERR_BAD_PARAM;
	}

#endif

	mx->ch[ch + mx->ch_num] = mx->ch[ch];

	mx->ch[ch].pos        = pos;
	mx->ch[ch].dir        = dir;
	mx->ch[ch].vol_left   = 0;
	mx->ch[ch].vol_right  = 0;
	mx->ch[ch].vol_center = 0;


	return 0;
}

static int
command_play_channel(void *internal, int ch, int handle, float32 freq, float32 vol, float32 pan_lr, float32 pan_fb, float64 pos, int dir)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;
	mpl__mx_std_smp_t *smp;

#ifdef CHECK_FOR_ERRORS

	if (ch < 0 || ch >= mx->ch_num)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (handle < 0 || handle >= mx->smp_num)
	{
		return MPL__ERR_BAD_PARAM;
	}

	smp = mx->smp + handle;

	if (!smp->exists)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (freq != -1 && (freq < 1 || freq > 1000000))
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (dir != -1 && dir != MPL__SND_DEV_DIR_FORWARDS && dir != MPL__SND_DEV_DIR_BACKWARDS)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (pan_lr < 0.0f || pan_lr > 1.0f ||
		pan_fb < 0.0f || pan_fb > 1.0f)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (pos < 0 || pos >= smp->sus_loop_end)
	{
		return MPL__ERR_BAD_PARAM;
	}

#endif

	mx->ch[ch + mx->ch_num] = mx->ch[ch];

	mx->ch[ch].pos        = pos;
	mx->ch[ch].dir        = dir;
	mx->ch[ch].smp        = handle;
	mx->ch[ch].freq       = freq == -1 ? mx->smp[handle].smp.freq : freq;
	mx->ch[ch].vol        = vol;
	mx->ch[ch].pan_lr     = pan_lr;
	mx->ch[ch].vol_left   = 0;
	mx->ch[ch].vol_right  = 0;
	mx->ch[ch].vol_center = 0;
	mx->ch[ch].loop_beg   = smp->sus_loop_beg;
	mx->ch[ch].loop_end   = smp->sus_loop_end;
	mx->ch[ch].loop_mode  = smp->sus_loop_mode;
	mx->ch[ch].playing    = 1;

	return 0;
}

static int
command_stop_channel(void *internal, int ch)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

#ifdef CHECK_FOR_ERRORS

	if (ch < 0 || ch >= mx->ch_num)
	{
		return MPL__ERR_BAD_PARAM;
	}

#endif

	mx->ch[ch + mx->ch_num] = mx->ch[ch];
	mx->ch[ch].playing      = 0;

	return 0;
}

static int
command_set_option(void *internal, char *option, char *value)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	return MPL__ERR_BAD_PARAM;
}

static int
command_get_option(void *internal, char *option, char **value)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	if (mpl__string_cmp_char(option, "ID") == MPL__STRING_EQUAL)
	{
		*value = "standard mixer";

		return 0;
	}

	if (mpl__string_cmp_char(option, "VERSION") == MPL__STRING_EQUAL)
	{
		*value = "0.01";

		return 0;
	}

	if (mpl__string_cmp_char(option, "AUTHOR") == MPL__STRING_EQUAL)
	{
		*value = "";

		return 0;
	}

	if (mpl__string_cmp_char(option, "EXTENSIONS") == MPL__STRING_EQUAL)
	{
		*value = "EXT_SUSTAIN_LOOP";

		return 0;
	}

	return MPL__ERR_BAD_PARAM;
}

static int
command_get_proc(void *internal, char *name, void_func_t *proc)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	if (mpl__string_cmp_char(name, MPL__FUNC_SND_MIXER_SET_SUSTAIN_LOOP) == MPL__STRING_EQUAL)
	{
		*proc = (void_func_t)command_set_sustain_loop;
		return 1;
	}

	if (mpl__string_cmp_char(name, MPL__FUNC_SND_MIXER_END_SUSTAIN) == MPL__STRING_EQUAL)
	{
		*proc = (void_func_t)command_end_sustain;

		return 0;
	}

	return MPL__ERR_BAD_PARAM;
}

static int
command_set_call_back(void *internal, mpl__snd_call_back_t call_back)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	mx->call_back        = call_back;

	mx->count_down_frac += mx->call_back.period * mx->output.freq * 0.001;
	mx->count_down       = (int)(mx->count_down_frac);
	mx->count_down_frac -= mx->count_down;

	return 0;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

static int
mixer_command_set_output_options(void *internal, mpl__snd_dev_output_t *opt, int latency)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

#ifdef CHECK_FOR_ERRORS

	if (opt->channels != 1 &&
		opt->channels != 2)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (opt->format < MPL__SND_DEV_FMT_8BIT || opt->format > MPL__SND_DEV_FMT_FLOAT_32BIT)
	{
		return MPL__ERR_BAD_PARAM;
	}

	if (opt->latency != MPL__SND_DEV_LATENCY_HIGH && opt->latency != MPL__SND_DEV_LATENCY_HIGH)
	{
		return MPL__ERR_BAD_PARAM;
	}

#endif

	mx->dc_spd[0]     = 0;
	mx->dc_pos[0]     = 0;
	mx->dc_spd[1]     = 0;
	mx->dc_pos[1]     = 0;

	mx->output  = *opt;
	mx->latency = latency;

	mx->ramp    = 1.0f / (opt->freq * RAMPING);

	mx->count_down = (int)(mx->count_down * opt->freq / mx->output.freq);

	return 0;
}

static int
mixer_command_set_options(void *internal, mpl__mixer_opt_t *opt)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;
	mpl__mx_std_ch_t *ch=0;
	mpl__mx_std_smp_t *smp=0;

	if (opt->ch_num != -1)
	{
		int cur;

		if (opt->ch_num < 1 || opt->ch_num > 256)
		{
			return MPL__ERR_BAD_PARAM;
		}

		for(cur = 0; cur < mx->ch_num; cur++)
		{
			if (mx->ch[cur].playing)
			{
				return MPL__ERR_GENERIC;
			}
		}

	}

	if (opt->smp_num != -1)
	{
		int cur;

		if (opt->smp_num < 1 || opt->smp_num > 256)
		{
			return MPL__ERR_BAD_PARAM;
		}

		for(cur = 0; cur < mx->smp_num; cur++)
		{
			if (mx->smp[cur].exists)
			{
				return MPL__ERR_GENERIC;
			}
		}
	}

	if (opt->mem_usage != -1)
	{
		if (opt->mem_usage != MPL__MX_MEM_AGGRESSIVE && opt->mem_usage != MPL__MX_MEM_LOW)
		{
			return MPL__ERR_BAD_PARAM;
		}
	}

	if (opt->qual != -1)
	{
		if (opt->qual != MPL__MX_HQ && opt->qual != MPL__MX_LQ)
		{
			return MPL__ERR_BAD_PARAM;
		}

	}

	if (opt->smp_num != -1)
	{
		if (mpl__mem_alloc(opt->smp_num * sizeof(mpl__mx_std_smp_t), (void**)&smp) <= MPL__ERR_GENERIC)
		{
			return MPL__ERR_NOMEM;
		}

		mpl__mem_set_zero(smp, opt->smp_num * sizeof(mpl__mx_std_smp_t));
	}

	if (opt->ch_num != -1)
	{
		if (mpl__mem_alloc(opt->ch_num * 2 * sizeof(mpl__mx_std_ch_t), (void**)&ch) <= MPL__ERR_GENERIC)
		{
			if (smp)
			{
				mpl__mem_free(smp);
			}
			
			return MPL__ERR_NOMEM;
		}

		mpl__mem_set_zero(ch, opt->ch_num * 2 * sizeof(mpl__mx_std_ch_t));
	}

	if (opt->ch_num != -1)
	{
		int cur;

		mpl__mem_free(mx->ch);

		mx->ch     = ch;
		mx->ch_num = opt->ch_num;

		for(cur = 0; cur < mx->ch_num * 2; cur++)
		{
			mx->ch[cur].playing = 0;
		}
	}

	if (opt->smp_num != -1)
	{
		int cur;

		for(cur = 0; cur < mx->smp_num; cur++)
		{
			if (mx->smp[cur].exists && mx->smp[cur].smp.data)
			{
				mpl__mem_free(mx->smp[cur].smp.data);
			}
		}

		mpl__mem_free(mx->smp);

		mx->smp     = smp;
		mx->smp_num = opt->smp_num;

		for(cur = 0; cur < mx->smp_num; cur++)
		{
			mx->smp[cur].exists = 0;
		}
	}

	if (opt->mem_usage != -1)
	{
		mx->mem_usage = opt->mem_usage;
	}

	if (opt->qual != -1)
	{

		mx->qual = opt->qual;
	}

	return 0;
}

static int
mixer_command_get_options(void *internal, mpl__mixer_opt_t *opt)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	opt->ch_num    = mx->ch_num;
	opt->smp_num   = mx->smp_num;
	opt->mem_usage = mx->mem_usage;
	opt->qual      = mx->qual;

	return 0;
}

static int
mixer_command_get_proc(void *internal, char *name, void_func_t *func)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	return MPL__ERR_BAD_PARAM;
}

static int
mixer_command_set_vol(void *internal, float32 vol, float32 pan_lr, float32 pan_fb)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;
	
#ifdef CHECK_FOR_ERRORS
	
	if (pan_lr < 0.0f || pan_lr > 1.0f ||
		pan_fb < 0.0f || pan_fb > 1.0f)
	{
		return MPL__ERR_BAD_PARAM;
	}
	
#endif
	
	mx->vol_global    = vol;
	mx->pan_lr_global = pan_lr;
	mx->pan_fb_global = pan_fb;

	return 0;
}

static int
mixer_command_mix(void *internal, void *buffer, int length)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;
	mpl__mx_std_ch_t *ch;
	mpl__mx_std_smp_t *smp;
	float32 *mix_buf;
	int mix_buf_size, mix_buf_pos, cnt, gap_size;

	mix_buf_size = mx->output.channels * length;

//	bad (and slow)
	if (mpl__mem_alloc(sizeof(float32) * mix_buf_size, (void**)&mix_buf) <= MPL__ERR_GENERIC)
	{
		return MPL__ERR_NOMEM;
	}

	mix_buf_pos = 0;

	for(cnt = 0; cnt < mix_buf_size ; cnt++)
	{
		mix_buf[cnt] = 0;
	}

	if (mx->paused)
	{
		goto convert;
	}

	while(mix_buf_pos < length)
	{
		gap_size = length - mix_buf_pos;

		if (mx->call_back.func)
		{
			if (!mx->count_down)
			{
				mx->call_back.func(mx->call_back.data, mx->call_back.param);

				mx->count_down_frac += mx->call_back.period * mx->output.freq * 0.001;
				mx->count_down       = (int)(mx->count_down_frac);
				mx->count_down_frac -= mx->count_down;
			}

			gap_size = gap_size < mx->count_down ? gap_size : mx->count_down;
		}

		for(cnt = 0; cnt < mx->ch_num * 2; cnt++)
		{
			ch = mx->ch + cnt;

			if (!ch->playing)
			{
				continue;
			}

			smp = mx->smp + ch->smp;

			mix_channel(mx, cnt, mix_buf, mix_buf_pos, gap_size);
		}

		mix_buf_pos    += gap_size;
		mx->count_down -= gap_size;
	}

convert:
	//filter_dc(mx, mix_buf, length);

	quantize(mix_buf, buffer, length * mx->output.channels, mx->output.format);

	mpl__mem_free(mix_buf);

	return 0;
}

static int
mixer_command_get_num_active_channels(void *internal)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;
	int ch, cnt;

	cnt = 0;

	for(ch = 0; ch < mx->ch_num; ch++)
	{
		if (mx->ch[ch].playing)
		{
			cnt++;
		}
	}

	return cnt;
}

static int
mixer_command_get_interface(void *internal, mpl__snd_mixer_t **mixer)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) internal;

	*mixer = &mx->iface;

	return 0;
}

///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

int
mpl__mx_std_create(mpl__mixer_t **mixer)
{
	mpl__mx_std_t *mx;

	if (mpl__mem_alloc(sizeof(mpl__mixer_t), (void**)mixer) <= MPL__ERR_GENERIC)
	{
		return MPL__ERR_NOMEM;
	}

	if (mpl__mem_alloc(sizeof(mpl__mx_std_t), (void**)&mx) <= MPL__ERR_GENERIC)
	{
		mpl__mem_free(*mixer);

		return MPL__ERR_NOMEM;
	}

	if (mpl__mem_alloc(sizeof(mpl__mx_std_ch_t) * 2, (void**)&mx->ch) <= MPL__ERR_GENERIC)
	{
		mpl__mem_free(*mixer);
		mpl__mem_free(mx);

		return MPL__ERR_NOMEM;
	}

	if (mpl__mem_alloc(sizeof(mpl__mx_std_smp_t), (void**)&mx->smp) <= MPL__ERR_GENERIC)
	{
		mpl__mem_free(*mixer);
		mpl__mem_free(mx);
		mpl__mem_free(mx->ch);

		return MPL__ERR_NOMEM;
	}

	(*mixer)->get_interface           = mixer_command_get_interface;
	(*mixer)->get_num_active_channels = mixer_command_get_num_active_channels;
	(*mixer)->get_options             = mixer_command_get_options;
	(*mixer)->get_proc                = mixer_command_get_proc;
	(*mixer)->mix                     = mixer_command_mix;
	(*mixer)->set_options             = mixer_command_set_options;
	(*mixer)->set_output_options      = mixer_command_set_output_options;
	(*mixer)->set_vol                 = mixer_command_set_vol;

	(*mixer)->internal_data = mx;

	mx->iface.destroy_sample          = command_destroy_sample;
	mx->iface.get_free_channel        = command_get_free_channel;
	mx->iface.get_latency             = command_get_latency;
	mx->iface.get_num_active_channels = command_get_num_active_channels;
	mx->iface.get_num_channels        = command_get_num_channels;
	mx->iface.get_option              = command_get_option;
	mx->iface.get_output_options      = command_get_output_options;
	mx->iface.get_proc                = command_get_proc;
	mx->iface.get_vol                 = command_get_vol;
	mx->iface.is_channel_active       = command_is_channel_active;
	mx->iface.pause                   = command_pause;
	mx->iface.play_channel            = command_play_channel;
	mx->iface.reset                   = command_reset;
	mx->iface.set_call_back           = command_set_call_back;
	mx->iface.set_channel_freq        = command_set_channel_freq;
	mx->iface.set_channel_pos         = command_set_channel_pos;
	mx->iface.set_channel_vol         = command_set_channel_vol;
	mx->iface.set_option              = command_set_option;
	mx->iface.set_vol                 = command_set_vol;
	mx->iface.stop                    = command_stop;
	mx->iface.stop_channel            = command_stop_channel;
	mx->iface.upload_sample           = command_upload_sample;

	mx->iface.internal_data = mx;

	mx->smp_num         = 1;
	mx->smp->exists     = 0;

	mx->ch_num          = 1;
	mx->ch[0].playing   = 0;
	mx->ch[1].playing   = 0;

	mx->count_down_frac = 0;
	mx->call_back.func  = 0;
	mx->latency         = 0;
	mx->mem_usage       = MPL__MX_MEM_LOW;
	mx->output.channels = 2;
	mx->output.format   = MPL__SND_DEV_FMT_16BIT;
	mx->output.freq     = 44100;
	mx->output.latency  = MPL__SND_DEV_LATENCY_HIGH;
	mx->paused          = 0;
	mx->qual            = MPL__MX_HQ;
	mx->vol_global      = 1.0f;
	mx->pan_lr_global   = 0.5f;
	mx->pan_fb_global   = 0.5f;
	mx->vol_local       = 1.0f;
	mx->pan_lr_local    = 0.5f;
	mx->pan_fb_local    = 0.5f;
	mx->dc_spd[0]       = 0;
	mx->dc_pos[0]       = 0;
	mx->dc_spd[1]       = 0;
	mx->dc_pos[1]       = 0;
	mx->ramp            = 1.0f / (44100 * RAMPING);

	return 0;
}

void
mpl__mx_std_destroy(mpl__mixer_t *mixer)
{
	mpl__mx_std_t *mx = (mpl__mx_std_t*) mixer->internal_data;

	mpl__mem_free(mx->ch);
	mpl__mem_free(mx->smp);
	mpl__mem_free(mx);
	mpl__mem_free(mixer);
}
 

#include <windows.h>
#include <malloc.h>
#include <process.h>
#include <mmsystem.h>
#include <dsound.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <conio.h>

#include <stdio.h>
#include <vbf/vbf_std.h>
#include <mpl/mx_std.h>
#include <mpl/ml_xm.h>
#include <mpl/sys/mem.h>

#define PLAYFREQ 44100

mpl__mixer_t *mixah;

LPDIRECTSOUND8 ds8 = 0;
WAVEFORMATEX format;
DSBUFFERDESC desc;
LPDIRECTSOUNDBUFFER8 buf = 0;
int bufpos;

void *tmpbuf;
int tmpbufsize;
int kill=0;
int playing=0;

double sine_pos = 0;

void
fillwf(WAVEFORMATEX *wf, int ch, int freq, int bits)
{
	wf->wFormatTag      = WAVE_FORMAT_PCM;
	wf->nChannels       = ch;
	wf->nSamplesPerSec  = freq;
	wf->wBitsPerSample  = bits;
	wf->nBlockAlign     = bits * ch >> 3;
	wf->nAvgBytesPerSec = wf->nSamplesPerSec * wf->nBlockAlign;
}

int
init()
{
	if (FAILED(DirectSoundCreate8(0, &ds8, 0)))
	{
		return -1;
	}

	if (FAILED(ds8->lpVtbl->SetCooperativeLevel(ds8, GetForegroundWindow(), DSSCL_NORMAL)))
	{
		return -1;
	}

	kill = 0;

	return 0;
}

void
shutitdown()
{
	if (playing)
	{
		kill = 1;

		while(kill) Sleep(5);
	}

	if (buf)
	{
		IUnknown_Release(buf);
		buf = 0;
	}

	if (ds8)
	{
		IUnknown_Release(ds8);
		ds8 = 0;
	}
}


int
setprimarybufferformat(int ch, int freq, int bits)
{
	LPDIRECTSOUNDBUFFER primbuf;
	WAVEFORMATEX format;
	DSBUFFERDESC desc;


	desc.dwBufferBytes = 0;
	desc.lpwfxFormat   = 0;
	desc.dwFlags       = DSBCAPS_PRIMARYBUFFER;
	desc.dwSize        = sizeof(DSBUFFERDESC);
	desc.dwReserved    = 0;

	if (FAILED(ds8->lpVtbl->CreateSoundBuffer(ds8, &desc, &primbuf, 0)))
	{
		return -1;
	}

	fillwf(&format, ch, freq, bits);

	if (FAILED(primbuf->lpVtbl->SetFormat(primbuf, &format)))
	{
		IUnknown_Release(primbuf);

		return -1;
	}

	IUnknown_Release(primbuf);

	return 0;
}


int
calc_space_left()
{
	int readpos, writepos;

	buf->lpVtbl->GetCurrentPosition(buf, &readpos, &writepos);

	if (bufpos < readpos)
	{
		return readpos - bufpos;
	}

	return desc.dwBufferBytes - bufpos + readpos;
}

int
write_data(void *data, mpl__mem_size_t size)
{
	int result, length1, length2;
	void *address1, *address2;

	result = buf->lpVtbl->Lock(buf, bufpos, size,
							   &address1, &length1,
							   &address2, &length2,
							   0);

	if (result == DSERR_BUFFERLOST)
	{
		buf->lpVtbl->Restore(buf);

		result = buf->lpVtbl->Lock(buf, bufpos, size,
								   &address1, &length1,
								   &address2, &length2,
								   0);
	}

	if (result != DS_OK)
	{
		return 0;
	}

	mpl__mem_copy(data, address1, length1);

	if (length2)
	{
		mpl__mem_copy(((i8*)data) + length1, address2, length2);
	}

	buf->lpVtbl->Unlock(buf, address1, length1, address2, length2);

	return 1;
}

int
fillbuf()
{
	mpl__mixer_mix(mixah, tmpbuf, tmpbufsize);
	
	return 0;
}

void __cdecl
dsthread(void *param)
{
	fillbuf();

	while(!kill)
	{
		if (calc_space_left() > tmpbufsize * format.nBlockAlign)
		{
			write_data(tmpbuf, tmpbufsize * format.nBlockAlign);

			bufpos += tmpbufsize * format.nBlockAlign;
			bufpos %= desc.dwBufferBytes;

			fillbuf();
		}

		Sleep(5);
	}

	kill = 0;
}

int
setparams(int ch, int freq, int bits)
{
	if (buf)
	{
		IUnknown_Release(buf);
		buf = 0;
	}

	fillwf(&format, ch, freq, bits);

	desc.dwBufferBytes = format.nBlockAlign * (int)(freq * 0.1);
	desc.lpwfxFormat   = &format;
	desc.dwFlags       = DSBCAPS_GLOBALFOCUS | DSBCAPS_GETCURRENTPOSITION2;
	desc.dwSize        = sizeof(DSBUFFERDESC);
	desc.dwReserved    = 0;

	if (FAILED(ds8->lpVtbl->CreateSoundBuffer(ds8, &desc, (struct IDirectSoundBuffer**)&buf, 0)))
	{
		return -1;
	}

	tmpbufsize = (desc.dwBufferBytes / format.nBlockAlign) >> 2;

	if (mpl__mem_alloc(format.nBlockAlign * tmpbufsize, &tmpbuf) <= MPL__ERR_GENERIC)
	{
		IUnknown_Release(buf);
		buf = 0;
		return -1;
	}

	SetThreadPriority((HANDLE)_beginthread(dsthread, 0, 0), THREAD_PRIORITY_TIME_CRITICAL);

	return 0;
}

int
play()
{
	if (buf->lpVtbl->Play(buf, 0, 0, DSBPLAY_LOOPING) != DS_OK)
	{
		return -1;
	}

	playing = 1;

	return 0;
}

int
clear()
{
	int result, length;
	char *bufpnt;

	result = buf->lpVtbl->Lock(buf, 0, desc.dwBufferBytes,
							   &bufpnt, &length,
							   0, 0,
							   0);

	if (result == DSERR_BUFFERLOST)
	{
		buf->lpVtbl->Restore(buf);

		result = buf->lpVtbl->Lock(buf, 0, desc.dwBufferBytes,
								   &bufpnt, &length,
								   0, 0,
								   0);
	}

	if (result != DS_OK)
	{
		return 0;
	}

	while(length--)
	{
		bufpnt[length] = 0;
	}

	buf->lpVtbl->Unlock(buf, bufpnt, desc.dwBufferBytes, 0, 0);

	return 1;
}

void
stop()
{
	buf->lpVtbl->Stop(buf);

	playing = 0;
}

int
cmd_cm(void *internal, mpl__snd_mixer_t **mixer, mpl__snd_mixer_opt_t opt)
{
	mpl__mixer_opt_t mopt;
	mpl__mixer_t *mx;
	mpl__snd_dev_output_t out;

	mpl__mx_std_create(&mx);

	mixah = mx;

	mopt.ch_num = opt.ch_num;
	mopt.mem_usage = 0;
	mopt.qual = MPL__MX_HQ;
	mopt.smp_num = opt.smp_num;

	mpl__mixer_set_options(mx, &mopt);
	mpl__mixer_set_vol(mx, 1.0f, 0.5f, 0.5f);

	out.channels = 2;
	out.format = MPL__SND_DEV_FMT_16BIT;
	out.freq = PLAYFREQ;
	out.latency = 0;

	mpl__mixer_set_output_options(mx, &out, 100);

	mpl__mixer_get_interface(mx, mixer);

	return 0;
}

int
cmd_dm(void *internal, mpl__snd_mixer_t *mixer)
{
	return 0;
}

int
cmd_goo(void *internal, mpl__snd_dev_output_t *opt)
{
	opt->channels = 2;
	opt->format = 2;
	opt->freq = PLAYFREQ;
	opt->latency = 0;

	return 0;
}

i16 buffer[2 * 10 * PLAYFREQ];

int
main(int argc, char **argv)
{

	mpl__xm_t xm;
	mpl__mp_t mp;
	vbf_t file;
	mpl__snd_dev_t dev;
	FILE *rg;

	mpl__mem_init();

	if (argc != 2)
	{
		printf("syntax: %s filename.xm\n", argv[0]);
		return 0;
	}

	dev.create_mixer = cmd_cm;
	dev.destroy_mixer = cmd_dm;
	dev.get_output_options = cmd_goo;

	rg = fopen(argv[1], "rb");
	if (!rg)
	{
		printf("file not found\n");
		return 0;
	}
	
	vbf_std_open(&file, rg);
	mpl__xm_load(&file, &xm);
	vbf_close(&file);
	fclose(rg);

	if (mpl__mp_xm_construct(&xm, &mp, 0) < MPL__ERR_OK)
	{
		printf("error\n");
		return 0;
	}

	if (mpl__mp_set_dev(&mp, &dev) < MPL__ERR_OK)
	{
		printf("couldn't set device\n");
		return 0;
	}
	
	if (mpl__mp_set_vol(&mp, 0.6f) < MPL__ERR_OK)
	{
		printf("error\n");
		return 0;
	}

	if (mpl__mp_play(&mp) < MPL__ERR_OK)
	{
		printf("error\n");
		return 0;
	}

	mpl__mp_set_loop(&mp, 4);

	init();
	setparams(2, PLAYFREQ, 16);
	clear();
	play();

	printf("playin'.....\n");

	while(!kbhit()) Sleep(100);
	stop();

	return 0;
}
 

#ifndef sys_cfg_h_n423788423342
#define sys_cfg_h_n423788423342

typedef __int64              i64;
typedef unsigned __int64     u64;
//typedef long long            i64;
//typedef unsigned long long   u64;
typedef int                  i32;
typedef unsigned int         u32;
typedef short                i16;
typedef unsigned short       u16;
typedef char                 i8;
typedef unsigned char        u8;

typedef float                float32;
typedef double               float64;
//typedef long double          float80;

typedef short                wide_char;

typedef void(*void_func_t)(void);

#define SYS_SMALL_ENDIAN     1
//#define SYS_BIG_ENDIAN       1

//#define SYS_MINI_VERSION     1

#define inline_function __inline

#endif
 

#ifndef vbf_mem_h_n4237878942373243422348
#define vbf_mem_h_n4237878942373243422348

#include <vbf/vbf.h>

int vbf_mem_open(vbf_t *vbf, void *buffer, vbf_size_t size);

#endif
 

#ifndef vbf_std_h_n478278423789423789342
#define vbf_std_h_n478278423789423789342

#include <vbf/vbf.h>
#include <stdio.h>

int vbf_std_open(vbf_t *vbf, FILE *file);

#endif
 

#ifndef vbf_util_h_n4782378243893
#define  vbf_util_h_n4782378243893

#include <vbf/vbf.h>
#include <sys_cfg.h>

#define VBF_BIG_ENDIAN       0
#define VBF_SMALL_ENDIAN     1

int vbf_read_u64(vbf_t *vbf, int endianess, u64 *val);
int vbf_read_i64(vbf_t *vbf, int endianess, i64 *val);
int vbf_read_u32(vbf_t *vbf, int endianess, u32 *val);
int vbf_read_i32(vbf_t *vbf, int endianess, i32 *val);
int vbf_read_u16(vbf_t *vbf, int endianess, u16 *val);
int vbf_read_i16(vbf_t *vbf, int endianess, i16 *val);
int vbf_read_u8(vbf_t *vbf, int endianess, u8 *val);
int vbf_read_i8(vbf_t *vbf, int endianess, i8 *val);
int vbf_read_float32(vbf_t *vbf, int endianess, float32 *val);
int vbf_read_float64(vbf_t *vbf, int endianess, float64 *val);

int vbf_read_array_u64(vbf_t *vbf, int endianess, int num, u64 *val);
int vbf_read_array_i64(vbf_t *vbf, int endianess, int num, i64 *val);
int vbf_read_array_u32(vbf_t *vbf, int endianess, int num, u32 *val);
int vbf_read_array_i32(vbf_t *vbf, int endianess, int num, i32 *val);
int vbf_read_array_u16(vbf_t *vbf, int endianess, int num, u16 *val);
int vbf_read_array_i16(vbf_t *vbf, int endianess, int num, i16 *val);
int vbf_read_array_u8(vbf_t *vbf, int endianess, int num, u8 *val);
int vbf_read_array_i8(vbf_t *vbf, int endianess, int num, i8 *val);
int vbf_read_array_float32(vbf_t *vbf, int endianess, int num, float32 *val);
int vbf_read_array_float64(vbf_t *vbf, int endianess, int num, float64 *val);

int vbf_read_line_char(vbf_t *vbf, char *buf, int max, int *read);
int vbf_read_line_wide_char(vbf_t *vbf, int endianess, wide_char *buf, int max, int *read);

#endif
 

#ifndef vbf_h_n423789784923789423
#define vbf_h_n423789784923789423

#include <sys_cfg.h>

#define VBF_ATTR_OPEN     1
#define VBF_ATTR_READ     2
#define VBF_ATTR_WRITE    4
#define VBF_ATTR_APPEND   8
#define VBF_ATTR_SEEK     16
#define VBF_ATTR_LENGTH   32

#define VBF_ERR_GENERIC   -1
#define VBF_ERR_BAD_POS   -2
#define VBF_ERR_NOT_OPEN  -3
#define VBF_ERR_NO_LENGTH -4
#define VBF_ERR_NO_SEEK   -5
#define VBF_ERR_NO_READ   -6
#define VBF_ERR_NO_WRITE  -7

typedef long int vbf_size_t;

typedef struct vbf_s {
	int        mode;
	vbf_size_t pos, length;
	void       *data;

	int (*raw_read)(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size);
	int (*raw_write)(struct vbf_s *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size);
	int (*raw_ioctl)(struct vbf_s *vbf, int command, void *buffer, vbf_size_t size, vbf_size_t *out_size);
	int (*raw_seek_rel)(struct vbf_s *vbf, vbf_size_t new_pos);
	int (*raw_close)(struct vbf_s *vbf);
} vbf_t;

int vbf_create(vbf_t *vbf);
int vbf_destroy(vbf_t *vbf);

int vbf_seek_beg(vbf_t *vbf, vbf_size_t pos);
int vbf_seek_cur(vbf_t *vbf, vbf_size_t pos);
int vbf_seek_end(vbf_t *vbf, vbf_size_t pos);
int vbf_tell(vbf_t *vbf, vbf_size_t *pos);
int vbf_size(vbf_t *vbf, vbf_size_t *size);
int vbf_mode(vbf_t *vbf, int *mode);
int vbf_read(vbf_t *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size);
int vbf_write(vbf_t *vbf, void *buffer, vbf_size_t size, vbf_size_t *out_size);
int vbf_ioctl(vbf_t *vbf, int command, void *buffer, vbf_size_t size, vbf_size_t *out_size);
int vbf_close(vbf_t *vbf);

#endif
 

#ifndef biquad_h_n43287238497789234
#define biquad_h_n43287238497789234

#include <sys_cfg.h>

/*
usage:

y[n] = a0 * x[n] + a1 * x[n-1] + a2 * x[n-2] +
                   b1 * y[n-1] + b2 * y[n-2]
*/

typedef struct {
	double a0, a1, a2,
		       b1, b2;
} mpl__biquad_coeff_t;

void mpl__fil_lp(mpl__biquad_coeff_t *fil, float omega, float bandwidth);
void mpl__fil_bp(mpl__biquad_coeff_t *fil, float omega, float bandwidth);
void mpl__fil_hp(mpl__biquad_coeff_t *fil, float omega, float bandwidth);
void mpl__fil_no(mpl__biquad_coeff_t *fil, float omega, float bandwidth);
void mpl__fil_peq(mpl__biquad_coeff_t *fil, float omega, float bandwidth, float dbgain);
void mpl__fil_ls(mpl__biquad_coeff_t *fil, float omega, float dbgain, float slope);
void mpl__fil_hs(mpl__biquad_coeff_t *fil, float omega, float dbgain, float slope);

#endif
 

#ifndef sd_std_h_n34782823478789234
#define sd_std_h_n34782823478789234

#include <mpl/mx.h>

typedef struct mpl__sd_std_s {
	int  (*mx_create)(mpl__mixer_t **mixer);
	void (*mx_destroy)(mpl__mixer_t *mixer);

	mpl__mixer_t *mx[4];
} mpl__sd_std_t;

int mpl__sd_std_create(mpl__snd_dev_t **sd, int  (*mx_create)(mpl__mixer_t **mixer), void (*mx_destroy)(mpl__mixer_t *mixer));
void mpl__sd_std_destroy(mpl__snd_dev_t *sd);

#endif 

#ifndef error_h_n473784923
#define error_h_n473784923

// to be done

#define MPL__ERR_OK                                0
#define MPL__ERR_GENERIC                          -1
#define MPL__ERR_BAD_PARAM                        -2

#define MPL__ERR_NOMEM                            -3

#define MPL__ERR_MSG_BOX_FULL                     -4
#define MPL__ERR_MSG_BOX_EMPTY                    -5

#define MPL__ERR_EOS                              -6

#endif
 

#ifndef ml_h_n31783892389
#define ml_h_n31783892389

#include <mpl/sys/msg_box.h>
#include <vbf/vbf.h>
#include <mpl/mp.h>
#include <mpl/error.h>

typedef void mpl__md_t;

typedef struct mpl__ml_s {
	int (*load)(void *internal, vbf_t *file, mpl__md_t **md);
	int (*destroy)(void *internal, mpl__md_t *md);

	int (*create_mp)(void *internal, mpl__md_t *md, mpl__msg_box_t *mb, mpl__mp_t **mp);
	int (*destroy_mp)(void *internal, mpl__mp_t **mp);

	int (*set_option)(void *internal, char *option, char *value);
	int (*get_option)(void *internal, char *option, char **value);
	int (*get_proc)(void *internal, char *name, void_func_t *proc);

	void *internal_data;
} mpl__ml_t;

int mpl__ml_load(mpl__ml_t *ml, vbf_t *file, mpl__md_t **md);
int mpl__ml_destroy(mpl__ml_t *ml, mpl__md_t *md);
int mpl__ml_create_mp(mpl__ml_t *ml, mpl__md_t *md, mpl__msg_box_t *mb, mpl__mp_t **mp);
int mpl__ml_destroy_mp(mpl__ml_t *ml, mpl__mp_t **mp);
int mpl__ml_set_option(mpl__ml_t *ml, char *option, char *value);
int mpl__ml_get_option(mpl__ml_t *ml, char *option, char **value);
int mpl__ml_get_proc(mpl__ml_t *ml, char *name, void_func_t *proc);


#endif
 

#ifndef mp_h_n432789237
#define mp_h_n432789237

#include <mpl/snddev.h>

#define MPL__MP_LOOP_NONE      0
#define MPL__MP_LOOP_FOREVER   -1

#define MPL__MP_MSG_RESTART    0
#define MPL__MP_MSG_END        1

typedef struct mpl__mp_s {
	int (*set_dev)(void *internal_data, mpl__snd_dev_t *dev);

	int (*reset)(void *internal_data);

	int (*play)(void *internal_data);
	int (*stop)(void *internal_data);
	int (*set_loop)(void *internal_data, int loop);

	// typically: 0xXXXYYY (XXX = pattern, YYY = row)
	int (*set_pos)(void *internal_data, int pos);
	int (*get_pos)(void *internal_data);

	int (*set_vol)(void *internal_data, float32 vol);
	int (*get_vol)(void *internal_data, float32 *vol);

	int (*set_option)(void *internal, char *option, char *value);
	int (*get_option)(void *internal, char *option, char **value);
	int (*get_proc)(void *internal, char *name, void_func_t *proc);

	void *internal_data;
} mpl__mp_t;

int mpl__mp_set_dev(mpl__mp_t *mp, mpl__snd_dev_t *dev);
int mpl__mp_reset(mpl__mp_t *mp);
int mpl__mp_play(mpl__mp_t *mp);
int mpl__mp_stop(mpl__mp_t *mp);
int mpl__mp_set_loop(mpl__mp_t *mp, int loop);
int mpl__mp_set_pos(mpl__mp_t *mp, int pos);
int mpl__mp_get_pos(mpl__mp_t *mp);
int mpl__mp_set_vol(mpl__mp_t *mp, float32 vol);
int mpl__mp_get_vol(mpl__mp_t *mp, float32 *vol);
int mpl__mp_set_option(mpl__mp_t *mp, char *option, char *value);
int mpl__mp_get_option(mpl__mp_t *mp, char *option, char **value);
int mpl__mp_get_proc(mpl__mp_t *mp, char *name, void_func_t *proc);

#endif
 

#ifndef mx_h_n7238478432789423
#define mx_h_n7238478432789423

#include <mpl/snddev.h>

#define MPL__MX_MEM_AGGRESSIVE   0
#define MPL__MX_MEM_LOW          1

#define MPL__MX_HQ               0  // high quality
#define MPL__MX_LQ               1  // low quality

typedef struct mpl__mixer_opt_s {
	int ch_num, smp_num, mem_usage, qual;
} mpl__mixer_opt_t;

typedef struct mpl__mixer_s {
	int (*set_output_options)(void *internal, mpl__snd_dev_output_t *opt, int latency);
	int (*set_options)(void *internal, mpl__mixer_opt_t *opt);
	int (*get_options)(void *internal, mpl__mixer_opt_t *opt);
	int (*get_proc)(void *internal, char *name, void_func_t *func);
	int (*get_interface)(void *internal, mpl__snd_mixer_t **mixer);

	int (*set_vol)(void *internal, float32 vol, float32 pan_lr, float32 pan_fb);

	int (*mix)(void *internal, void *buffer, int length);

	int (*get_num_active_channels)(void *internal);

	void *internal_data;
} mpl__mixer_t;

int mpl__mixer_set_output_options(mpl__mixer_t *mx, mpl__snd_dev_output_t *opt, int latency);
int mpl__mixer_set_options(mpl__mixer_t *mx, mpl__mixer_opt_t *opt);
int mpl__mixer_get_options(mpl__mixer_t *mx, mpl__mixer_opt_t *opt);
int mpl__mixer_get_proc(mpl__mixer_t *mx, char *name, void_func_t *func);
int mpl__mixer_get_interface(mpl__mixer_t *mx, mpl__snd_mixer_t **mixer);
int mpl__mixer_set_vol(mpl__mixer_t *mx, float32 vol, float32 pan_lr, float32 pan_fb);
int mpl__mixer_mix(mpl__mixer_t *mx, void *buffer, int length);
int mpl__mixer_get_num_active_channels(mpl__mixer_t *mx);

#endif
 

#ifndef snddev_h_n478237842378
#define snddev_h_n478237842378

// notes:
//
// data is always signed (any need for unsigned data?!?)


#include <sys_cfg.h>
#include <mpl/error.h>

#define MPL__SND_DEV_FMT_NONLOOPING    0
#define MPL__SND_DEV_FMT_LOOPING       1
#define MPL__SND_DEV_FMT_BIDILOOPING   2

#define MPL__SND_DEV_FMT_8BIT          1
#define MPL__SND_DEV_FMT_16BIT         2
#define MPL__SND_DEV_FMT_24BIT         3
#define MPL__SND_DEV_FMT_32BIT         4
#define MPL__SND_DEV_FMT_FLOAT_32BIT   5

#define MPL__SND_DEV_LATENCY_HIGH      0
#define MPL__SND_DEV_LATENCY_LOW       1

#define MPL__SND_DEV_DIR_FORWARDS      0
#define MPL__SND_DEV_DIR_BACKWARDS     1

typedef struct mpl__snd_dev_output_s {
	int format;
	int channels;
	float32 freq;
	int latency;
} mpl__snd_dev_output_t;

typedef void(*mpl__snd_call_back_func_t)(void *data, int param);

typedef struct mpl__snd_mixer_call_back_s {
	mpl__snd_call_back_func_t	func;
	void						*data;
	int							param;
	float64						period;
} mpl__snd_call_back_t;

typedef struct mpl__snd_dev_smp_s {
	int			format;
	int			channels;
	int			loopmode;
	int			loop;
	int			length;
	float32		vol;
	float32		pan_lr;
	float32		pan_fb;
	float32		freq;
	void		*data;
} mpl__snd_mixer_smp_t;

typedef struct mpl__snd_mixer_s {
	int (*reset)(void *internal);  // stops playing, toasts samples
	int (*pause)(void *internal);  // 1 -> paused | 0 -> unpaused ; doesn't run callback
	int (*stop)(void *internal);

	int (*upload_sample)(void *internal, mpl__snd_mixer_smp_t sample);
	int (*destroy_sample)(void *internal, int handle);

	int (*set_vol)(void *internal, float32 vol, float32 pan_lr, float32 pan_fb);
	int (*get_vol)(void *internal, float32 *vol, float32 *pan_lr, float32 *pan_fb);

	int (*get_output_options)(void *internal, mpl__snd_dev_output_t *opt);
	int (*get_latency)(void *internal);   // ms

	int (*get_num_channels)(void *internal);
	int (*get_num_active_channels)(void *internal);
	int (*get_free_channel)(void *internal);
	int (*is_channel_active)(void *internal, int ch);

	int (*set_channel_vol)(void *internal, int ch, float32 vol, float32 pan_lr, float32 pan_fb);
	int (*set_channel_freq)(void *internal, int ch, float32 freq);
	int (*set_channel_pos)(void *internal, int ch, float64 pos, int dir);
	int (*play_channel)(void *internal, int ch, int handle, float32 freq, float32 vol, float32 pan_lr, float32 pan_fb, float64 pos, int dir);
	int (*stop_channel)(void *internal, int ch);

	/*
		getoption(...)

		"ID"
		"VERSION"
		"AUTHOR"
		"EXTENSIONS" -> e.g. "EXT_MMX EXT_EQ EXT_REVERB"....
	*/
	int (*set_option)(void *internal, char *option, char *value);
	int (*get_option)(void *internal, char *option, char **value);
	int (*get_proc)(void *internal, char *name, void_func_t *proc);

	int (*set_call_back)(void *internal, mpl__snd_call_back_t call_back);

	void *internal_data;
} mpl__snd_mixer_t;

typedef struct mpl__snd_mixer_opt_s {
	int			ch_num;   // min number of channels
	int			smp_num;  // min number of samples
	int			latency;
} mpl__snd_mixer_opt_t;

typedef struct mpl__snd_stream_format_s {
	int			format;
	int			channels;
	float32		freq;
} mpl__snd_stream_format_t;

typedef struct mpl__snd_stream_opt_s {
	mpl__snd_stream_format_t	format;
	int							latency;
} mpl__snd_stream_opt_t;

typedef struct mpl__snd_stream_s {
	int (*set_vol)(void *internal, float32 vol, float32 pan_lr, float32 pan_fb);
	int (*get_vol)(void *internal, float32 *vol, float32 *pan_lr, float32 *pan_fb);

	int (*get_output_options)(void *internal, mpl__snd_dev_output_t *opt);
	int (*set_input_format)(void *internal, mpl__snd_stream_format_t *opt);
	int (*get_input_format)(void *internal, mpl__snd_stream_format_t *opt);
	int (*get_latency)(void *internal);   // ms
	int (*get_buffer_size)(void *internal); // ms

	int (*write)(void *internal, void *data, int length);

	int (*set_option)(void *internal, char *option, char *value);
	int (*get_option)(void *internal, char *option, char **value);
	int (*get_proc)(void *internal, char *name, void_func_t *proc);

	int (*set_call_back)(void *internal, mpl__snd_call_back_t call_back);

	void *internal_data;
} mpl__snd_stream_t;

typedef struct mpl__snd_dev_s {
	int (*set_vol)(void *internal, float32 vol, float32 pan_lr, float32 pan_fb);
	int (*get_vol)(void *internal, float32 *vol, float32 *pan_lr, float32 *pan_fb);

	int (*set_output_options)(void *internal, mpl__snd_dev_output_t opt);
	int (*get_output_options)(void *internal, mpl__snd_dev_output_t *opt);

	int (*set_latency)(void *internal, int latency);
	int (*get_latency)(void *internal);   // ms

	int (*set_option)(void *internal, char *option, char *value);
	int (*get_option)(void *internal, char *option, char **value);
	int (*get_proc)(void *internal, char *name, void_func_t *proc);

	int (*create_mixer)(void *internal, mpl__snd_mixer_t **mixer, mpl__snd_mixer_opt_t opt);
	int (*destroy_mixer)(void *internal, mpl__snd_mixer_t *mixer);

	int (*create_stream)(void *internal, mpl__snd_stream_t **stream, mpl__snd_stream_opt_t opt);
	int (*destroy_stream)(void *internal, mpl__snd_stream_t *stream);

	void *internal_data;
} mpl__snd_dev_t;

// dev

int mpl__snd_dev_set_vol(mpl__snd_dev_t *dev, float32 vol, float32 pan_lr, float32 pan_fb);
int mpl__snd_dev_get_vol(mpl__snd_dev_t *dev, float32 *vol, float32 *pan_lr, float32 *pan_fb);
int mpl__snd_dev_set_output_options(mpl__snd_dev_t *dev, mpl__snd_dev_output_t opt);
int mpl__snd_dev_get_output_options(mpl__snd_dev_t *dev, mpl__snd_dev_output_t *opt);
int mpl__snd_dev_set_latency(mpl__snd_dev_t *dev, int latency);
int mpl__snd_dev_get_latency(mpl__snd_dev_t *dev);
int mpl__snd_dev_set_option(mpl__snd_dev_t *dev, char *option, char *value);
int mpl__snd_dev_get_option(mpl__snd_dev_t *dev, char *option, char **value);
int mpl__snd_dev_get_proc(mpl__snd_dev_t *dev, char *name, void_func_t *proc);
int mpl__snd_dev_create_mixer(mpl__snd_dev_t *dev, mpl__snd_mixer_t **mixer, mpl__snd_mixer_opt_t opt);
int mpl__snd_dev_destroy_mixer(mpl__snd_dev_t *dev, mpl__snd_mixer_t *mixer);
int mpl__snd_dev_create_stream(mpl__snd_dev_t *dev, mpl__snd_stream_t **stream, mpl__snd_stream_opt_t opt);
int mpl__snd_dev_destroy_stream(mpl__snd_dev_t *dev, mpl__snd_stream_t *stream);

// mixer

int mpl__snd_mixer_reset(mpl__snd_mixer_t *mixer);  // stops playing, toasts samples
int mpl__snd_mixer_pause(mpl__snd_mixer_t *mixer);  // 1 -> paused | 0 -> unpaused ; doesn't run callback
int mpl__snd_mixer_stop(mpl__snd_mixer_t *mixer);
int mpl__snd_mixer_upload_sample(mpl__snd_mixer_t *mixer, mpl__snd_mixer_smp_t sample);
int mpl__snd_mixer_destroy_sample(mpl__snd_mixer_t *mixer, int handle);
int mpl__snd_mixer_set_vol(mpl__snd_mixer_t *mixer, float32 vol, float32 pan_lr, float32 pan_fb);
int mpl__snd_mixer_get_vol(mpl__snd_mixer_t *mixer, float32 *vol, float32 *pan_lr, float32 *pan_fb);
int mpl__snd_mixer_get_output_options(mpl__snd_mixer_t *mixer, mpl__snd_dev_output_t *opt);
int mpl__snd_mixer_get_latency(mpl__snd_mixer_t *mixer);   // ms
int mpl__snd_mixer_get_num_channels(mpl__snd_mixer_t *mixer);
int mpl__snd_mixer_get_num_active_channels(mpl__snd_mixer_t *mixer);
int mpl__snd_mixer_get_free_channel(mpl__snd_mixer_t *mixer);
int mpl__snd_mixer_is_channel_active(mpl__snd_mixer_t *mixer, int ch);
int mpl__snd_mixer_set_channel_vol(mpl__snd_mixer_t *mixer, int ch, float32 vol, float32 pan_lr, float32 pan_fb);
int mpl__snd_mixer_set_channel_freq(mpl__snd_mixer_t *mixer, int ch, float32 freq);
int mpl__snd_mixer_set_channel_pos(mpl__snd_mixer_t *mixer, int ch, float64 pos, int dir);
int mpl__snd_mixer_play_channel(mpl__snd_mixer_t *mixer, int ch, int handle, float32 freq, float32 vol, float32 pan_lr, float32 pan_fb, float64 pos, int dir);
int mpl__snd_mixer_stop_channel(mpl__snd_mixer_t *mixer, int ch);
int mpl__snd_mixer_set_option(mpl__snd_mixer_t *mixer, char *option, char *value);
int mpl__snd_mixer_get_option(mpl__snd_mixer_t *mixer, char *option, char **value);
int mpl__snd_mixer_get_proc(mpl__snd_mixer_t *mixer, char *name, void_func_t *proc);
int mpl__snd_mixer_set_call_back(mpl__snd_mixer_t *mixer, mpl__snd_call_back_t call_back);

// stream

int mpl__snd_stream_set_vol(mpl__snd_stream_t *stream, float32 vol, float32 pan_lr, float32 pan_fb);
int mpl__snd_stream_get_vol(mpl__snd_stream_t *stream, float32 *vol, float32 *pan_lr, float32 *pan_fb);
int mpl__snd_stream_get_output_options(mpl__snd_stream_t *stream, mpl__snd_dev_output_t *opt);
int mpl__snd_stream_set_input_format(mpl__snd_stream_t *stream, mpl__snd_stream_format_t *opt);
int mpl__snd_stream_get_input_format(mpl__snd_stream_t *stream, mpl__snd_stream_format_t *opt);
int mpl__snd_stream_get_latency(mpl__snd_stream_t *stream);   // ms
int mpl__snd_stream_get_buffer_size(mpl__snd_stream_t *stream); // ms
int mpl__snd_stream_set_option(mpl__snd_stream_t *stream, char *option, char *value);
int mpl__snd_stream_get_option(mpl__snd_stream_t *stream, char *option, char **value);
int mpl__snd_stream_get_proc(mpl__snd_stream_t *stream, char *name, void_func_t *proc);
int mpl__snd_stream_write(mpl__snd_stream_t *stream, void *data, int length);
int mpl__snd_stream_set_call_back(mpl__snd_stream_t *stream, mpl__snd_call_back_t call_back);


//////////////////////////////////////////////////////////////
// extensions

#define MPL__EXT_SND_MIXER_SUSTAIN_LOOP      "EXT_SUSTAIN_LOOP"
#define MPL__FUNC_SND_MIXER_SET_SUSTAIN_LOOP "mpl__snd_mixer_set_sustain_loop"
#define MPL__FUNC_SND_MIXER_END_SUSTAIN      "mpl__snd_mixer_end_sustain"

typedef int (*mpl__snd_mixer_set_sustain_loop_t)(mpl__snd_mixer_t *sndmx, int handle, int begin, int end, int mode);
typedef int (*mpl__snd_mixer_end_sustain_t)(mpl__snd_mixer_t *sndmx, int ch);


#endif
 

#ifndef string_h_n42378789234
#define string_h_n42378789234

#include <sys_cfg.h>

#define MPL__STRING_EQUAL     1
#define MPL__STRING_UNEQUAL   0

int mpl__string_cmp_char(char *str1, char *str2);
int mpl__string_cmp_wide_char(wide_char *str1, wide_char *str2);

#endif
 

#ifndef mp_xm_h_n42378789234789342
#define mp_xm_h_n42378789234789342

#include <vbf/vbf_util.h>
#include <mpl/sys/msg_box.h>
#include <mpl/mp.h>

#define MPL__XM_FREQ_TABLE_LINEAR             1

#define MPL__XM_SMP_LOOP_BITS                 0x03

#define MPL__XM_SMP_NO_LOOP                   0
#define MPL__XM_SMP_LOOP                      1
#define MPL__XM_SMP_BIDI_LOOP                 2

#define MPL__XM_SMP_16BIT                     16

// vol/pan envelope
#define MPL__XM_ENV_ON                        1
#define MPL__XM_ENV_SUSTAIN                   2
#define MPL__XM_ENV_LOOP                      4

#define MPL__XM_NO_NOTE                       98
#define MPL__XM_KEY_OFF                       97

#define MPL__XM_EFF_ARPEGGIO                  0x00
#define MPL__XM_EFF_PORTA_UP                  0x01
#define MPL__XM_EFF_PORTA_DOWN                0x02
#define MPL__XM_EFF_PORTA                     0x03
#define MPL__XM_EFF_VIB                       0x04
#define MPL__XM_EFF_PORTA_VOL_SLIDE           0x05
#define MPL__XM_EFF_VIB_VOL_SLIDE             0x06
#define MPL__XM_EFF_TREMOLO                   0x07
#define MPL__XM_EFF_PAN                       0x08
#define MPL__XM_EFF_SMP_OFFSET                0x09
#define MPL__XM_EFF_VOL_SLIDE                 0x0A
#define MPL__XM_EFF_POS_JUMP                  0x0B
#define MPL__XM_EFF_VOL                       0x0C
#define MPL__XM_EFF_PAT_BREAK                 0x0D
#define MPL__XM_EFF_MOD_EXT                   0x0E
#define MPL__XM_EFF_SPEED                     0x0F
#define MPL__XM_EFF_GLOB_VOL                  0x10
#define MPL__XM_EFF_GLOB_VOL_SLIDE            0x11
#define MPL__XM_EFF_KEY_OFF                   0x14
#define MPL__XM_EFF_ENV_POS                   0x15
#define MPL__XM_EFF_PAN_SLIDE                 0x19
#define MPL__XM_EFF_RETRIG_VOL_SLIDE          0x1B
#define MPL__XM_EFF_TREMOR                    0x1D
#define MPL__XM_EFF_EXTRA_FINE_PORTA          0x21

// Exx effects
#define MPL__XM_EXT_EFF_FINE_PORTA_UP         0x10
#define MPL__XM_EXT_EFF_FINE_PORTA_DOWN       0x20
#define MPL__XM_EXT_EFF_GLISSANDO             0x30
#define MPL__XM_EXT_EFF_VIB_WAVE              0x40
#define MPL__XM_EXT_EFF_FINE_TUNE             0x50
#define MPL__XM_EXT_EFF_PAT_LOOP              0x60
#define MPL__XM_EXT_EFF_TREMOLO_WAVE          0x70
#define MPL__XM_EXT_EFF_PAN                   0x80
#define MPL__XM_EXT_EFF_RETRIG                0x90
#define MPL__XM_EXT_EFF_FINE_VOL_SLIDE_UP     0xA0
#define MPL__XM_EXT_EFF_FINE_VOL_SLIDE_DOWN   0xB0
#define MPL__XM_EXT_EFF_NOTE_CUT              0xC0
#define MPL__XM_EXT_EFF_NOTE_DELAY            0xD0
#define MPL__XM_EXT_EFF_PAT_DELAY             0xE0

#define MPL__XM_VOL_EFF_VOL_SLIDE_DOWN        0x60
#define MPL__XM_VOL_EFF_VOL_SLIDE_UP          0x70
#define MPL__XM_VOL_EFF_FINE_VOL_SLIDE_DOWN   0x80
#define MPL__XM_VOL_EFF_FINE_VOL_SLIDE_UP     0x90
#define MPL__XM_VOL_EFF_VIB_SPEED             0xA0
#define MPL__XM_VOL_EFF_VIB                   0xB0
#define MPL__XM_VOL_EFF_PAN                   0xC0
#define MPL__XM_VOL_EFF_PAN_SLIDE_LEFT        0xD0
#define MPL__XM_VOL_EFF_PAN_SLIDE_RIGHT       0xE0
#define MPL__XM_VOL_EFF_PORTA                 0xF0

#define MPL__XM_CTRL_VOL                      1
#define MPL__XM_CTRL_PER                      2
#define MPL__XM_CTRL_START                    4
#define MPL__XM_CTRL_STOP                     8

#define MPL__XM_PL_CTRL_BPM                   1
#define MPL__XM_PL_CTRL_VOL                   2

typedef struct {
	int				index;

	char			name[23];
	
	int				loop_begin;
	int				loop_end;

	int				vol;
	int				pan;

	int				rel_note;
	int				finetune;

	int				length;
	int				format;
	void*			data;
} mpl__xm_sample_t;

typedef struct {
	int x, y;
} mpl__xm_point_t;

typedef struct {
	char			name[23];

	int				note2smp[96];

	mpl__xm_point_t vol_env[12];
	int				vol_num;
	int				vol_sus;
	int				vol_loop_beg;
	int				vol_loop_end;
	int				vol_type;

	int             vol_fade_out;

	mpl__xm_point_t	pan_env[12];
	int				pan_num;
	int				pan_sus;
	int				pan_loop_beg;
	int				pan_loop_end;
	int				pan_type;

	int				vib_type;
	int				vib_sweep;
	int				vib_depth;
	int				vib_rate;

	int				smp_num;
	mpl__xm_sample_t *smp;
} mpl__xm_inst_t;

typedef struct {
	u8				key;
	u8				inst;
	u8				volume;
	u8				effect;
	u8				param;
} mpl__xm_cell_t;

typedef struct {
	char			title[21];
	char			tracker[21];

	int				restart_pos;
	int				length;
	int				order[256];

	int				inst_num;
	mpl__xm_inst_t*		inst;
	int				smp_index_num;

	int				pat_num;
	mpl__xm_cell_t*		pat[256];
	int				pat_length[256];

	int				ch_num;
	int				bpm, speed;
	int				freq_table;
} mpl__xm_t;

typedef struct {
	int				active;
	int				ctrl;
	int				key;
	int				real_key;
	int				key_off;
	int				eff;

	int				inst;
	mpl__xm_inst_t	*p_inst;
	mpl__xm_sample_t *p_smp;
//	double			sample_pos;
	int				smp_offset;

	int				vol;
	int				vol_delta;
	int				env_vol;
	int				env_vol_tick;
	int				fade_out_vol;

	int				pan;
	int				pan_delta;
	int				env_pan;
	int				env_pan_tick;

	int				per;
	int				per_delta;
	int				dst_per;

	int				porta_period;
	int				porta_speed;

	int				vib_speed;
	int				vib_depth;
	int				vib_pos;

	int				inst_vib_sweep_pos;
	int				inst_vib_pos;

	int				tremolo_speed;
	int				tremolo_depth;
	int				tremolo_pos;

	int				vol_slide;
	int				fvol_slide_up;
	int				fvol_slide_down;
	int				vib_vol_slide;
	int				porta_vol_slide;
	int				retrig_vol_slide;
	int				pan_slide;

	int				loop_row;
	int				loop_num;

	int				porta_up;
	int				porta_down;
	int				fporta_up;
	int				fporta_down;
	int				efporta_up;
	int				efporta_down;

	int				tremor_pos;
	int				tremor_spd;

	int				wave_control;
} mpl__mp_xm_chan_t;

typedef struct {
	mpl__xm_t		*xm;

	int				pat_cur;
	int				pat_next;
	int				row_cur;
	int				row_next;

	int				bpm;
	int				speed;
	int				tick_cur;
	int				delay;
	int				ctrl;
	int				paused;

	mpl__mp_xm_chan_t ch[64];

	int				smp_handle[300];
	int             smp_fine_tune[300];

	float32			vol;
	int				glob_vol, glob_vol_slide;

	int				loop;

	mpl__snd_dev_t	*dev;
	mpl__snd_mixer_t *mixer;
	mpl__msg_box_t	*mb;
} mpl__mp_xm_t;

int mpl__mp_xm_construct(mpl__xm_t *xm, mpl__mp_t *mp, mpl__msg_box_t *mb);
int mpl__mp_xm_destruct(mpl__mp_t *mp);

#endif
 

#ifndef ml_xm_h_n4378789243234890
#define ml_xm_h_n4378789243234890

#include <mpl/mp_xm.h>

int mpl__xm_load(vbf_t *file, mpl__xm_t *xm);
int mpl__xm_destruct(mpl__xm_t *xm);

#endif
 

#ifndef dsp_std_h_n43782784923
#define dsp_std_h_n43782784923

#include <mpl/snddev.h>

int mpl__dsp_add(void *src, void *dst, int size, int ch_num, float32 vol, int format);
int mpl__dsp_sub(void *src, void *dst, int size, int ch_num, float32 vol, int format);
int mpl__dsp_move(void *src, void *dst, int size, int ch_num, float32 vol, int format);
int mpl__dsp_conv_format(void *src, void *dst, int src_format, int dst_format, int size, int ch_num, float32 vol);

#endif
 

#ifndef mx_std_h_n37842789342789
#define mx_std_h_37842789342789

// standard mixer

#include <mpl/mx.h>

typedef struct {
	int					exists;
	mpl__snd_mixer_smp_t smp;
	int					sus_loop_beg;
	int					sus_loop_end;
	int					sus_loop_mode;
//	int					locked;
} mpl__mx_std_smp_t;

typedef struct {
	int					playing;
	int					smp;
	float32				patch[8];
	float32				vol_left, vol_right, vol_center;
	float32				vol_left_ramp, vol_right_ramp, vol_center_ramp;
	int					vol_left_ramp_num, vol_right_ramp_num, vol_center_ramp_num;
	float32				vol_left_dst, vol_right_dst, vol_center_dst;
	float32				vol, pan_lr;
	float32				freq;
	float64				pos;
	int					dir;
	int					loop_beg;
	int					loop_end;
	int					loop_mode;
} mpl__mx_std_ch_t;

typedef struct {
	mpl__mx_std_smp_t	*smp;
	int					smp_num;
	mpl__mx_std_ch_t	*ch;
	int					ch_num;

	int					latency;
	int					paused;
	int					mem_usage;
	int					qual;
	mpl__snd_dev_output_t output;
	float32				vol_local;
	float32				pan_lr_local;
	float32				pan_fb_local;
	float32				vol_global;
	float32				pan_lr_global;
	float32				pan_fb_global;

	float32				ramp;
	float32				dc_spd[2], dc_pos[2];
//	float32				quant[2];


	mpl__snd_mixer_t	iface;
	mpl__snd_call_back_t call_back;
	float64				count_down_frac;
	int					count_down;
} mpl__mx_std_t;

int  mpl__mx_std_create(mpl__mixer_t **mixer);
void mpl__mx_std_destroy(mpl__mixer_t *mixer);

#endif
 

#ifndef critsect_h_n423784238
#define critsect_h_n423784238

#include <windows.h>
#include <sys_cfg.h>
#include <mpl/error.h>

typedef CRITICAL_SECTION mpl__critical_section_t;

int mpl__cs_create(mpl__critical_section_t **cs);
int mpl__cs_destroy(mpl__critical_section_t *cs);
int mpl__cs_construct(mpl__critical_section_t *cs);
int mpl__cs_destruct(mpl__critical_section_t *cs);
int mpl__cs_enter(mpl__critical_section_t *cs);
int mpl__cs_leave(mpl__critical_section_t *cs);

#endif
 

#ifndef mem_h_n78923478924
#define mem_h_n78923478924

#include <sys_cfg.h>
#include <mpl/error.h>

typedef int mpl__mem_size_t;

int mpl__mem_init();
int mpl__mem_alloc(mpl__mem_size_t size, void **mem);
int mpl__mem_get_size(mpl__mem_size_t *size, void *mem);
int mpl__mem_resize(mpl__mem_size_t newsize, int onlyexpand, void **mem);
int mpl__mem_free(void *mem);
int mpl__mem_copy(void *src, void *dst, mpl__mem_size_t size);
int mpl__mem_set_zero(void *mem, mpl__mem_size_t size);

#endif
 

#ifndef msg_box_h_n43789423798
#define msg_box_h_n43789423798

#include <sys_cfg.h>
#include <mpl/sys/critsect.h>
#include <mpl/error.h>

typedef struct mpl__msg_s {
	int					msg;
	int					param[8];
	void				*data;
} mpl__msg_t;

typedef struct mpl__msg_box_s {
	mpl__msg_t				*msg;
	int						max;
	int						cnt;
	int						first;
	int						last;
	mpl__critical_section_t	cs;
} mpl__msg_box_t;

int mpl__msg_box_create(mpl__msg_box_t **mb, int max);
int mpl__msg_box_destroy(mpl__msg_box_t *mb);
int mpl__msg_box_construct(mpl__msg_box_t *mb, int max);
int mpl__msg_box_destruct(mpl__msg_box_t *mb);
int mpl__msg_box_send(mpl__msg_box_t *mb, mpl__msg_t *msg);
int mpl__msg_box_receive(mpl__msg_box_t *mb, mpl__msg_t *msg);

#endif