CMS.C

#ifdef CMS

//#define CMS_DEBUG		// verbose to CMSLOG.TXT debug file
//#define DRUMS_ONLY		// for percussion debug purpouses

#ifdef CMS_DEBUG
#include <stdio.h>
#include <stdarg.h>
#endif

#include "cms.h"

#ifdef CMS_DEBUG
void debug_log(const char *fmt, ...)
{
   FILE *f_log;
   va_list ap;

	f_log = fopen("cmslog.log", "a");
	va_start(ap, fmt);
        vfprintf(f_log, fmt, ap);
	va_end(ap);
        fclose(f_log);
}
#endif

mid_channel cms_synth[MAX_CMS_CHANNELS];	// CMS synth

static unsigned short freqtable[128] = {
    8,    9,    9,   10,   10,   11,   12,   12,   13,   14,   15,   15,
   16,   17,   18,   19,   21,   22,   23,   24,   26,   28,   29,   31,
   33,   35,   37,   39,   41,   44,   46,   49,   52,   55,   58,   62,
   65,   69,   73,   78,   82,   87,   92,   98,  104,  110,  117,  123,
  131,  139,  147,  156,  165,  175,  185,  196,  208,  220,  233,  247,
  262,  277,  294,  311,  330,  349,  370,  392,  415,  440,  466,  494,
  523,  554,  587,  622,  659,  698,  740,  784,  831,  880,  932,  988,
 1047, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1976,
 2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951,
 4186, 4435, 4699, 4978, 5274, 5588, 5920, 6272, 6645, 7040, 7459, 7902,
 8372, 8870, 9397, 9956,10548,11175,11840,12544};

static unsigned short pitchtable[256] = {                    /* pitch wheel */
         29193U,29219U,29246U,29272U,29299U,29325U,29351U,29378U,  /* -128 */
         29405U,29431U,29458U,29484U,29511U,29538U,29564U,29591U,  /* -120 */
         29618U,29644U,29671U,29698U,29725U,29752U,29778U,29805U,  /* -112 */
         29832U,29859U,29886U,29913U,29940U,29967U,29994U,30021U,  /* -104 */
         30048U,30076U,30103U,30130U,30157U,30184U,30212U,30239U,  /*  -96 */
         30266U,30293U,30321U,30348U,30376U,30403U,30430U,30458U,  /*  -88 */
         30485U,30513U,30541U,30568U,30596U,30623U,30651U,30679U,  /*  -80 */
         30706U,30734U,30762U,30790U,30817U,30845U,30873U,30901U,  /*  -72 */
         30929U,30957U,30985U,31013U,31041U,31069U,31097U,31125U,  /*  -64 */
         31153U,31181U,31209U,31237U,31266U,31294U,31322U,31350U,  /*  -56 */
         31379U,31407U,31435U,31464U,31492U,31521U,31549U,31578U,  /*  -48 */
         31606U,31635U,31663U,31692U,31720U,31749U,31778U,31806U,  /*  -40 */
         31835U,31864U,31893U,31921U,31950U,31979U,32008U,32037U,  /*  -32 */
         32066U,32095U,32124U,32153U,32182U,32211U,32240U,32269U,  /*  -24 */
         32298U,32327U,32357U,32386U,32415U,32444U,32474U,32503U,  /*  -16 */
         32532U,32562U,32591U,32620U,32650U,32679U,32709U,32738U,  /*   -8 */
         32768U,32798U,32827U,32857U,32887U,32916U,32946U,32976U,  /*    0 */
         33005U,33035U,33065U,33095U,33125U,33155U,33185U,33215U,  /*    8 */
         33245U,33275U,33305U,33335U,33365U,33395U,33425U,33455U,  /*   16 */
         33486U,33516U,33546U,33576U,33607U,33637U,33667U,33698U,  /*   24 */
         33728U,33759U,33789U,33820U,33850U,33881U,33911U,33942U,  /*   32 */
         33973U,34003U,34034U,34065U,34095U,34126U,34157U,34188U,  /*   40 */
         34219U,34250U,34281U,34312U,34343U,34374U,34405U,34436U,  /*   48 */
         34467U,34498U,34529U,34560U,34591U,34623U,34654U,34685U,  /*   56 */
         34716U,34748U,34779U,34811U,34842U,34874U,34905U,34937U,  /*   64 */
         34968U,35000U,35031U,35063U,35095U,35126U,35158U,35190U,  /*   72 */
         35221U,35253U,35285U,35317U,35349U,35381U,35413U,35445U,  /*   80 */
         35477U,35509U,35541U,35573U,35605U,35637U,35669U,35702U,  /*   88 */
         35734U,35766U,35798U,35831U,35863U,35895U,35928U,35960U,  /*   96 */
         35993U,36025U,36058U,36090U,36123U,36155U,36188U,36221U,  /*  104 */
         36254U,36286U,36319U,36352U,36385U,36417U,36450U,36483U,  /*  112 */
         36516U,36549U,36582U,36615U,36648U,36681U,36715U,36748U}; /*  120 */

