gzdoom/libraries/timidity/playmidi.cpp

/*

	TiMidity -- Experimental MIDI to WAVE converter
	Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi>

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

	playmidi.c -- random stuff in need of rearrangement

*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <assert.h>

#include "timidity.h"
#include "common.h"
#include "instrum.h"
#include "playmidi.h"


namespace Timidity
{

bool Envelope::Update(struct Voice* v)
{
	if (Type == INST_GUS)
		return gf1.Update(v);
	return sf2.Update(v);
}
void Envelope::ApplyToAmp(struct Voice* v)
{
	if (Type == INST_GUS)
		return gf1.ApplyToAmp(v);
	return sf2.ApplyToAmp(v);
}
void Envelope::Release(struct Voice* v)
{
	if (Type == INST_GUS)
		return gf1.Release(v);
	return sf2.Release(v);
}

void Renderer::reset_voices()
{
	memset(voice, 0, sizeof(voice[0]) * voices);
}

/* Process the Reset All Controllers event */
void Renderer::reset_controllers(int c)
{
	channel[c].volume = 100;
	channel[c].expression = 127;
	channel[c].sustain = 0;
	channel[c].pitchbend = 0x2000;
	channel[c].pitchfactor = 0; /* to be computed */
	channel[c].mono = 0;
	channel[c].rpn = RPN_RESET;
	channel[c].nrpn = RPN_RESET;
}

void Renderer::reset_midi()
{
	for (int i = 0; i < MAXCHAN; i++)
	{
		reset_controllers(i);
		/* The rest of these are unaffected by the Reset All Controllers event */
		channel[i].program = default_program;
		channel[i].panning = NO_PANNING;
		channel[i].pitchsens = 200;
		channel[i].bank = 0; /* tone bank or drum set */
	}
	reset_voices();
}

void Renderer::recompute_freq(int v)
{
	Channel *ch = &channel[voice[v].channel];
	int 
		sign = (voice[v].sample_increment < 0), /* for bidirectional loops */
		pb = ch->pitchbend;
	double a;

	if (voice[v].sample->sample_rate == 0)
	{
		return;
	}

	if (voice[v].vibrato_control_ratio != 0)
	{
		/* This instrument has vibrato. Invalidate any precomputed
		   sample_increments. */
		memset(voice[v].vibrato_sample_increment, 0, sizeof(voice[v].vibrato_sample_increment));
	}

	if (pb == 0x2000 || pb < 0 || pb > 0x3FFF)
	{
		voice[v].frequency = voice[v].orig_frequency;
	}
	else
	{
		pb -= 0x2000;
		if (ch->pitchfactor == 0)
		{
			/* Damn. Somebody bent the pitch. */
			ch->pitchfactor = float(pow(2.f, ((abs(pb) * ch->pitchsens) / (8191.f * 1200.f))));
		}
		if (pb < 0)
		{
			voice[v].frequency = voice[v].orig_frequency / ch->pitchfactor;
		}
		else
		{
			voice[v].frequency = voice[v].orig_frequency * ch->pitchfactor;
		}
	}

	a = FSCALE(((double)(voice[v].sample->sample_rate) * voice[v].frequency) /
		((double)(voice[v].sample->root_freq) * rate),
		FRACTION_BITS);

	if (sign) 
		a = -a; /* need to preserve the loop direction */

	voice[v].sample_increment = (int)(a);
}

