np2/win9x/cmmidi.cpp - diff

Return to cmmidi.cpp CVS log

Up to [RetroPC.NET] / np2 / win9x

Diff for /np2/win9x/cmmidi.cpp between versions 1.2 and 1.5

version 1.2, 2003/10/21 11:22:05	version 1.5, 2005/02/07 14:46:14
Line 34 enum { MIDI_MT32 = 0, MIDI_CM32L, MIDI	Line 34 enum { MIDI_MT32 = 0, MIDI_CM32L, MIDI
MIDI_SC55, MIDI_SC88, MIDI_LA,	MIDI_SC55, MIDI_SC88, MIDI_LA,
MIDI_GM, MIDI_GS, MIDI_XG, MIDI_OTHER};	MIDI_GM, MIDI_GS, MIDI_XG, MIDI_OTHER};

static const BYTE EXCV_MTRESET[] = {	static const UINT8 EXCV_MTRESET[] = {
0xfe, 0xfe, 0xfe};	0xfe, 0xfe, 0xfe};
static const BYTE EXCV_GMRESET[] = {	static const UINT8 EXCV_GMRESET[] = {
0xf0, 0x7e, 0x7f, 0x09, 0x01, 0xf7};	0xf0, 0x7e, 0x7f, 0x09, 0x01, 0xf7};
static const BYTE EXCV_GSRESET[] = {	static const UINT8 EXCV_GSRESET[] = {
0xf0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7f, 0x00, 0x41, 0xf7};	0xf0, 0x41, 0x10, 0x42, 0x12, 0x40, 0x00, 0x7f, 0x00, 0x41, 0xf7};
static const BYTE EXCV_XGRESET[] = {	static const UINT8 EXCV_XGRESET[] = {
0xf0, 0x43, 0x10, 0x4C, 0x00, 0x00, 0x7E, 0x00, 0xf7};	0xf0, 0x43, 0x10, 0x4C, 0x00, 0x00, 0x7E, 0x00, 0xf7};
static const BYTE EXCV_GMVOLUME[] = {	static const UINT8 EXCV_GMVOLUME[] = {
0xf0, 0x7F, 0x7F, 0x04, 0x01, 0x00, 0x00, 0xF7};	0xf0, 0x7F, 0x7F, 0x04, 0x01, 0x00, 0x00, 0xF7};

enum {	enum {
Line 83 struct _cmmidi;	Line 83 struct _cmmidi;
typedef struct _cmmidi _CMMIDI;	typedef struct _cmmidi _CMMIDI;
typedef struct _cmmidi *CMMIDI;	typedef struct _cmmidi *CMMIDI;