unsigned char	CMSFreqMap[128] = {
		0  ,  3,  7, 11, 15, 19, 23, 27,
		31 , 34, 38, 41, 45, 48, 51, 55,
		58 , 61, 64, 66, 69, 72, 75, 77,
		80 , 83, 86, 88, 91, 94, 96, 99,
		102,104,107,109,112,114,116,119,
		121,123,125,128,130,132,134,136,
		138,141,143,145,147,149,151,153,
		155,157,159,161,162,164,166,168,
		170,172,174,175,177,179,181,182,
		184,186,188,189,191,193,194,196,
		197,199,200,202,203,205,206,208,
		209,210,212,213,214,216,217,218,
		219,221,222,223,225,226,227,228,
		229,231,232,233,234,235,236,237,
		239,240,241,242,243,244,245,246,
		247,249,250,251,252,253,254,255
	};

// CMS IO port address
unsigned short cmsPort;


// The 12 note-within-an-octave values for the SAA1099, starting at B
static unsigned char noteAdr[] = {5, 32, 60, 85, 110, 132, 153, 173, 192, 210, 227, 243};

// Volume
static unsigned char atten[128] = {
                 0,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,
                 3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,
                 5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,
                 7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,
                 9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,
                 11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,
                 13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,
        	 15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,
        };

// Logic channel - first chip/second chip
static unsigned char ChanReg[12] =  {000,001,002,003,004,005,000,001,002,003,004,005};

// Set octave command
static unsigned char OctavReg[12] = {0x10,0x10,0x11,0x11,0x12,0x12,0x10,0x10,0x11,0x11,0x12,0x12};

unsigned char CmsOctaveStore[12];

unsigned char ChanEnableReg[2] = {0,0};

// Note priority
unsigned char NotePriority;

unsigned short channelpitch[16];

void __declspec( naked ) cmsWrite(void)
{
/*
	parameters
	dx = port base+offset
	ah = register
	al = data
*/
_asm
    {
	inc  dx
	xchg al,ah
	out  dx,al
	dec  dx
	xchg al,ah
	out  dx,al
        ret
    }
}

void __declspec( naked ) cmsNull(unsigned short port)
{
/*
	parameters
	dx = port offset to null
*/
_asm
    {
	add   dx,cmsPort // FIXME! CMSPortAddr
	mov   cx,20h
	xor   ax,ax
loop_nul:           // null all 20 registers 
	call  cmsWrite
	inc   ah
	loop  loop_nul

	mov   ax,1C02h // reset chip 
	call  cmsWrite

	mov   ax,1C01h // enable this chip 
	call  cmsWrite

	ret
    }
}

void cmsReset(unsigned short port)
{
   unsigned char i;
   cmsPort = port;
   _asm
    {
	mov  dx,0
	call cmsNull
	mov  dx,2
	call cmsNull
    }
	for (i=0;i<11;i++)CmsOctaveStore[i]=0;
	ChanEnableReg[0]=0;
	ChanEnableReg[1]=0;
        for (i=0;i<MAX_CMS_CHANNELS;i++)
        {
                cms_synth[i].note=0;
                cms_synth[i].priority=0;
    		cms_synth[i].ch = 0;
    		cms_synth[i].voice = 0;
    		cms_synth[i].velocity = 0;
        }
        for (i=0;i<16;i++)
        {
            channelpitch[i] = 8192;
        }
	NotePriority = 0;
}

static void CMS_SetRegister(unsigned short regAddr, unsigned char reg, unsigned char val)
{
    outp(regAddr + 1, reg); /* Select the register */
    outp(regAddr, val);     /* Set the value of the register */
}