static const uint8_t vol_table[] = {
000 /* 000 */,	129 /* 001 */,	145 /* 002 */,	155 /* 003 */,	
161 /* 004 */,	166 /* 005 */,	171 /* 006 */,	174 /* 007 */,	
177 /* 008 */,	180 /* 009 */,	182 /* 010 */,	185 /* 011 */,	
187 /* 012 */,	188 /* 013 */,	190 /* 014 */,	192 /* 015 */,	
193 /* 016 */,	195 /* 017 */,	196 /* 018 */,	197 /* 019 */,	
198 /* 020 */,	199 /* 021 */,	201 /* 022 */,	202 /* 023 */,	
203 /* 024 */,	203 /* 025 */,	204 /* 026 */,	205 /* 027 */,	
206 /* 028 */,	207 /* 029 */,	208 /* 030 */,	208 /* 031 */,	
209 /* 032 */,	210 /* 033 */,	211 /* 034 */,	211 /* 035 */,	
212 /* 036 */,	213 /* 037 */,	213 /* 038 */,	214 /* 039 */,	
214 /* 040 */,	215 /* 041 */,	215 /* 042 */,	216 /* 043 */,	
217 /* 044 */,	217 /* 045 */,	218 /* 046 */,	218 /* 047 */,	
219 /* 048 */,	219 /* 049 */,	219 /* 050 */,	220 /* 051 */,	
220 /* 052 */,	221 /* 053 */,	221 /* 054 */,	222 /* 055 */,	
222 /* 056 */,	222 /* 057 */,	223 /* 058 */,	223 /* 059 */,	
224 /* 060 */,	224 /* 061 */,	224 /* 062 */,	225 /* 063 */,	
225 /* 064 */,	226 /* 065 */,	227 /* 066 */,	228 /* 067 */,	
229 /* 068 */,	230 /* 069 */,	231 /* 070 */,	231 /* 071 */,	
232 /* 072 */,	233 /* 073 */,	234 /* 074 */,	234 /* 075 */,	
235 /* 076 */,	236 /* 077 */,	236 /* 078 */,	237 /* 079 */,	
238 /* 080 */,	238 /* 081 */,	239 /* 082 */,	239 /* 083 */,	
240 /* 084 */,	241 /* 085 */,	241 /* 086 */,	242 /* 087 */,	
242 /* 088 */,	243 /* 089 */,	243 /* 090 */,	244 /* 091 */,	
244 /* 092 */,	244 /* 093 */,	245 /* 094 */,	245 /* 095 */,	
246 /* 096 */,	246 /* 097 */,	247 /* 098 */,	247 /* 099 */,	
247 /* 100 */,	248 /* 101 */,	248 /* 102 */,	249 /* 103 */,	
249 /* 104 */,	249 /* 105 */,	250 /* 106 */,	250 /* 107 */,	
250 /* 108 */,	251 /* 109 */,	251 /* 110 */,	251 /* 111 */,	
252 /* 112 */,	252 /* 113 */,	252 /* 114 */,	253 /* 115 */,	
253 /* 116 */,	253 /* 117 */,	254 /* 118 */,	254 /* 119 */,	
254 /* 120 */,	254 /* 121 */,	255 /* 122 */,	255 /* 123 */,	
255 /* 124 */,	255 /* 125 */,	255 /* 126 */,	255 /* 127 */,	
};

void Renderer::recompute_amp(Voice *v)
{
	Channel *chan = &channel[v->channel];
	int chanvol = chan->volume;
	int chanexpr = chan->expression;

	if (v->sample->type == INST_GUS)
	{
		v->attenuation = (vol_table[(chanvol * chanexpr) / 127] * vol_table[v->velocity]) * ((127 + 64) / 12419775.f);
	}
	else
	{
		// Implicit modulators from SF2 spec
		double velatten, cc7atten, cc11atten;

		velatten = log10(127.0 / v->velocity);
		cc7atten = log10(127.0 / chanvol);
		cc11atten = log10(127.0 / chanexpr);
		v->attenuation = float(400 * (velatten + cc7atten + cc11atten)) + v->sample->initial_attenuation;
	}
}

// Pan must be in the range [0,1]
void Renderer::compute_pan(double pan, int type, float &left_offset, float &right_offset)
{
	if (pan <= 0)
	{
		left_offset = 1;
		right_offset = 0;
	}
	else if (pan >= 127/128.0)
	{
		left_offset = 0;
		right_offset = 1;
	}
	else
	{
		if (type == INST_GUS)
		{
			/* Original amp equation looks like this:
			 *    calc_gf1_amp(atten + offset)
			 * which expands to:
			 *    2^(16*(atten + offset) - 16)
			 * Keeping in mind that 2^(x + y) == 2^x * 2^y, we can
			 * rewrite this to avoid doing two pows in GF1Envelope::ApplyToAmp():
			 *    2^(16*atten + 16*offset - 16)
			 *    2^(16*atten - 16 + 16 * offset + 16 - 16)
			 *    2^(16*atten - 16) * 2^(16*offset + 16 - 16)
			 *    2^(16*atten - 16) * 2^(16*(offset + 1) - 16)
			 *    calc_gf1_amp(atten) * calc_gf1_amp(offset + 1)
			 */
			right_offset = (float)calc_gf1_amp((log(pan) * (1 / (log_of_2 * 32))) + 1);
			left_offset = (float)calc_gf1_amp((log(1 - pan) * (1 / (log_of_2 * 32))) + 1);
		}
		else
		{
			/* Equal Power Panning for SF2/DLS.
			 */
			left_offset = (float)sqrt(1 - pan);
			right_offset = (float)sqrt(pan);
		}
	}
}