	typedef struct {
	UINT8 prog;
	UINT8 press;
	UINT16 bend;
	UINT8 ctrl[28];
	} _MIDICH, *MIDICH;

struct _cmmidi {	struct _cmmidi {
UINT opened;	UINT opened;
void (*outfn)(CMMIDI self, UINT32 msg);	void (*outfn)(CMMIDI self, UINT32 msg);
Line 97 struct _cmmidi {	Line 104 struct _cmmidi {
UINT midisyscnt;	UINT midisyscnt;
UINT mpos;	UINT mpos;

BYTE midilast;	UINT8 midilast;
BYTE midiexcvwait;	UINT8 midiexcvwait;
BYTE midimodule;	UINT8 midimodule;

BYTE buffer[MIDI_BUFFER];	UINT8 buffer[MIDI_BUFFER];
_MIDICH mch[16];	_MIDICH mch[16];
BYTE excvbuf[MIDI_BUFFER];	UINT8 excvbuf[MIDI_BUFFER];

BYTE def_en;	UINT8 def_en;
MIMPIDEF def;	MIMPIDEF def;

UINT recvpos;	UINT recvpos;
UINT recvsize;	UINT recvsize;
BYTE recvbuf[MIDI_BUFFER];	UINT8 recvbuf[MIDI_BUFFER];
BYTE midiinbuf[MIDI_BUFFER];	UINT8 midiinbuf[MIDI_BUFFER];
};	};

typedef struct {	typedef struct {
Line 122 typedef struct {	Line 129 typedef struct {
static UINT midiinhdls;	static UINT midiinhdls;
static MIDIINHDL midiinhdl[MIDIIN_MAX];	static MIDIINHDL midiinhdl[MIDIIN_MAX];

static const BYTE midictrltbl[] = { 0, 1, 5, 7, 10, 11, 64,	static const UINT8 midictrltbl[] = { 0, 1, 5, 7, 10, 11, 64,
65, 66, 67, 84, 91, 93,	65, 66, 67, 84, 91, 93,
94, // for SC-88	94, // for SC-88
71, 72, 73, 74}; // for XG	71, 72, 73, 74}; // for XG

static BYTE midictrlindex[128];	static UINT8 midictrlindex[128];


// ----	// ----
Line 178 static UINT module2number(const char *mo	Line 185 static UINT module2number(const char *mo

UINT i;	UINT i;

for (i=0; i<(sizeof(cmmidi_mdlname)/sizeof(char *)); i++) {	for (i=0; i<NELEMENTS(cmmidi_mdlname); i++) {
if (milstr_extendcmp(module, cmmidi_mdlname[i])) {	if (milstr_extendcmp(module, cmmidi_mdlname[i])) {
break;	break;
}	}
Line 195 static void waitlastexclusiveout(CMMIDI	Line 202 static void waitlastexclusiveout(CMMIDI
}	}
}	}

static void sendexclusive(CMMIDI midi, const BYTE *buf, UINT leng) {	static void sendexclusive(CMMIDI midi, const UINT8 *buf, UINT leng) {

CopyMemory(midi->excvbuf, buf, leng);	CopyMemory(midi->excvbuf, buf, leng);
midi->hmidiouthdr.lpData = (char *)midi->excvbuf;	midi->hmidiouthdr.lpData = (char *)midi->excvbuf;
Line 249 const SINT32 *ptr;	Line 256 const SINT32 *ptr;

static void midireset(CMMIDI midi) {	static void midireset(CMMIDI midi) {

const BYTE *excv;	const UINT8 *excv;
UINT excvsize;	UINT excvsize;
BYTE work[4];	UINT8 work[4];

switch(midi->midimodule) {	switch(midi->midimodule) {
case MIDI_GM:	case MIDI_GM:
Line 309 const BYTE *excv;	Line 316 const BYTE *excv;

static void midisetparam(CMMIDI midi) {	static void midisetparam(CMMIDI midi) {

BYTE i;	UINT8 i;
UINT j;	UINT j;
MIDICH mch;	MIDICH mch;

Line 321 static void midisetparam(CMMIDI midi) {	Line 328 static void midisetparam(CMMIDI midi) {
if (mch->bend != 0xffff) {	if (mch->bend != 0xffff) {
midi->outfn(midi, (mch->bend << 8) + 0xe0+i);	midi->outfn(midi, (mch->bend << 8) + 0xe0+i);
}	}
for (j=0; j<sizeof(midictrltbl)/sizeof(BYTE); j++) {	for (j=0; j<NELEMENTS(midictrltbl); j++) {
if (mch->ctrl[j+1] != 0xff) {	if (mch->ctrl[j+1] != 0xff) {
midi->outfn(midi,	midi->outfn(midi,
MIDIOUTS(0xb0+i, midictrltbl[j], mch->ctrl[j+1]));	MIDIOUTS(0xb0+i, midictrltbl[j], mch->ctrl[j+1]));
Line 336 static void midisetparam(CMMIDI midi) {	Line 343 static void midisetparam(CMMIDI midi) {

// ----	// ----

static UINT midiread(COMMNG self, BYTE *data) {	static UINT midiread(COMMNG self, UINT8 *data) {

CMMIDI midi;	CMMIDI midi;

Line 350 static UINT midiread(COMMNG self, BYTE *	Line 357 static UINT midiread(COMMNG self, BYTE *
return(0);	return(0);
}	}

static UINT midiwrite(COMMNG self, BYTE data) {	static UINT midiwrite(COMMNG self, UINT8 data) {

CMMIDI midi;	CMMIDI midi;
MIDICH mch;	MIDICH mch;
Line 463 static UINT midiwrite(COMMNG self, BYTE	Line 470 static UINT midiwrite(COMMNG self, BYTE
if (midi->buffer[1] == 123) {	if (midi->buffer[1] == 123) {
mch->press = 0;	mch->press = 0;
mch->bend = 0x4000;	mch->bend = 0x4000;
mch->ctrl[1] = 0; // Modulation	mch->ctrl[1+1] = 0; // Modulation
mch->ctrl[5] = 127; // Explession	mch->ctrl[5+1] = 127; // Explession
mch->ctrl[6] = 0; // Hold	mch->ctrl[6+1] = 0; // Hold
mch->ctrl[7] = 0; // Portament	mch->ctrl[7+1] = 0; // Portament
mch->ctrl[8] = 0; // Sostenute	mch->ctrl[8+1] = 0; // Sostenute
mch->ctrl[9] = 0; // Soft	mch->ctrl[9+1] = 0; // Soft
}	}
else {	else {
mch->ctrl[midictrlindex[midi->buffer[1]]]	mch->ctrl[midictrlindex[midi->buffer[1]]]
Line 529 static UINT midiwrite(COMMNG self, BYTE	Line 536 static UINT midiwrite(COMMNG self, BYTE
return(0);	return(0);
}	}

static BYTE midigetstat(COMMNG self) {	static UINT8 midigetstat(COMMNG self) {

return(0x00);	return(0x00);
}	}

static UINT midimsg(COMMNG self, UINT msg, long param) {	static long midimsg(COMMNG self, UINT msg, long param) {

CMMIDI midi;	CMMIDI midi;
	COMFLAG flag;

midi = (CMMIDI)(self + 1);	midi = (CMMIDI)(self + 1);
switch(msg) {	switch(msg) {
Line 544 static UINT midimsg(COMMNG self, UINT ms	Line 552 static UINT midimsg(COMMNG self, UINT ms
midireset(midi);	midireset(midi);
return(1);	return(1);

	case COMMSG_SETFLAG:
	flag = (COMFLAG)param;
	if ((flag) &&
	(flag->size == sizeof(_COMFLAG) + sizeof(midi->mch)) &&
	(flag->sig == COMSIG_MIDI)) {
	CopyMemory(midi->mch, flag + 1, sizeof(midi->mch));
	midisetparam(midi);
	return(1);
	}
	break;

	case COMMSG_GETFLAG:
	flag = (COMFLAG)_MALLOC(sizeof(_COMFLAG) + sizeof(midi->mch),
	"MIDI FLAG");
	if (flag) {
	flag->size = sizeof(_COMFLAG) + sizeof(midi->mch);
	flag->sig = COMSIG_MIDI;
	flag->ver = 0;
	flag->param = 0;
	CopyMemory(flag + 1, midi->mch, sizeof(midi->mch));
	return((long)flag);
	}
	break;

case COMMSG_MIMPIDEFFILE:	case COMMSG_MIMPIDEFFILE:
mimpidef_load(&midi->def, (char *)param);	mimpidef_load(&midi->def, (char *)param);
return(1);	return(1);
Line 551 static UINT midimsg(COMMNG self, UINT ms	Line 583 static UINT midimsg(COMMNG self, UINT ms
case COMMSG_MIMPIDEFEN:	case COMMSG_MIMPIDEFEN:
midi->def_en = (param)?TRUE:FALSE;	midi->def_en = (param)?TRUE:FALSE;
return(1);	return(1);

case COMMSG_MIDISTATSET:
CopyMemory(midi->mch, (void *)param, sizeof(midi->mch));
midisetparam(midi);
return(1);

case COMMSG_MIDISTATGET:
CopyMemory((void *)param, midi->mch, sizeof(midi->mch));
return(1);
}	}
return(0);	return(0);
}	}
Line 643 void cmmidi_initailize(void) {	Line 666 void cmmidi_initailize(void) {
UINT i;	UINT i;

ZeroMemory(midictrlindex, sizeof(midictrlindex));	ZeroMemory(midictrlindex, sizeof(midictrlindex));
for (i=0; i<sizeof(midictrltbl)/sizeof(BYTE); i++) {	for (i=0; i<NELEMENTS(midictrltbl); i++) {
midictrlindex[midictrltbl[i]] = (BYTE)(i + 1);	midictrlindex[midictrltbl[i]] = (UINT8)(i + 1);
}	}
midictrlindex[32] = 1;	midictrlindex[32] = 1;
}	}
Line 732 COMMNG cmmidi_create(const char *midiout	Line 755 COMMNG cmmidi_create(const char *midiout

midi->midilast = 0x80;	midi->midilast = 0x80;
// midi->midiexcvwait = 0;	// midi->midiexcvwait = 0;
midi->midimodule = (BYTE)module2number(module);	midi->midimodule = (UINT8)module2number(module);
FillMemory(midi->mch, sizeof(midi->mch), 0xff);	FillMemory(midi->mch, sizeof(midi->mch), 0xff);
return(ret);	return(ret);

Line 754 cmcre_err1:	Line 777 cmcre_err1:

// ---- midiin callback	// ---- midiin callback

static void midiinrecv(CMMIDI midi, const BYTE *data, UINT size) {	static void midiinrecv(CMMIDI midi, const UINT8 *data, UINT size) {

UINT wpos;	UINT wpos;
UINT wsize;	UINT wsize;
Line 808 void cmmidi_recvdata(HMIDIIN hdr, UINT32	Line 831 void cmmidi_recvdata(HMIDIIN hdr, UINT32
break;	break;
#endif	#endif
}	}
midiinrecv(midi, (BYTE *)&data, databytes);	midiinrecv(midi, (UINT8 *)&data, databytes);
}	}
}	}

Line 818 void cmmidi_recvexcv(HMIDIIN hdr, MIDIHD	Line 841 void cmmidi_recvexcv(HMIDIIN hdr, MIDIHD

midi = midiinhdlget(hdr);	midi = midiinhdlget(hdr);
if (midi) {	if (midi) {
midiinrecv(midi, (BYTE *)data->lpData, data->dwBytesRecorded);	midiinrecv(midi, (UINT8 *)data->lpData, data->dwBytesRecorded);
midiInUnprepareHeader(midi->hmidiin,	midiInUnprepareHeader(midi->hmidiin,
&midi->hmidiinhdr, sizeof(MIDIHDR));	&midi->hmidiinhdr, sizeof(MIDIHDR));
midiInPrepareHeader(midi->hmidiin,	midiInPrepareHeader(midi->hmidiin,

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

Removed from v.1.2
changed lines
	Added in v.1.5