#if 0
void cmsDisableVoice(unsigned char voice)
{
	if (voice > 5)
	    {
		ChanEnableReg[1] &= ~(1 << ChanReg[voice]);
		CMS_SetRegister(cmsPort + 2, 0x14, ChanEnableReg[1]);
	    }
	else
	    {
		ChanEnableReg[0] &= ~(1 << ChanReg[voice]);
		CMS_SetRegister(cmsPort, 0x14, ChanEnableReg[0]);
	    }
}

void cmsSound(unsigned char voice,unsigned char freq,unsigned char octave,unsigned char amplitudeLeft,unsigned char amplitudeRight)
{
	if (voice > 5)
	    {
		if (ChanReg[voice]&0x1 == 0)
			CmsOctaveStore[OctavReg[voice]-0x10+3] = (CmsOctaveStore[OctavReg[voice]-0x10+3] & 0xF0) | octave;
		else
			CmsOctaveStore[OctavReg[voice]-0x10+3] = ((CmsOctaveStore[OctavReg[voice]-0x10+3] & 0xF) << 4) | octave;
		CMS_SetRegister(cmsPort + 2, OctavReg[voice], CmsOctaveStore[OctavReg[voice]-0x10+3]);
		CMS_SetRegister(cmsPort + 2, ChanReg[voice], (amplitudeLeft << 4) | amplitudeRight);
		CMS_SetRegister(cmsPort + 2, ChanReg[voice] | 0x8, freq);
		ChanEnableReg[1] |= 1 << ChanReg[voice];
		CMS_SetRegister(cmsPort + 2, 0x14, ChanEnableReg[1]);
	    }
	else
	    {
		if (ChanReg[voice]&0x1 == 0)
			CmsOctaveStore[OctavReg[voice]-0x10] = (CmsOctaveStore[OctavReg[voice]-0x10] & 0xF0) | octave;
		else
			CmsOctaveStore[OctavReg[voice]-0x10] = ((CmsOctaveStore[OctavReg[voice]-0x10] & 0xF) << 4) | octave;
		CMS_SetRegister(cmsPort, OctavReg[voice], CmsOctaveStore[OctavReg[voice]-0x10]);
		CMS_SetRegister(cmsPort, ChanReg[voice], (amplitudeLeft << 4) | amplitudeRight);
		CMS_SetRegister(cmsPort, ChanReg[voice] | 0x8, freq);
		ChanEnableReg[0] |= 1 << ChanReg[voice];
		CMS_SetRegister(cmsPort, 0x14, ChanEnableReg[0]);
	    }
}

#endif

void cmsDisableVoice(unsigned char voice)
{
_asm
   {
		xor   bh,bh
		mov   bl,voice

		mov   dx,cmsPort	// FIXME !!!

		mov   bl,ChanReg[bx]	; bl = true channel (0 - 5)

		xor   di,di
		mov   cl,voice
		cmp   cl,06h
                jl    skip_inc
		inc   di
                add   dx,2
skip_inc:
		mov   al,14h
		inc   dx
		out   dx,al
		dec   dx

		mov   al,ChanEnableReg[di]
		mov   ah,01h
		mov   cl,bl
		shl   ah,cl
		not   ah
		and   al,ah		; al = voice enable reg

		out   dx,al
		mov   ChanEnableReg[di],al
    }
}


void cmsSetVolume(unsigned char voice,unsigned char amplitudeLeft,unsigned char amplitudeRight)
{
_asm
   {
		xor   bh,bh
		mov   bl,voice
		
		mov   dx,cmsPort	// FIXME !!!
		cmp   bl,06h		; check channel num > 5?
		jl    setVol	; yes - set port = port + 2
		add   dx,2
setVol:
		mov   bl,ChanReg[bx]	; bx = true channel (0 - 5)
		mov   al,byte ptr amplitudeLeft
		mov   ah,byte ptr amplitudeRight
		mov   cl,4
		shl   ah,cl
		or    al,ah
		mov   ah,bl
		call cmsWrite
   }
}