void Renderer::kill_key_group(int i)
{
	int j = voices; 

	if (voice[i].sample->key_group == 0)
	{
		return;
	}
	while (j--)
	{
		if ((voice[j].status & VOICE_RUNNING) && !(voice[j].status & (VOICE_RELEASING | VOICE_STOPPING))) continue;
		if (i == j) continue;
		if (voice[i].channel != voice[j].channel) continue;
		if (voice[j].sample->key_group != voice[i].sample->key_group) continue;
		kill_note(j);
	}
}

float Renderer::calculate_scaled_frequency(Sample *sp, int note)
{
	double scalednote = (note - sp->scale_note) * sp->scale_factor / 1024.0 + sp->scale_note + sp->tune * 0.01;
	return (float)note_to_freq(scalednote);
}

bool Renderer::start_region(int chan, int note, int vel, Sample *sp, float f)
{
	int voicenum;
	Voice *v;

	voicenum = allocate_voice();
	if (voicenum < 0)
	{
		return false;
	}
	v = &voice[voicenum];
	v->sample = sp;

	if (sp->type == INST_GUS)
	{
		v->orig_frequency = f;
	}
	else
	{
		if (sp->scale_factor != 1024)
		{
			v->orig_frequency = calculate_scaled_frequency(sp, note);
		}
		else if (sp->tune != 0)
		{
			v->orig_frequency = note_to_freq(note + sp->tune * 0.01);
		}
		else
		{
			v->orig_frequency = note_to_freq(note);
		}
	}

	v->status = VOICE_RUNNING;
	v->channel = chan;
	v->note = note;
	v->velocity = vel;
	v->sample_offset = 0;
	v->sample_increment = 0; /* make sure it isn't negative */
	v->sample_count = 0;

	v->tremolo_phase = 0;
	v->tremolo_phase_increment = v->sample->tremolo_phase_increment;
	v->tremolo_sweep = v->sample->tremolo_sweep_increment;
	v->tremolo_sweep_position = 0;

	v->vibrato_sweep = v->sample->vibrato_sweep_increment;
	v->vibrato_sweep_position = 0;
	v->vibrato_control_ratio = v->sample->vibrato_control_ratio;
	v->vibrato_control_counter = v->vibrato_phase = 0;

	kill_key_group(voicenum);

	memset(v->vibrato_sample_increment, 0, sizeof(v->vibrato_sample_increment));

	if (sp->type == INST_SF2)
	{
		// Channel pan is added to instrument pan.
		double pan;
		if (channel[chan].panning == NO_PANNING)
		{
			pan = (sp->panning + 500) / 1000.0;
		}
		else
		{
			pan = channel[chan].panning / 128.0 + sp->panning / 1000.0;
		}
		compute_pan(pan, sp->type, v->left_offset, v->right_offset);
	}
	else if (channel[chan].panning != NO_PANNING)
	{
		compute_pan(channel[chan].panning / 128.0, sp->type, v->left_offset, v->right_offset);
	}
	else
	{
		v->left_offset = v->sample->left_offset;
		v->right_offset = v->sample->right_offset;
	}

	recompute_freq(voicenum);
	recompute_amp(v);
	v->control_counter = 0;

	v->eg1.Init(this, v);

	if (v->sample->modes & PATCH_LOOPEN)
	{
		v->status |= VOICE_LPE;
	}
	return true;
}

