np2/sound/vermouth/midiout.c - diff

Return to midiout.c CVS log

Up to [RetroPC.NET] / np2 / sound / vermouth

Diff for /np2/sound/vermouth/midiout.c between versions 1.14 and 1.17

version 1.14, 2006/12/16 09:43:24	version 1.17, 2006/12/16 22:23:24
Line 2	Line 2
#include "midiout.h"	#include "midiout.h"


#define MIDIOUT_VERSION 0x115	#define MIDIOUT_VERSION 0x116
#define MIDIOUT_VERSTRING "VERMOUTH 1.15"	#define MIDIOUT_VERSTRING "VERMOUTH 1.16"

static const char vermouthver[] = MIDIOUT_VERSTRING;	static const char vermouthver[] = MIDIOUT_VERSTRING;

Line 15 static const int gaintbl[24+1] =	Line 15 static const int gaintbl[24+1] =

// ---- voice	// ---- voice

static void voice_volupdate(VOICE v) {	#define VOICEHDLPTR(hdl) ((hdl)->voice)
	#define VOICEHDLEND(hdl) (VOICE)((hdl) + 1)

	static void VERMOUTHCL voice_volupdate(VOICE v) {

CHANNEL ch;	CHANNEL ch;
int vol;	int vol;
Line 63 static void voice_volupdate(VOICE v) {	Line 66 static void voice_volupdate(VOICE v) {
#endif	#endif
}	}

static INSTLAYER selectlayer(VOICE v, INSTRUMENT inst) {	static INSTLAYER VERMOUTHCL selectlayer(VOICE v, INSTRUMENT inst) {

int layers;	int layers;
INSTLAYER layer;	INSTLAYER layer;
Line 110 static INSTLAYER selectlayer(VOICE v, IN	Line 113 static INSTLAYER selectlayer(VOICE v, IN
return(layersel);	return(layersel);
}	}

static void freq_update(VOICE v) {	static void VERMOUTHCL freq_update(VOICE v) {

CHANNEL ch;	CHANNEL ch;
float step;	float step;
Line 134 static void freq_update(VOICE v) {	Line 137 static void freq_update(VOICE v) {
v->sampstep = (int)step;	v->sampstep = (int)step;
}	}

static void voice_on(MIDIHDL midi, CHANNEL ch, VOICE v, int key, int vel) {	static void VERMOUTHCL voice_on(MIDIHDL hdl, CHANNEL ch, VOICE v, int key,
	int vel) {

INSTRUMENT inst;	INSTRUMENT inst;
INSTLAYER layer;	INSTLAYER layer;
Line 158 static void voice_on(MIDIHDL midi, CHANN	Line 162 static void voice_on(MIDIHDL midi, CHANN
#if !defined(MIDI_GMONLY)	#if !defined(MIDI_GMONLY)
inst = ch->rhythm[key];	inst = ch->rhythm[key];
if (inst == NULL) {	if (inst == NULL) {
inst = midi->bank0[1][key];	inst = hdl->bank0[1][key];
}	}
#else	#else
inst = midi->bank0[1][key];	inst = hdl->bank0[1][key];
#endif	#endif
if (inst == NULL) {	if (inst == NULL) {
return;	return;
Line 237 static void voice_on(MIDIHDL midi, CHANN	Line 241 static void voice_on(MIDIHDL midi, CHANN
v->flag \|= VOICE_FIXPITCH;	v->flag \|= VOICE_FIXPITCH;
}	}
else {	else {
v->freq = (float)layer->samprate / (float)midi->samprate *	v->freq = (float)layer->samprate / (float)hdl->samprate *
(float)v->frequency / (float)layer->freqroot;	(float)v->frequency / (float)layer->freqroot;
}	}
voice_setphase(v, VOICE_ON);	voice_setphase(v, VOICE_ON);
Line 255 static void voice_on(MIDIHDL midi, CHANN	Line 259 static void voice_on(MIDIHDL midi, CHANN
envelope_updates(v);	envelope_updates(v);
}	}

static void voice_off(VOICE v) {	static void VERMOUTHCL voice_off(VOICE v) {

voice_setphase(v, VOICE_OFF);	voice_setphase(v, VOICE_OFF);
if (v->sample->mode & MODE_ENVELOPE) {	if (v->sample->mode & MODE_ENVELOPE) {
Line 265 static void voice_off(VOICE v) {	Line 269 static void voice_off(VOICE v) {
}	}
}	}

static void allresetvoices(MIDIHDL midi) {	static void VERMOUTHCL allresetvoices(MIDIHDL hdl) {

VOICE v;	VOICE v;
VOICE vterm;	VOICE vterm;

v = midi->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
voice_setfree(v);	voice_setfree(v);
v++;	v++;
Line 281 static void allresetvoices(MIDIHDL midi)	Line 285 static void allresetvoices(MIDIHDL midi)

// ---- key	// ---- key

static void key_on(MIDIHDL midi, CHANNEL ch, int key, int vel) {	static void VERMOUTHCL key_on(MIDIHDL hdl, CHANNEL ch, int key, int vel) {

VOICE v;	VOICE v;
VOICE v1;	VOICE v1;
Line 290 static void key_on(MIDIHDL midi, CHANNEL	Line 294 static void key_on(MIDIHDL midi, CHANNEL
int volmin;	int volmin;

v = NULL;	v = NULL;
v1 = midi->voice;	v1 = VOICEHDLPTR(hdl);
v2 = v1 + VOICE_MAX;	v2 = VOICEHDLEND(hdl);
do {	do {
v2--;	v2--;
if (v2->phase == VOICE_FREE) {	if (v2->phase == VOICE_FREE) {
Line 305 static void key_on(MIDIHDL midi, CHANNEL	Line 309 static void key_on(MIDIHDL midi, CHANNEL
} while(v1 < v2);	} while(v1 < v2);

if (v != NULL) {	if (v != NULL) {
voice_on(midi, ch, v, key, vel);	voice_on(hdl, ch, v, key, vel);
return;	return;
}	}

volmin = 0x7fffffff;	volmin = 0x7fffffff;
v2 = v1 + VOICE_MAX;	v2 = VOICEHDLEND(hdl);
do {	do {
v2--;	v2--;
if (!(v2->phase & (VOICE_ON \| VOICE_REL))) {	if (!(v2->phase & (VOICE_ON \| VOICE_REL))) {
Line 327 static void key_on(MIDIHDL midi, CHANNEL	Line 331 static void key_on(MIDIHDL midi, CHANNEL

if (v != NULL) {	if (v != NULL) {
voice_setfree(v);	voice_setfree(v);
voice_on(midi, ch, v, key, vel);	voice_on(hdl, ch, v, key, vel);
}	}
}	}

static void key_off(MIDIHDL midi, CHANNEL ch, int key) {	static void VERMOUTHCL key_off(MIDIHDL hdl, CHANNEL ch, int key) {

VOICE v;	VOICE v;
VOICE vterm;	VOICE vterm;

v = midi->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
if ((v->phase & VOICE_ON) &&	if ((v->phase & VOICE_ON) &&
(v->channel == ch) && (v->note == key)) {	(v->channel == ch) && (v->note == key)) {
Line 353 static void key_off(MIDIHDL midi, CHANNE	Line 357 static void key_off(MIDIHDL midi, CHANNE
} while(v < vterm);	} while(v < vterm);
}	}

static void key_pressure(MIDIHDL midi, CHANNEL ch, int key, int vel) {	static void VERMOUTHCL key_pressure(MIDIHDL hdl, CHANNEL ch, int key,
	int vel) {

VOICE v;	VOICE v;
VOICE vterm;	VOICE vterm;

v = midi->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
if ((v->phase & VOICE_ON) &&	if ((v->phase & VOICE_ON) &&
(v->channel == ch) && (v->note == key)) {	(v->channel == ch) && (v->note == key)) {
Line 375 static void key_pressure(MIDIHDL midi, C	Line 380 static void key_pressure(MIDIHDL midi, C

// ---- control	// ---- control

static void volumeupdate(MIDIHDL midi, CHANNEL ch) {	static void VERMOUTHCL volumeupdate(MIDIHDL hdl, CHANNEL ch) {

VOICE v;	VOICE v;
VOICE vterm;	VOICE vterm;

#if defined(VOLUME_ACURVE)	#if defined(VOLUME_ACURVE)
ch->level = (midi->level * acurve[ch->volume] * ch->expression) >> 15;	ch->level = (hdl->level * acurve[ch->volume] * ch->expression) >> 15;
#else	#else
ch->level = (midi->level * ch->volume * ch->expression) >> 14;	ch->level = (hdl->level * ch->volume * ch->expression) >> 14;
#endif	#endif
v = midi->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
if ((v->phase & (VOICE_ON \| VOICE_SUSTAIN)) && (v->channel == ch)) {	if ((v->phase & (VOICE_ON \| VOICE_SUSTAIN)) && (v->channel == ch)) {
voice_volupdate(v);	voice_volupdate(v);
Line 396 static void volumeupdate(MIDIHDL midi, C	Line 401 static void volumeupdate(MIDIHDL midi, C
} while(v < vterm);	} while(v < vterm);
}	}

static void pedaloff(MIDIHDL midi, CHANNEL ch) {	static void VERMOUTHCL pedaloff(MIDIHDL hdl, CHANNEL ch) {

VOICE v;	VOICE v;
VOICE vterm;	VOICE vterm;

v = midi->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
if ((v->phase & VOICE_SUSTAIN) && (v->channel == ch)) {	if ((v->phase & VOICE_SUSTAIN) && (v->channel == ch)) {
voice_off(v);	voice_off(v);
Line 411 static void pedaloff(MIDIHDL midi, CHANN	Line 416 static void pedaloff(MIDIHDL midi, CHANN
} while(v < vterm);	} while(v < vterm);
}	}

static void allsoundsoff(MIDIHDL midi, CHANNEL ch) {	static void VERMOUTHCL allsoundsoff(MIDIHDL hdl, CHANNEL ch) {

VOICE v;	VOICE v;
VOICE vterm;	VOICE vterm;

v = midi->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
if ((v->phase != VOICE_FREE) && (v->channel == ch)) {	if ((v->phase != VOICE_FREE) && (v->channel == ch)) {
voice_setphase(v, VOICE_REL);	voice_setphase(v, VOICE_REL);
Line 427 static void allsoundsoff(MIDIHDL midi, C	Line 432 static void allsoundsoff(MIDIHDL midi, C
} while(v < vterm);	} while(v < vterm);
}	}

static void resetallcontrollers(CHANNEL ch) {	static void VERMOUTHCL resetallcontrollers(CHANNEL ch) {

ch->flag &= CHANNEL_MASK;	ch->flag &= CHANNEL_MASK;
if (ch->flag == 9) {	if (ch->flag == 9) {
Line 439 static void resetallcontrollers(CHANNEL	Line 444 static void resetallcontrollers(CHANNEL
ch->pitchfactor = 1.0;	ch->pitchfactor = 1.0;
}	}

static void allnotesoff(MIDIHDL midi, CHANNEL ch) {	static void VERMOUTHCL allnotesoff(MIDIHDL hdl, CHANNEL ch) {

VOICE v;	VOICE v;
VOICE vterm;	VOICE vterm;

v = midi->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
#if 1	#if 1
if ((v->phase & (VOICE_ON \| VOICE_SUSTAIN)) && (v->channel == ch)) {	if ((v->phase & (VOICE_ON \| VOICE_SUSTAIN)) && (v->channel == ch)) {
Line 465 static void allnotesoff(MIDIHDL midi, CH	Line 470 static void allnotesoff(MIDIHDL midi, CH
} while(v < vterm);	} while(v < vterm);
}	}

static void ctrlchange(MIDIHDL midi, CHANNEL ch, int ctrl, int val) {	static void VERMOUTHCL ctrlchange(MIDIHDL hdl, CHANNEL ch, int ctrl,
	int val) {

val &= 0x7f;	val &= 0x7f;
switch(ctrl & 0x7f) {	switch(ctrl & 0x7f) {
Line 492 static void ctrlchange(MIDIHDL midi, CHA	Line 498 static void ctrlchange(MIDIHDL midi, CHA

case CTRL_VOLUME:	case CTRL_VOLUME:
ch->volume = val;	ch->volume = val;
volumeupdate(midi, ch);	volumeupdate(hdl, ch);
break;	break;

case CTRL_PANPOT:	case CTRL_PANPOT:
Line 501 static void ctrlchange(MIDIHDL midi, CHA	Line 507 static void ctrlchange(MIDIHDL midi, CHA

case CTRL_EXPRESS:	case CTRL_EXPRESS:
ch->expression = val;	ch->expression = val;
volumeupdate(midi, ch);	volumeupdate(hdl, ch);
break;	break;

case CTRL_PEDAL:	case CTRL_PEDAL:
if (val == 0) {	if (val == 0) {
ch->flag &= ~CHANNEL_SUSTAIN;	ch->flag &= ~CHANNEL_SUSTAIN;
pedaloff(midi, ch);	pedaloff(hdl, ch);
}	}
else {	else {
ch->flag \|= CHANNEL_SUSTAIN;	ch->flag \|= CHANNEL_SUSTAIN;
Line 523 static void ctrlchange(MIDIHDL midi, CHA	Line 529 static void ctrlchange(MIDIHDL midi, CHA
break;	break;

case CTRL_SOUNDOFF:	case CTRL_SOUNDOFF:
allsoundsoff(midi, ch);	allsoundsoff(hdl, ch);
break;	break;

case CTRL_RESETCTRL:	case CTRL_RESETCTRL:
resetallcontrollers(ch);	resetallcontrollers(ch);
break;	/FALLTHROUGH/

case CTRL_NOTEOFF:	case CTRL_NOTEOFF:
allnotesoff(midi, ch);	allnotesoff(hdl, ch);
break;	break;

case CTRL_MONOON:	case CTRL_MONOON:
Line 548 static void ctrlchange(MIDIHDL midi, CHA	Line 554 static void ctrlchange(MIDIHDL midi, CHA
}	}
}	}

static void progchange(MIDIHDL midi, CHANNEL ch, int val) {	static void VERMOUTHCL progchange(MIDIHDL hdl, CHANNEL ch, int val) {

#if !defined(MIDI_GMONLY)	#if !defined(MIDI_GMONLY)
MIDIMOD module;	MIDIMOD mod;
INSTRUMENT *bank;	INSTRUMENT *bank;
INSTRUMENT inst;	INSTRUMENT inst;

module = midi->module;	mod = hdl->module;
inst = NULL;	inst = NULL;
if (ch->bank < MIDI_BANKS) {	if (ch->bank < MIDI_BANKS) {
bank = module->tone[ch->bank * 2];	bank = mod->tone[ch->bank * 2];
if (bank) {	if (bank) {
inst = bank[val];	inst = bank[val];
}	}
}	}
if (inst == NULL) {	if (inst == NULL) {
bank = midi->bank0[0];	bank = hdl->bank0[0];
inst = bank[val];	inst = bank[val];
}	}
ch->inst = inst;	ch->inst = inst;

bank = NULL;	bank = NULL;
if (ch->bank < MIDI_BANKS) {	if (ch->bank < MIDI_BANKS) {
bank = module->tone[ch->bank * 2 + 1];	bank = mod->tone[ch->bank * 2 + 1];
}	}
if (bank == NULL) {	if (bank == NULL) {
bank = midi->bank0[1];	bank = hdl->bank0[1];
}	}
ch->rhythm = bank;	ch->rhythm = bank;
#else	#else
ch->inst = midi->bank0[0][val];	ch->inst = hdl->bank0[0][val];
#endif	#endif
ch->program = val;	ch->program = val;
}	}

static void chpressure(MIDIHDL midi, CHANNEL ch, int vel) {	static void VERMOUTHCL chpressure(MIDIHDL hdl, CHANNEL ch, int vel) {

VOICE v;	VOICE v;
VOICE vterm;	VOICE vterm;

v = midi->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
if ((v->phase & VOICE_ON) && (v->channel == ch)) {	if ((v->phase & VOICE_ON) && (v->channel == ch)) {
v->velocity = vel;	v->velocity = vel;
Line 601 static void chpressure(MIDIHDL midi, CHA	Line 607 static void chpressure(MIDIHDL midi, CHA
} while(v < vterm);	} while(v < vterm);
}	}

static void pitchbendor(MIDIHDL midi, CHANNEL ch, int val1, int val2) {	static void VERMOUTHCL pitchbendor(MIDIHDL hdl, CHANNEL ch, int val1,
	int val2) {

VOICE v;	VOICE v;
VOICE vterm;	VOICE vterm;
Line 619 static void pitchbendor(MIDIHDL midi, CH	Line 626 static void pitchbendor(MIDIHDL midi, CH
ch->pitchfactor = bendhtbl[(val1 >> (6 + 7)) + 24] *	ch->pitchfactor = bendhtbl[(val1 >> (6 + 7)) + 24] *
bendltbl[(val1 >> 7) & 0x3f];	bendltbl[(val1 >> 7) & 0x3f];
}	}
v = midi->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
if ((v->phase != VOICE_FREE) && (v->channel == ch)) {	if ((v->phase != VOICE_FREE) && (v->channel == ch)) {
freq_update(v);	freq_update(v);
Line 630 static void pitchbendor(MIDIHDL midi, CH	Line 637 static void pitchbendor(MIDIHDL midi, CH
}	}
}	}

static void allvolupdate(MIDIHDL midi) {	static void VERMOUTHCL allvolupdate(MIDIHDL hdl) {

int level;	int level;
CHANNEL ch;	CHANNEL ch;
Line 638 static void allvolupdate(MIDIHDL midi) {	Line 645 static void allvolupdate(MIDIHDL midi) {
VOICE v;	VOICE v;
VOICE vterm;	VOICE vterm;

level = gaintbl[midi->gain + 16] >> 1;	level = gaintbl[hdl->gain + 16] >> 1;
level *= midi->master;	level *= hdl->master;
midi->level = level;	hdl->level = level;
ch = midi->channel;	ch = hdl->channel;
chterm = ch + 16;	chterm = ch + CHANNEL_MAX;
do {	do {
ch->level = (level * ch->volume * ch->expression) >> 14;	ch->level = (level * ch->volume * ch->expression) >> 14;
ch++;	ch++;
} while(ch < chterm);	} while(ch < chterm);
v = midi->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
if (v->phase & (VOICE_ON \| VOICE_SUSTAIN)) {	if (v->phase & (VOICE_ON \| VOICE_SUSTAIN)) {
voice_volupdate(v);	voice_volupdate(v);
Line 659 static void allvolupdate(MIDIHDL midi) {	Line 666 static void allvolupdate(MIDIHDL midi) {
}	}

#if defined(ENABLE_GSRX)	#if defined(ENABLE_GSRX)
static void allresetmidi(MIDIHDL midi, BOOL gs)	static void VERMOUTHCL allresetmidi(MIDIHDL hdl, BOOL gs)
#else	#else
#define allresetmidi(m, g) _allresetmidi(m)	#define allresetmidi(m, g) _allresetmidi(m)
static void _allresetmidi(MIDIHDL midi)	static void VERMOUTHCL _allresetmidi(MIDIHDL hdl)
#endif	#endif
{	{
CHANNEL ch;	CHANNEL ch;
CHANNEL chterm;	CHANNEL chterm;
UINT flag;	UINT flag;

midi->master = 127;	hdl->master = 127;
ch = midi->channel;	ch = hdl->channel;
chterm = ch + 16;	chterm = ch + CHANNEL_MAX;
ZeroMemory(ch, sizeof(_CHANNEL) * 16);	ZeroMemory(ch, sizeof(_CHANNEL) * CHANNEL_MAX);
flag = 0;	flag = 0;
do {	do {
ch->flag = flag++;	ch->flag = flag++;
Line 681 static void _allresetmidi(MIDIHDL midi)	Line 688 static void _allresetmidi(MIDIHDL midi)
ch->bank = 0;	ch->bank = 0;
#endif	#endif
ch->panpot = 64;	ch->panpot = 64;
progchange(midi, ch, 0);	progchange(hdl, ch, 0);
resetallcontrollers(ch);	resetallcontrollers(ch);
#if defined(ENABLE_GSRX)	#if defined(ENABLE_GSRX)
ch->keyshift = 0x40;	ch->keyshift = 0x40;
Line 700 static void _allresetmidi(MIDIHDL midi)	Line 707 static void _allresetmidi(MIDIHDL midi)
#endif	#endif
ch++;	ch++;
} while(ch < chterm);	} while(ch < chterm);
allresetvoices(midi);	allresetvoices(hdl);
allvolupdate(midi);	allvolupdate(hdl);
}	}


Line 714 VEXTERN UINT VEXPORT midiout_getver(char	Line 721 VEXTERN UINT VEXPORT midiout_getver(char
return((MIDIOUT_VERSION << 8) \| 0x00);	return((MIDIOUT_VERSION << 8) \| 0x00);
}	}

VEXTERN MIDIHDL VEXPORT midiout_create(MIDIMOD module, UINT worksize) {	VEXTERN MIDIHDL VEXPORT midiout_create(MIDIMOD mod, UINT worksize) {

UINT size;	UINT size;
MIDIHDL ret;	MIDIHDL ret;

if (module == NULL) {	if (mod == NULL) {
return(NULL);	return(NULL);
}	}
worksize = min(worksize, 512);	worksize = min(worksize, 512);
Line 729 VEXTERN MIDIHDL VEXPORT midiout_create(M	Line 736 VEXTERN MIDIHDL VEXPORT midiout_create(M
size += sizeof(_SAMPLE) * worksize;	size += sizeof(_SAMPLE) * worksize;
ret = (MIDIHDL)_MALLOC(size, "MIDIHDL");	ret = (MIDIHDL)_MALLOC(size, "MIDIHDL");
if (ret) {	if (ret) {
midimod_lock(module);	midimod_lock(mod);
ZeroMemory(ret, size);	ZeroMemory(ret, size);
ret->samprate = module->samprate;	ret->samprate = mod->samprate;
ret->worksize = worksize;	ret->worksize = worksize;
ret->module = module;	ret->module = mod;
// ret->master = 127;	// ret->master = 127;
ret->bank0[0] = module->tone[0];	ret->bank0[0] = mod->tone[0];
ret->bank0[1] = module->tone[1];	ret->bank0[1] = mod->tone[1];
ret->sampbuf = (SINT32 *)(ret + 1);	ret->sampbuf = (SINT32 *)(ret + 1);
ret->resampbuf = (SAMPLE)(ret->sampbuf + worksize * 2);	ret->resampbuf = (SAMPLE)(ret->sampbuf + worksize * 2);
allresetmidi(ret, FALSE);	allresetmidi(ret, FALSE);
Line 746 VEXTERN MIDIHDL VEXPORT midiout_create(M	Line 753 VEXTERN MIDIHDL VEXPORT midiout_create(M

VEXTERN void VEXPORT midiout_destroy(MIDIHDL hdl) {	VEXTERN void VEXPORT midiout_destroy(MIDIHDL hdl) {

MIDIMOD module;	MIDIMOD mod;

if (hdl) {	if (hdl) {
module = hdl->module;	mod = hdl->module;
_MFREE(hdl);	_MFREE(hdl);
midimod_lock(module);	midimod_lock(mod);
}	}
}	}

Line 808 VEXTERN void VEXPORT midiout_shortmsg(MI	Line 815 VEXTERN void VEXPORT midiout_shortmsg(MI
}	}
}	}

static void longmsg_uni(MIDIHDL hdl, const UINT8 *msg, UINT size) {	static void VERMOUTHCL longmsg_uni(MIDIHDL hdl, const UINT8 *msg, UINT size) {

if ((size >= 6) && (msg[2] == 0x7f)) {	if ((size >= 6) && (msg[2] == 0x7f)) {
switch(msg[3]) {	switch(msg[3]) {
Line 822 static void longmsg_uni(MIDIHDL hdl, con	Line 829 static void longmsg_uni(MIDIHDL hdl, con
}	}
}	}

static void longmsg_gm(MIDIHDL hdl, const UINT8 *msg, UINT size) {	static void VERMOUTHCL longmsg_gm(MIDIHDL hdl, const UINT8 *msg, UINT size) {

if ((size >= 6) && (msg[2] == 0x7f)) {	if ((size >= 6) && (msg[2] == 0x7f)) {
switch(msg[3]) {	switch(msg[3]) {
Line 842 static void longmsg_gm(MIDIHDL hdl, cons	Line 849 static void longmsg_gm(MIDIHDL hdl, cons
}	}
}	}

static void rolandcmd4(MIDIHDL hdl, UINT addr, UINT8 data) {	static void VERMOUTHCL rolandcmd4(MIDIHDL hdl, UINT addr, UINT8 data) {

UINT part;	UINT part;
CHANNEL ch;	CHANNEL ch;
Line 998 static void rolandcmd4(MIDIHDL hdl, UINT	Line 1005 static void rolandcmd4(MIDIHDL hdl, UINT
}	}
}	}

static void longmsg_roland(MIDIHDL hdl, const UINT8 *msg, UINT size) {	static void VERMOUTHCL longmsg_roland(MIDIHDL hdl, const UINT8 *msg,
	UINT size) {

UINT addr;	UINT addr;
UINT8 data;	UINT8 data;
Line 1080 VEXTERN const SINT32 * VEXPORT midiout_g	Line 1088 VEXTERN const SINT32 * VEXPORT midiout_g
}	}
buf = hdl->sampbuf;	buf = hdl->sampbuf;
ZeroMemory(buf, size * 2 * sizeof(SINT32));	ZeroMemory(buf, size * 2 * sizeof(SINT32));
v = hdl->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
playing = FALSE;	playing = FALSE;
do {	do {
if (v->phase != VOICE_FREE) {	if (v->phase != VOICE_FREE) {
Line 1131 moget_err:	Line 1139 moget_err:
return(NULL);	return(NULL);
}	}

	static UINT VERMOUTHCL preparepcm(MIDIHDL hdl, UINT size)
	{
	UINT step;
	VOICE v;
	VOICE vterm;
	SINT32 *buf;
	SAMPLE src;
	SAMPLE srcterm;
	UINT cnt;
	UINT pos;
	UINT rem;

	step = min(size, hdl->worksize);
	buf = hdl->sampbuf;
	ZeroMemory(buf, step * 2 * sizeof(SINT32));
	v = VOICEHDLPTR(hdl);
	vterm = VOICEHDLEND(hdl);
	do {
	if (v->phase != VOICE_FREE) {
	cnt = step;
	if (v->phase & VOICE_REL) {
	voice_setfree(v);
	if (cnt > REL_COUNT) {
	cnt = REL_COUNT;
	}
	}
	if (v->flag & VOICE_FIXPITCH) {
	pos = v->samppos >> FREQ_SHIFT;
	src = v->sample->data + pos;
	rem = (v->sample->datasize >> FREQ_SHIFT) - pos;
	if (cnt < rem) {
	v->samppos += cnt << FREQ_SHIFT;
	srcterm = src + cnt;
	}
	else {
	voice_setfree(v);
	srcterm = src + rem;
	}
	}
	else {
	src = hdl->resampbuf;
	srcterm = v->resamp(v, src, src + cnt);
	}
	if (src != srcterm) {
	v->mix(v, buf, src, srcterm);
	}
	}
	v++;
	} while(v < vterm);
	return(step);
	}

VEXTERN UINT VEXPORT midiout_get16(MIDIHDL hdl, SINT16 *pcm, UINT size) {	VEXTERN UINT VEXPORT midiout_get16(MIDIHDL hdl, SINT16 *pcm, UINT size) {

UINT step;	UINT step;
Line 1151 VEXTERN UINT VEXPORT midiout_get16(MIDIH	Line 1211 VEXTERN UINT VEXPORT midiout_get16(MIDIH
size -= step;	size -= step;
buf = hdl->sampbuf;	buf = hdl->sampbuf;
ZeroMemory(buf, step * 2 * sizeof(SINT32));	ZeroMemory(buf, step * 2 * sizeof(SINT32));
v = hdl->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
if (v->phase != VOICE_FREE) {	if (v->phase != VOICE_FREE) {
cnt = step;	cnt = step;
Line 1225 VEXTERN UINT VEXPORT midiout_get32(MIDIH	Line 1285 VEXTERN UINT VEXPORT midiout_get32(MIDIH

if ((hdl != NULL) && (size)) {	if ((hdl != NULL) && (size)) {
do {	do {

step = min(size, hdl->worksize);	step = min(size, hdl->worksize);
size -= step;	size -= step;
buf = hdl->sampbuf;	buf = hdl->sampbuf;
ZeroMemory(buf, step * 2 * sizeof(SINT32));	ZeroMemory(buf, step * 2 * sizeof(SINT32));
v = hdl->voice;	v = VOICEHDLPTR(hdl);
vterm = v + VOICE_MAX;	vterm = VOICEHDLEND(hdl);
do {	do {
if (v->phase != VOICE_FREE) {	if (v->phase != VOICE_FREE) {
cnt = step;	cnt = step;
Line 1263 VEXTERN UINT VEXPORT midiout_get32(MIDIH	Line 1324 VEXTERN UINT VEXPORT midiout_get32(MIDIH
}	}
v++;	v++;
} while(v < vterm);	} while(v < vterm);

do {	do {
pcm[0] += buf[0] >> (SAMP_SHIFT + 1);	pcm[0] += buf[0] >> (SAMP_SHIFT + 1);
pcm[1] += buf[1] >> (SAMP_SHIFT + 1);	pcm[1] += buf[1] >> (SAMP_SHIFT + 1);

RetroPC.NET-CVS <cvs@retropc.net>

Removed from v.1.14
changed lines
	Added in v.1.17