void cmsSound(unsigned char voice,unsigned char freq,unsigned char octave,unsigned char amplitudeLeft,unsigned char amplitudeRight)
{
_asm
   {
		xor   bh,bh
		mov   bl,voice
		
		mov   dx,cmsPort	// FIXME !!!
		cmp   bl,06h		; check channel num > 5?
		jl    setOctave	; yes - set port = port + 2
		add   dx,2
setOctave:
		mov   bl,ChanReg[bx]	; bx = true channel (0 - 5) //FIXME swap down
		mov   ah,OctavReg[bx]   ; ah = Set octave command   //FIXME swap up
;
;	ah now = register
;		0,1,6,7=$10
;		2,3,8,9=$11
;		4,5,10,11=$12
;
;	CMS octave regs are write only, so we have to track
;	the values in adjoining voices manually

		mov   al,ah
		xor   ah,ah		; ax = set octave cmd (10h - 12h)
		mov   di,ax		; di = ax
		sub   di,010h		; di = octave cmd - 10h (0..2 index)
		mov   cl,voice
		cmp   cl,06h
                jl    skip_inc
		add   di,3
skip_inc:
		mov   ah,al		; set ah back to octave cmd

		mov   al,byte ptr CmsOctaveStore[di]
		mov   bh,octave
		test  bl,01h
		jnz   shiftOctave
		and   al,0F0h
		jmp   outOctave
shiftOctave:
		and   al,0Fh
		mov   cl,4
		shl   bh,cl
outOctave:
		or    al,bh
		mov   byte ptr CmsOctaveStore[di],al
		call cmsWrite		; set octave to CMS
setAmp:
		mov   al,byte ptr amplitudeLeft
		mov   ah,byte ptr amplitudeRight
		;and   al,0Fh
		mov   cl,4
		shl   ah,cl
		or    al,ah
		mov   ah,bl
		call cmsWrite
setFreq:
		mov   al,byte ptr freq
		or    ah,08h


		call cmsWrite
voiceEnable:
		mov   al,14h
		inc   dx
		out   dx,al
		dec   dx

		xor   di,di
		mov   cl,voice
		cmp   cl,06h
                jl    skip_inc2
		inc   di
skip_inc2:
		mov   al,ChanEnableReg[di]
		mov   ah,01h
		mov   cl,bl
		shl   ah,cl
		or    al,ah
		out   dx,al
		mov   ChanEnableReg[di],al
    }
}

// ****
// High-level CMS synth procedures
// ****

void cms_pitchwheel(unsigned short oplport, int channel, int pitchwheel)
{
  unsigned char i;
  unsigned short notefreq;
  unsigned short period;
  unsigned char mixer;
  unsigned char note;
  int pitch;
  unsigned char octave;

    channelpitch[channel] = pitchwheel;
    for(i=0; i<MAX_CMS_CHANNELS; i++)
    {
        if ((cms_synth[i].ch==channel) && (cms_synth[i].note != 0))
        {
         note = cms_synth[i].note;

         pitch = pitchwheel;
         if (pitch != 0) {
           if (pitch > 127) {
              pitch = 127;
           } else if (pitch < -128) {
              pitch = -128;
           }
         }

        notefreq = ((unsigned long)freqtable[note] * pitchtable[pitch + 128]) >> 15;

	if ((notefreq > 31) && (notefreq < 7824))
	{
		octave=4;
		while (notefreq<489)
	 		{
				notefreq=notefreq*2;
				octave--;
			}
		while (notefreq>977)
			{
				notefreq=notefreq / 2;
				octave++;
			}

#ifndef DRUMS_ONLY
		cmsSound(cms_synth[i].voice,CMSFreqMap[((notefreq-489)*128) / 489],octave,atten[cms_synth[i].velocity],atten[cms_synth[i].velocity]); 
#endif

        }
      }
   }
}