void Renderer::start_note(int chan, int note, int vel)
{
	Instrument *ip;
	Sample *sp;
	int bank = channel[chan].bank;
	int prog = channel[chan].program;
	int i;
	float f;

	note &= 0x7f;
	if (ISDRUMCHANNEL(chan))
	{
		if (NULL == instruments->drumset[bank] || NULL == (ip = instruments->drumset[bank]->instrument[note]))
		{
			if (!(ip = instruments->drumset[0]->instrument[note]))
				return; /* No instrument? Then we can't play. */
		}
		assert(ip != MAGIC_LOAD_INSTRUMENT);
		if (ip == MAGIC_LOAD_INSTRUMENT)
		{
			return;
		}
		if (ip->samples != 1 && ip->sample->type == INST_GUS)
		{
			cmsg(CMSG_WARNING, VERB_VERBOSE, 
				"Strange: percussion instrument with %d samples!", ip->samples);
		}
	}
	else
	{
		if (channel[chan].program == SPECIAL_PROGRAM)
		{
			ip = default_instrument;
		}
		else if (NULL == instruments->tonebank[bank] || NULL == (ip = instruments->tonebank[bank]->instrument[prog]))
		{
			if (NULL == (ip = instruments->tonebank[0]->instrument[prog]))
				return; /* No instrument? Then we can't play. */
		}
		assert(ip != MAGIC_LOAD_INSTRUMENT);
		if (ip == MAGIC_LOAD_INSTRUMENT)
		{
			return;
		}
	}

	if (NULL == ip->sample || ip->samples == 0)
		return;	/* No samples? Then nothing to play. */

	// For GF1 patches, scaling is based solely on the first
	// waveform in this layer.
	if (ip->sample->type == INST_GUS && ip->sample->scale_factor != 1024)
	{
		f = calculate_scaled_frequency(ip->sample, note);
	}
	else
	{
		f = note_to_freq(note);
	}

	if (ip->sample->type == INST_GUS)
	{
		/* We're more lenient with matching ranges for GUS patches, since the
		 * official Gravis ones don't cover the full range of possible
		 * frequencies for every instrument.
		 */
		if (ip->samples == 1)
		{ // If there's only one sample, definitely play it.
			start_region(chan, note, vel, ip->sample, f);
		}
		for (i = ip->samples, sp = ip->sample; i != 0; --i, ++sp)
		{
			// GUS patches don't have velocity ranges, so no need to compare against them.
			if (sp->low_freq <= f && sp->high_freq >= f)
			{
				if (i > 1 && (sp + 1)->low_freq <= f && (sp + 1)->high_freq >= f)
				{ /* If there is a range of contiguous regions that match our
				   * desired frequency, the last one in that block is used.
				   */
					continue;
				}
				start_region(chan, note, vel, sp, f);
				break;
			}
		}
		if (i == 0)
		{ /* Found nothing. Try again, but look for the one with the closest root frequency.
		   * As per the suggestion in the original TiMidity function, this search uses
		   * note values rather than raw frequencies.
		   */
			double cdiff = 1e10;
			double want_note = freq_to_note(f);
			Sample *closest = sp = ip->sample;
			for (i = ip->samples; i != 0; --i, ++sp)
			{
				double diff = fabs(freq_to_note(sp->root_freq) - want_note);
				if (diff < cdiff)
				{
					cdiff = diff;
					closest = sp;
				}
			}
			start_region(chan, note, vel, closest, f);
		}
	}
	else
	{
		for (i = ip->samples, sp = ip->sample; i != 0; --i, ++sp)
		{
			if ((sp->low_vel <= vel && sp->high_vel >= vel &&
				 sp->low_freq <= f && sp->high_freq >= f))
			{
				if (!start_region(chan, note, vel, sp, f))
				{ // Ran out of voices
					break;
				}
			}
		}
	}
}

void Renderer::kill_note(int i)
{
	Voice *v = &voice[i];

	if (v->status & VOICE_RUNNING)
	{
		v->status &= ~VOICE_SUSTAINING;
		v->status |= VOICE_RELEASING | VOICE_STOPPING;
	}
}

int Renderer::allocate_voice()
{
	int i, lowest;
	float lv, v;

	for (i = 0; i < voices; ++i)
	{
		if (!(voice[i].status & VOICE_RUNNING))
		{
			return i; /* Can't get a lower volume than silence */
		}
	}

	/* Look for the decaying note with the lowest volume */
	lowest = -1;
	lv = 1e10;
	i = voices;
	while (i--)
	{
		if ((voice[i].status & VOICE_RELEASING) && !(voice[i].status & VOICE_STOPPING))
		{
			v = voice[i].attenuation;
			if (v < lv)
			{
				lv = v;
				lowest = i;
			}
		}
	}

	if (lowest >= 0)
	{
		/* This can still cause a click, but if we had a free voice to
		   spare for ramping down this note, we wouldn't need to kill it
		   in the first place... Still, this needs to be fixed. Perhaps
		   we could use a reserve of voices to play dying notes only. */

		cut_notes++;
		voice[lowest].status = 0;
	}
	else
	{
		lost_notes++;
	}
	return lowest;
}

void Renderer::note_on(int chan, int note, int vel)
{
	if (vel == 0)
	{
		note_off(chan, note, 0);
		return;
	}

	int i = voices;

	/* Only one instance of a note can be playing on a single channel. */
	while (i--)
	{
		if (voice[i].channel == chan && ((voice[i].note == note && !voice[i].sample->self_nonexclusive) || channel[chan].mono))
		{
			if (channel[chan].mono)
			{
				kill_note(i);
			}
			else
			{
				finish_note(i);
			}
		}
	}

	start_note(chan, note, vel);
}