void cmsNoteOff(unsigned char channel, unsigned char note)
{
  unsigned char i;
  unsigned char voice;

    if (channel == 9)
    {
#ifdef CMS_DEBUG
       debug_log("DRUM OFF note= %u\n",note);
#endif
	CMS_SetRegister(cmsPort+2, 0x19, 0x0);
	CMS_SetRegister(cmsPort+2, 0x15, 0x0); // noise ch 11
	cmsDisableVoice(11);
    }
    else
    {

    voice = MAX_CMS_CHANNELS;
    for(i=0; i<MAX_CMS_CHANNELS; i++)
    {
      	if(cms_synth[i].note==note)
      	{
        	voice = i;
        	break;
      	}
    }


    // Note not found, ignore note off command
    if(voice==MAX_CMS_CHANNELS)
    {
#ifdef CMS_DEBUG
	debug_log("not found Ch=%u,note=%u\n",channel & 0xFF,note & 0xFF);
#endif
    	return;
    }

    // decrease priority for all notes greater than current
    for (i=0; i<MAX_CMS_CHANNELS; i++)
	if (cms_synth[i].priority > cms_synth[voice].priority )
		cms_synth[i].priority = cms_synth[i].priority - 1;

    
    if (NotePriority != 0) NotePriority--;

    cmsDisableVoice(voice);
    cms_synth[voice].note = 0;
    cms_synth[voice].priority = 0;
    cms_synth[voice].ch = 0;
    cms_synth[voice].voice = 0;
    cms_synth[voice].velocity = 0;
   }
}

void cmsNoteOn(unsigned char channel, unsigned char note, unsigned char velocity)
{
  unsigned char octave;
  unsigned char noteVal;
  unsigned char i;
  unsigned char voice;
  unsigned char note_cms;
  unsigned notefreq;
  int pitch;

  if (channel == 9)
  {
    if (velocity != 0)
       {
#ifdef CMS_DEBUG
       debug_log("DRUM ON note= %u\n",note);
#endif
	CMS_SetRegister(cmsPort+2, 0x19, 0x84); // single dacay
	switch (note) {
		case 37: // Side Stick
			CMS_SetRegister(cmsPort+2, 0x16, 0x00); // noise gen 1 31.3kHz
			CMS_SetRegister(cmsPort+2, 0x15, 0x20); // noise ch 11
			cmsSound(11,0,2,atten[velocity],atten[velocity]);
			break;
		case 38: // Acoustic Snare
			CMS_SetRegister(cmsPort+2, 0x16, 0x00); // noise gen 1 31.3kHz
			CMS_SetRegister(cmsPort+2, 0x15, 0x20); // noise ch 11
			cmsSound(11,0,0,atten[velocity],atten[velocity]);
			break;
		case 39: // Hand Clap
			CMS_SetRegister(cmsPort+2, 0x16, 0x10); // noise gen 1 15.6kHz
			CMS_SetRegister(cmsPort+2, 0x15, 0x20); // noise ch 11
			cmsSound(11,0,3,atten[velocity],atten[velocity]);
			break;
		case 40: // Electric Snare
			CMS_SetRegister(cmsPort+2, 0x16, 0x10); // noise gen 1 15.6kHz
			CMS_SetRegister(cmsPort+2, 0x15, 0x20); // noise ch 11
			cmsSound(11,0,1,atten[velocity],atten[velocity]);
			break;
		case 42: // Closed Hi Hat
			CMS_SetRegister(cmsPort+2, 0x16, 0x10); // noise gen 1 15.6kHz
			CMS_SetRegister(cmsPort+2, 0x15, 0x20); // noise ch 11
			cmsSound(11,0,2,atten[velocity],atten[velocity]);
			break;
		case 44: // Pedal Hi-Hat
			CMS_SetRegister(cmsPort+2, 0x16, 0x10); // noise gen 1 15.6kHz
			CMS_SetRegister(cmsPort+2, 0x15, 0x20); // noise ch 11
			cmsSound(11,0,0,atten[velocity],atten[velocity]);
			break;
		case 52: // Chinese Cymbal
			CMS_SetRegister(cmsPort+2, 0x16, 0x20); // noise gen 1 7.6kHz
			CMS_SetRegister(cmsPort+2, 0x15, 0x20); // noise ch 11
			cmsSound(11,0,2,atten[velocity],atten[velocity]);
			break;
		case 55: // Splash Cymbal
			CMS_SetRegister(cmsPort+2, 0x16, 0x20); // noise gen 1 7.6kHz
			CMS_SetRegister(cmsPort+2, 0x15, 0x20); // noise ch 11
			cmsSound(11,0,0,atten[velocity],atten[velocity]);
			break;
		case 71: // Short Whistle
		case 72: // Long Whistle
			cmsSound(11,0,6,atten[velocity],atten[velocity]);
			break;
		default:
			cmsSound(11,0,1,atten[velocity],atten[velocity]);
        }
       }
    else
       {
	CMS_SetRegister(cmsPort+2, 0x19, 0x0);
	CMS_SetRegister(cmsPort+2, 0x15, 0x0); // noise ch 11
	cmsDisableVoice(11);
       }
  }
  else
  if (velocity != 0)
  {
/*
	note_cms = note+1;

	octave = (note_cms / 12) - 1; //Some fancy math to get the correct octave
  	noteVal = note_cms - ((octave + 1) * 12); //More fancy math to get the correct note
*/
	NotePriority++;

        voice = MAX_CMS_CHANNELS;
    	for(i=0; i<MAX_CMS_CHANNELS; i++)
    	{
      		if(cms_synth[i].note==0)
      		{
        		voice = i;
        		break;
      		}
    	}


  	// We run out of voices, find low priority voice
  	if(voice==MAX_CMS_CHANNELS)
  	{
		unsigned char min_prior = cms_synth[0].priority;

#ifdef CMS_DEBUG
	debug_log("out of voice. NotePriority=%u\n",NotePriority);
    		for (i=0; i<MAX_CMS_CHANNELS; i++)
		  debug_log("%u ",cms_synth[i].priority);
	debug_log("\n");	
#endif
		// find note with min prioryty
		voice = 0;
    		for (i=1; i<MAX_CMS_CHANNELS; i++)
		  if (cms_synth[i].priority < min_prior) 
		  {
			voice = i;
                        min_prior = cms_synth[i].priority;
                  }

		// decrease all notes priority by one
    		for (i=0; i<MAX_CMS_CHANNELS; i++)
		  if (cms_synth[i].priority != 0)
			cms_synth[i].priority = cms_synth[i].priority - 1;

		// decrease current priority
		if (NotePriority != 0) NotePriority--;

#ifdef CMS_DEBUG
	debug_log("find low priority voice %u, NotePriority=%u\n",voice,NotePriority);
    		for (i=0; i<MAX_CMS_CHANNELS; i++)
		  debug_log("%u ",cms_synth[i].priority);
	debug_log("\n");	
#endif
  	}

        pitch = channelpitch[channel];
        if (pitch != 0) {
           if (pitch > 127) {
              pitch = 127;
           } else if (pitch < -128) {
              pitch = -128;
           }
        }

        notefreq = ((unsigned long)freqtable[note] * pitchtable[pitch + 128]) >> 15;

	if ((notefreq > 31) && (notefreq < 7824))
	{
		octave=4;
		while (notefreq<489)
	 		{
				notefreq=notefreq*2;
				octave--;
			}
		while (notefreq>977)
			{
				notefreq=notefreq / 2;
				octave++;
			}

#ifndef DRUMS_ONLY
		cmsSound(voice,CMSFreqMap[((notefreq-489)*128) / 489],octave,atten[velocity],atten[velocity]); 
#endif

		cms_synth[voice].note = note;
		cms_synth[voice].priority = NotePriority;
		cms_synth[voice].velocity = velocity;
        	cms_synth[voice].ch = channel;
        	cms_synth[voice].voice = voice;
	}

  } 
  else
        cmsNoteOff(channel,note);
}


void cmsTick(void)
{
#if 0
  unsigned char i;
  unsigned char noteVal;

  for (i=0;i<MAX_CMS_CHANNELS;i++) 
    if (cms_synth[i].note != 0)
	{
		noteVal = cms_synth[i].volume-1;
		if (noteVal != 0)
			{
				cmsSetVolume(i,atten[noteVal],atten[noteVal]);
				cms_synth[i].volume = noteVal;
			}
		else
			{
    				cmsDisableVoice(i);
				cms_synth[i].volume = 0;
				cms_synth[i].note = 0;
			}
	}
#endif
}

void cmsController(unsigned char channel, unsigned char id, unsigned char val)
{
  unsigned char i;
    if ((id==121) || (id==123)) // All Sound/Notes Off
    {
  		for (i=0;i<MAX_CMS_CHANNELS;i++) 
    		  if (cms_synth[i].note != 0)
		 	{
    				cmsDisableVoice(i);
				cms_synth[i].note = 0;
				cms_synth[i].priority = 0;
    				cms_synth[i].ch = 0;
    				cms_synth[i].voice = 0;
    				cms_synth[i].velocity = 0;
		 	}
		if (id==121)
		{
        		for (i=0;i<16;i++)
            			channelpitch[i] = 8192;
		}
    }
}

#endif