void Renderer::finish_note(int i)
{
	Voice *v = &voice[i];

	if ((v->status & (VOICE_RUNNING | VOICE_RELEASING)) == VOICE_RUNNING)
	{
		v->status &= ~VOICE_SUSTAINING;
		v->status |= VOICE_RELEASING;

		if (!(v->sample->modes & PATCH_NO_SRELEASE))
		{
			v->status &= ~VOICE_LPE;	/* sampled release */
		}
		v->eg1.Release(v);
		v->eg2.Release(v);
	}
}

void Renderer::note_off(int chan, int note, int vel)
{
	int i;
	
	for (i = voices; i-- > 0; )
	{
		if ((voice[i].status & VOICE_RUNNING) && !(voice[i].status & (VOICE_RELEASING | VOICE_STOPPING))
			&& voice[i].channel == chan && voice[i].note == note)
		{
			if (channel[chan].sustain)
			{
				voice[i].status |= NOTE_SUSTAIN;
			}
			else
			{
				finish_note(i);
			}
		}
	}
}

/* Process the All Notes Off event */
void Renderer::all_notes_off(int chan)
{
	int i = voices;
	while (i--)
	{
		if ((voice[i].status & VOICE_RUNNING) && voice[i].channel == chan)
		{
			if (channel[chan].sustain) 
			{
				voice[i].status |= NOTE_SUSTAIN;
			}
			else
			{
				finish_note(i);
			}
		}
	}
}

/* Process the All Sounds Off event */
void Renderer::all_sounds_off(int chan)
{
	int i = voices;
	while (i--)
	{
		if (voice[i].channel == chan && 
			(voice[i].status & VOICE_RUNNING) &&
			!(voice[i].status & VOICE_STOPPING))
		{
			kill_note(i);
		}
	}
}

void Renderer::adjust_pressure(int chan, int note, int amount)
{
	int i = voices;
	while (i--)
	{
		if ((voice[i].status & VOICE_RUNNING) &&
			voice[i].channel == chan &&
			voice[i].note == note)
		{
			voice[i].velocity = amount;
			recompute_amp(&voice[i]);
			apply_envelope_to_amp(&voice[i]);
			if (!(voice[i].sample->self_nonexclusive))
			{
				return;
			}
		}
	}
}

void Renderer::adjust_panning(int chan)
{
	Channel *chanp = &channel[chan];
	int i = voices;
	while (i--)
	{
		Voice *v = &voice[i];
		if ((v->channel == chan) && (v->status & VOICE_RUNNING))
		{
			double pan = chanp->panning / 128.0;
			if (v->sample->type == INST_SF2)
			{ // Add instrument pan to channel pan.
				pan += v->sample->panning / 500.0;
			}
			compute_pan(pan, v->sample->type, v->left_offset, v->right_offset);
			apply_envelope_to_amp(v);
		}
	}
}

void Renderer::drop_sustain(int chan)
{
	int i = voices;
	while (i--)
	{
		if (voice[i].channel == chan && (voice[i].status & NOTE_SUSTAIN))
		{
			finish_note(i);
		}
	}
}

void Renderer::adjust_pitchbend(int chan)
{
	int i = voices;
	while (i--)
	{
		if ((voice[i].status & VOICE_RUNNING) && voice[i].channel == chan)
		{
			recompute_freq(i);
		}
	}
}

void Renderer::adjust_volume(int chan)
{
	int i = voices;
	while (i--)
	{
		if (voice[i].channel == chan && (voice[i].status & VOICE_RUNNING))
		{
			recompute_amp(&voice[i]);
			apply_envelope_to_amp(&voice[i]);
		}
	}
}

void Renderer::HandleEvent(int status, int parm1, int parm2)
{
	int command = status & 0xF0;
	int chan	= status & 0x0F;

	switch (command)
	{
	case ME_NOTEON:
		note_on(chan, parm1, parm2);
		break;

	case ME_NOTEOFF:
		note_off(chan, parm1, parm2);
		break;

	case ME_KEYPRESSURE:
		adjust_pressure(chan, parm1, parm2);
		break;

	case ME_CONTROLCHANGE:
		HandleController(chan, parm1, parm2);
		break;

	case ME_PROGRAM:
		if (ISDRUMCHANNEL(chan))
		{
			/* Change drum set */
			channel[chan].bank = parm1;
		}
		else
		{
			channel[chan].program = parm1;
		}
		break;

	case ME_CHANNELPRESSURE:
		/* Unimplemented */
		break;

	case ME_PITCHWHEEL:
		channel[chan].pitchbend = parm1 | (parm2 << 7);
		channel[chan].pitchfactor = 0;
		/* Adjust for notes already playing */
		adjust_pitchbend(chan);
		break;
	}
}

void Renderer::HandleController(int chan, int ctrl, int val)
{
	switch (ctrl)
	{
    /* These should be the SCC-1 tone bank switch
       commands. I don't know why there are two, or
       why the latter only allows switching to bank 0.
       Also, some MIDI files use 0 as some sort of
       continuous controller. This will cause lots of
       warnings about undefined tone banks. */
	case CTRL_BANK_SELECT:
		channel[chan].bank = val;
		break;

	case CTRL_BANK_SELECT+32:
		if (val == 0)
		{
			channel[chan].bank = 0;
		}
		break;

	case CTRL_VOLUME:
		channel[chan].volume = val;
		adjust_volume(chan);
		break;

	case CTRL_EXPRESSION:
		channel[chan].expression = val;
		adjust_volume(chan);
		break;

	case CTRL_PAN:
		channel[chan].panning = val;
		adjust_panning(chan);
		break;

	case CTRL_SUSTAIN:
		channel[chan].sustain = val;
		if (val == 0)
		{
			drop_sustain(chan);
		}
		break;

	case CTRL_NRPN_LSB:
		channel[chan].nrpn = (channel[chan].nrpn & 0x3F80) | (val);
		channel[chan].nrpn_mode = true;
		break;

	case CTRL_NRPN_MSB:
		channel[chan].nrpn = (channel[chan].nrpn & 0x007F) | (val << 7);
		channel[chan].nrpn_mode = true;
		break;

	case CTRL_RPN_LSB:
		channel[chan].rpn = (channel[chan].rpn & 0x3F80) | (val);
		channel[chan].nrpn_mode = false;
		break;

	case CTRL_RPN_MSB:
		channel[chan].rpn = (channel[chan].rpn & 0x007F) | (val << 7);
		channel[chan].nrpn_mode = false;
		break;

	case CTRL_DATA_ENTRY:
		if (channel[chan].nrpn_mode)
		{
			DataEntryCoarseNRPN(chan, channel[chan].nrpn, val);
		}
		else
		{
			DataEntryCoarseRPN(chan, channel[chan].rpn, val);
		}
		break;

	case CTRL_DATA_ENTRY+32:
		if (channel[chan].nrpn_mode)
		{
			DataEntryFineNRPN(chan, channel[chan].nrpn, val);
		}
		else
		{
			DataEntryFineRPN(chan, channel[chan].rpn, val);
		}
		break;

	case CTRL_ALL_SOUNDS_OFF:
		all_sounds_off(chan);
		break;

	case CTRL_RESET_CONTROLLERS:
		reset_controllers(chan);
		break;

	case CTRL_ALL_NOTES_OFF:
		all_notes_off(chan);
		break;
	}
}

void Renderer::DataEntryCoarseRPN(int chan, int rpn, int val)
{
	switch (rpn)
	{
	case RPN_PITCH_SENS:
		channel[chan].pitchsens = (channel[chan].pitchsens % 100) + (val * 100);
		channel[chan].pitchfactor = 0;
		break;

	// TiMidity resets the pitch sensitivity when a song attempts to write to
	// RPN_RESET. My docs tell me this is just a dummy value that is guaranteed
	// to not cause future data entry to go anywhere until a new RPN is set.
	}
}

void Renderer::DataEntryFineRPN(int chan, int rpn, int val)
{
	switch (rpn)
	{
	case RPN_PITCH_SENS:
		channel[chan].pitchsens = (channel[chan].pitchsens / 100) * 100 + val;
		channel[chan].pitchfactor = 0;
		break;
	}
}

void Renderer::DataEntryCoarseNRPN(int chan, int nrpn, int val)
{
}

void Renderer::DataEntryFineNRPN(int chan, int nrpn, int val)
{
}

void Renderer::HandleLongMessage(const uint8_t *data, int len)
{
	// SysEx handling goes here.
}

void Renderer::Reset()
{
	lost_notes = cut_notes = 0;
	reset_midi();
}

}