mirror of https://github.com/ZDoom/raze-gles.git
6149 lines
185 KiB
C++
6149 lines
185 KiB
C++
/*
|
|
TiMidity++ -- MIDI to WAVE converter and player
|
|
Copyright (C) 1999-2009 Masanao Izumo <iz@onicos.co.jp>
|
|
Copyright (C) 1995 Tuukka Toivonen <tt@cgs.fi>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; 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 <algorithm>
|
|
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include "timidity.h"
|
|
#include "common.h"
|
|
#include "instrum.h"
|
|
#include "playmidi.h"
|
|
#include "mix.h"
|
|
#include "recache.h"
|
|
#include "reverb.h"
|
|
#include "freq.h"
|
|
#include "quantity.h"
|
|
#include "tables.h"
|
|
#include "effect.h"
|
|
|
|
|
|
namespace TimidityPlus
|
|
{
|
|
std::mutex ConfigMutex;
|
|
int timidity_modulation_wheel = true;
|
|
int timidity_portamento = false;
|
|
int timidity_reverb = 0;
|
|
int timidity_chorus = 0;
|
|
int timidity_surround_chorus = false; // requires restart!
|
|
int timidity_channel_pressure = false;
|
|
int timidity_lpf_def = true;
|
|
int timidity_temper_control = true;
|
|
int timidity_modulation_envelope = true;
|
|
int timidity_overlap_voice_allow = true;
|
|
int timidity_drum_effect = false;
|
|
int timidity_pan_delay = false;
|
|
float timidity_drum_power = 1.f;
|
|
int timidity_key_adjust = 0;
|
|
float timidity_tempo_adjust = 1.f;
|
|
float min_sustain_time = 5000;
|
|
|
|
// The following options have no generic use and are only meaningful for some SYSEX events not normally found in common MIDIs.
|
|
// For now they are kept as unchanging global variables
|
|
static bool opt_eq_control = false;
|
|
static bool op_nrpn_vibrato = true;
|
|
static bool opt_tva_attack = false;
|
|
static bool opt_tva_decay = false;
|
|
static bool opt_tva_release = false;
|
|
static bool opt_insertion_effect = false;
|
|
static bool opt_delay_control = false;
|
|
|
|
|
|
// These two variables need to remain global or things will get messy because they get accessed from non-class code.
|
|
int32_t control_ratio = 22;
|
|
int32_t playback_rate = 22050;
|
|
|
|
#define PLAY_INTERLEAVE_SEC 1.0
|
|
#define PORTAMENTO_TIME_TUNING (1.0 / 5000.0)
|
|
#define PORTAMENTO_CONTROL_RATIO 256 /* controls per sec */
|
|
#define DEFAULT_CHORUS_DELAY1 0.02
|
|
#define DEFAULT_CHORUS_DELAY2 0.003
|
|
#define CHORUS_OPPOSITE_THRESHOLD 32
|
|
#define EOT_PRESEARCH_LEN 32
|
|
#define SPEED_CHANGE_RATE 1.0594630943592953 /* 2^(1/12) */
|
|
#define DEFAULT_AMPLIFICATION 70
|
|
#define VIBRATO_DEPTH_MAX 384 /* 600 cent */
|
|
|
|
void set_playback_rate(int freq)
|
|
{
|
|
const int CONTROLS_PER_SECOND = 1000;
|
|
const int MAX_CONTROL_RATIO = 255;
|
|
|
|
playback_rate = freq;
|
|
control_ratio = playback_rate / CONTROLS_PER_SECOND;
|
|
if (control_ratio < 1)
|
|
control_ratio = 1;
|
|
else if (control_ratio > MAX_CONTROL_RATIO)
|
|
control_ratio = MAX_CONTROL_RATIO;
|
|
}
|
|
|
|
|
|
Player::Player(Instruments *instr)
|
|
{
|
|
last_reverb_setting = timidity_reverb;
|
|
memset(this, 0, sizeof(*this));
|
|
|
|
// init one-time global stuff - this should go to the device class once it exists.
|
|
instruments = instr;
|
|
initialize_resampler_coeffs();
|
|
init_tables();
|
|
|
|
new_midi_file_info();
|
|
init_mblock(&playmidi_pool);
|
|
|
|
reverb = new Reverb;
|
|
reverb->init_effect_status(play_system_mode);
|
|
effect = new Effect(reverb);
|
|
|
|
|
|
mixer = new Mixer(this);
|
|
recache = new Recache(this);
|
|
|
|
for (int i = 0; i < MAX_CHANNELS; i++)
|
|
init_channel_layer(i);
|
|
|
|
instruments->init_userdrum();
|
|
instruments->init_userinst();
|
|
|
|
master_volume_ratio = 0xFFFF;
|
|
vol_table = def_vol_table;
|
|
|
|
play_system_mode = DEFAULT_SYSTEM_MODE;
|
|
midi_streaming = 0;
|
|
stream_max_compute = 500; /* compute time limit (in msec) when streaming */
|
|
current_keysig = 0;
|
|
current_temper_keysig = 0;
|
|
temper_adj = 0;
|
|
current_play_tempo = 500000;
|
|
opt_realtime_playing = 0;
|
|
check_eot_flag = 0;
|
|
playmidi_seek_flag = 0;
|
|
opt_pure_intonation = 0;
|
|
current_freq_table = 0;
|
|
current_temper_freq_table = 0;
|
|
master_tuning = 0;
|
|
|
|
make_rvid_flag = 0; /* For reverb optimization */
|
|
|
|
voices = DEFAULT_VOICES;
|
|
amplification = DEFAULT_AMPLIFICATION;
|
|
|
|
|
|
static const int drums[] = { 10, -1 };
|
|
|
|
CLEAR_CHANNELMASK(default_drumchannels);
|
|
for (int i = 0; drums[i] > 0; i++)
|
|
{
|
|
SET_CHANNELMASK(default_drumchannels, drums[i] - 1);
|
|
}
|
|
for (int i = 16; i < MAX_CHANNELS; i++)
|
|
{
|
|
if (IS_SET_CHANNELMASK(default_drumchannels, i & 0xF))
|
|
SET_CHANNELMASK(default_drumchannels, i);
|
|
}
|
|
COPY_CHANNELMASK(drumchannels, default_drumchannels);
|
|
COPY_CHANNELMASK(drumchannel_mask, default_drumchannel_mask);
|
|
|
|
}
|
|
|
|
Player::~Player()
|
|
{
|
|
reuse_mblock(&playmidi_pool);
|
|
if (reverb_buffer != nullptr) free(reverb_buffer);
|
|
for (int i = 0; i < MAX_CHANNELS; i++) free_drum_effect(i);
|
|
delete mixer;
|
|
delete recache;
|
|
delete effect;
|
|
delete reverb;
|
|
}
|
|
|
|
|
|
bool Player::IS_SYSEX_EVENT_TYPE(MidiEvent *event)
|
|
{
|
|
return ((event)->type == ME_NONE || (event)->type >= ME_RANDOM_PAN || (event)->b == SYSEX_TAG);
|
|
}
|
|
|
|
|
|
void Player::init_freq_table_user(void)
|
|
{
|
|
int p, i, j, k, l;
|
|
double f;
|
|
|
|
for (p = 0; p < 4; p++)
|
|
for (i = 0; i < 12; i++)
|
|
for (j = -1; j < 11; j++) {
|
|
f = 440 * pow(2.0, (i - 9) / 12.0 + j - 5);
|
|
for (k = 0; k < 12; k++) {
|
|
l = i + j * 12 + k;
|
|
if (l < 0 || l >= 128)
|
|
continue;
|
|
freq_table_user[p][i][l] = f * 1000 + 0.5;
|
|
freq_table_user[p][i + 12][l] = f * 1000 + 0.5;
|
|
freq_table_user[p][i + 24][l] = f * 1000 + 0.5;
|
|
freq_table_user[p][i + 36][l] = f * 1000 + 0.5;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*! convert Hz to internal vibrato control ratio. */
|
|
double Player::cnv_Hz_to_vib_ratio(double freq)
|
|
{
|
|
return ((double)(playback_rate) / (freq * 2.0f * VIBRATO_SAMPLE_INCREMENTS));
|
|
}
|
|
|
|
void Player::adjust_amplification(void)
|
|
{
|
|
static const double compensation_ratio = 1.0;
|
|
/* compensate master volume */
|
|
master_volume = (double)(amplification) / 100.0 *
|
|
((double)master_volume_ratio * (compensation_ratio/0xFFFF));
|
|
}
|
|
|
|
int Player::new_vidq(int ch, int note)
|
|
{
|
|
int i;
|
|
|
|
if(timidity_overlap_voice_allow)
|
|
{
|
|
i = ch * 128 + note;
|
|
return vidq_head[i]++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int Player::last_vidq(int ch, int note)
|
|
{
|
|
int i;
|
|
|
|
if(timidity_overlap_voice_allow)
|
|
{
|
|
i = ch * 128 + note;
|
|
if(vidq_head[i] == vidq_tail[i])
|
|
{
|
|
return -1;
|
|
}
|
|
return vidq_tail[i]++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void Player::reset_voices(void)
|
|
{
|
|
int i;
|
|
for(i = 0; i < max_voices; i++)
|
|
{
|
|
voice[i].status = VOICE_FREE;
|
|
voice[i].temper_instant = 0;
|
|
voice[i].chorus_link = i;
|
|
}
|
|
upper_voices = 0;
|
|
memset(vidq_head, 0, sizeof(vidq_head));
|
|
memset(vidq_tail, 0, sizeof(vidq_tail));
|
|
}
|
|
|
|
void Player::kill_note(int i)
|
|
{
|
|
voice[i].status = VOICE_DIE;
|
|
}
|
|
|
|
void Player::kill_all_voices(void)
|
|
{
|
|
int i, uv = upper_voices;
|
|
|
|
for(i = 0; i < uv; i++)
|
|
if(voice[i].status & ~(VOICE_FREE | VOICE_DIE))
|
|
kill_note(i);
|
|
memset(vidq_head, 0, sizeof(vidq_head));
|
|
memset(vidq_tail, 0, sizeof(vidq_tail));
|
|
}
|
|
|
|
void Player::reset_drum_controllers(struct DrumParts *d[], int note)
|
|
{
|
|
int i, j;
|
|
|
|
if (note == -1)
|
|
{
|
|
for (i = 0; i < 128; i++)
|
|
if (d[i] != NULL)
|
|
{
|
|
d[i]->drum_panning = NO_PANNING;
|
|
for (j = 0; j < 6; j++) { d[i]->drum_envelope_rate[j] = -1; }
|
|
d[i]->pan_random = 0;
|
|
d[i]->drum_level = 1.0f;
|
|
d[i]->coarse = 0;
|
|
d[i]->fine = 0;
|
|
d[i]->delay_level = -1;
|
|
d[i]->chorus_level = -1;
|
|
d[i]->reverb_level = -1;
|
|
d[i]->play_note = -1;
|
|
d[i]->drum_cutoff_freq = 0;
|
|
d[i]->drum_resonance = 0;
|
|
init_rx_drum(d[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
d[note]->drum_panning = NO_PANNING;
|
|
for (j = 0; j < 6; j++) { d[note]->drum_envelope_rate[j] = -1; }
|
|
d[note]->pan_random = 0;
|
|
d[note]->drum_level = 1.0f;
|
|
d[note]->coarse = 0;
|
|
d[note]->fine = 0;
|
|
d[note]->delay_level = -1;
|
|
d[note]->chorus_level = -1;
|
|
d[note]->reverb_level = -1;
|
|
d[note]->play_note = -1;
|
|
d[note]->drum_cutoff_freq = 0;
|
|
d[note]->drum_resonance = 0;
|
|
init_rx_drum(d[note]);
|
|
}
|
|
}
|
|
|
|
void Player::reset_nrpn_controllers(int c)
|
|
{
|
|
int i;
|
|
|
|
/* NRPN */
|
|
reset_drum_controllers(channel[c].drums, -1);
|
|
channel[c].vibrato_ratio = 1.0;
|
|
channel[c].vibrato_depth = 0;
|
|
channel[c].vibrato_delay = 0;
|
|
channel[c].param_cutoff_freq = 0;
|
|
channel[c].param_resonance = 0;
|
|
channel[c].cutoff_freq_coef = 1.0;
|
|
channel[c].resonance_dB = 0;
|
|
|
|
/* System Exclusive */
|
|
channel[c].dry_level = 127;
|
|
channel[c].eq_gs = 1;
|
|
channel[c].insertion_effect = 0;
|
|
channel[c].velocity_sense_depth = 0x40;
|
|
channel[c].velocity_sense_offset = 0x40;
|
|
channel[c].pitch_offset_fine = 0;
|
|
if (play_system_mode == GS_SYSTEM_MODE) { channel[c].assign_mode = 1; }
|
|
else {
|
|
if (ISDRUMCHANNEL(c)) { channel[c].assign_mode = 1; }
|
|
else { channel[c].assign_mode = 2; }
|
|
}
|
|
for (i = 0; i < 12; i++)
|
|
channel[c].scale_tuning[i] = 0;
|
|
channel[c].prev_scale_tuning = 0;
|
|
channel[c].temper_type = 0;
|
|
|
|
init_channel_layer(c);
|
|
init_part_eq_xg(&(channel[c].eq_xg));
|
|
|
|
/* channel pressure & polyphonic key pressure control */
|
|
init_midi_controller(&(channel[c].mod));
|
|
init_midi_controller(&(channel[c].bend));
|
|
init_midi_controller(&(channel[c].caf));
|
|
init_midi_controller(&(channel[c].paf));
|
|
init_midi_controller(&(channel[c].cc1));
|
|
init_midi_controller(&(channel[c].cc2));
|
|
channel[c].bend.pitch = 2;
|
|
|
|
init_rx(c);
|
|
channel[c].note_limit_high = 127;
|
|
channel[c].note_limit_low = 0;
|
|
channel[c].vel_limit_high = 127;
|
|
channel[c].vel_limit_low = 0;
|
|
|
|
free_drum_effect(c);
|
|
|
|
channel[c].legato = 0;
|
|
channel[c].damper_mode = 0;
|
|
channel[c].loop_timeout = 0;
|
|
|
|
channel[c].sysex_gs_msb_addr = channel[c].sysex_gs_msb_val =
|
|
channel[c].sysex_xg_msb_addr = channel[c].sysex_xg_msb_val =
|
|
channel[c].sysex_msb_addr = channel[c].sysex_msb_val = 0;
|
|
}
|
|
|
|
/* Process the Reset All Controllers event */
|
|
void Player::reset_controllers(int c)
|
|
{
|
|
int j;
|
|
/* Some standard says, although the SCC docs say 0. */
|
|
|
|
if (play_system_mode == XG_SYSTEM_MODE)
|
|
channel[c].volume = 100;
|
|
else
|
|
channel[c].volume = 90;
|
|
|
|
channel[c].expression = 127; /* SCC-1 does this. */
|
|
channel[c].sustain = 0;
|
|
channel[c].sostenuto = 0;
|
|
channel[c].pitchbend = 0x2000;
|
|
channel[c].pitchfactor = 0; /* to be computed */
|
|
channel[c].mod.val = 0;
|
|
channel[c].bend.val = 0;
|
|
channel[c].caf.val = 0;
|
|
channel[c].paf.val = 0;
|
|
channel[c].cc1.val = 0;
|
|
channel[c].cc2.val = 0;
|
|
channel[c].portamento_time_lsb = 0;
|
|
channel[c].portamento_time_msb = 0;
|
|
channel[c].porta_control_ratio = 0;
|
|
channel[c].portamento = 0;
|
|
channel[c].last_note_fine = -1;
|
|
for (j = 0; j < 6; j++) { channel[c].envelope_rate[j] = -1; }
|
|
update_portamento_controls(c);
|
|
set_reverb_level(c, -1);
|
|
if (timidity_chorus == 1)
|
|
channel[c].chorus_level = 0;
|
|
else
|
|
channel[c].chorus_level = -timidity_chorus;
|
|
channel[c].mono = 0;
|
|
channel[c].delay_level = 0;
|
|
}
|
|
|
|
int Player::get_default_mapID(int ch)
|
|
{
|
|
if (play_system_mode == XG_SYSTEM_MODE)
|
|
return ISDRUMCHANNEL(ch) ? XG_DRUM_MAP : XG_NORMAL_MAP;
|
|
return INST_NO_MAP;
|
|
}
|
|
|
|
void Player::reset_midi(int playing)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_CHANNELS; i++) {
|
|
reset_controllers(i);
|
|
reset_nrpn_controllers(i);
|
|
channel[i].tone_map0_number = 0;
|
|
channel[i].mod.lfo1_pitch_depth = 50;
|
|
/* The rest of these are unaffected
|
|
* by the Reset All Controllers event
|
|
*/
|
|
channel[i].program = instruments->defaultProgram(i);
|
|
channel[i].panning = NO_PANNING;
|
|
channel[i].pan_random = 0;
|
|
/* tone bank or drum set */
|
|
if (ISDRUMCHANNEL(i)) {
|
|
channel[i].bank = 0;
|
|
channel[i].altassign = instruments->drumSet(0)->alt;
|
|
} else {
|
|
if (special_tonebank >= 0)
|
|
channel[i].bank = special_tonebank;
|
|
else
|
|
channel[i].bank = default_tonebank;
|
|
}
|
|
channel[i].bank_lsb = channel[i].bank_msb = 0;
|
|
if (play_system_mode == XG_SYSTEM_MODE && i % 16 == 9)
|
|
channel[i].bank_msb = 127; /* Use MSB=127 for XG */
|
|
update_rpn_map(i, RPN_ADDR_FFFF, 0);
|
|
channel[i].special_sample = 0;
|
|
channel[i].key_shift = 0;
|
|
channel[i].mapID = get_default_mapID(i);
|
|
channel[i].lasttime = 0;
|
|
}
|
|
if (playing) {
|
|
kill_all_voices();
|
|
if (temper_type_mute) {
|
|
if (temper_type_mute & 1)
|
|
FILL_CHANNELMASK(channel_mute);
|
|
else
|
|
CLEAR_CHANNELMASK(channel_mute);
|
|
}
|
|
} else
|
|
reset_voices();
|
|
master_volume_ratio = 0xffff;
|
|
adjust_amplification();
|
|
master_tuning = 0;
|
|
if (current_file_info) {
|
|
COPY_CHANNELMASK(drumchannels, current_file_info->drumchannels);
|
|
COPY_CHANNELMASK(drumchannel_mask,
|
|
current_file_info->drumchannel_mask);
|
|
} else {
|
|
COPY_CHANNELMASK(drumchannels, default_drumchannels);
|
|
COPY_CHANNELMASK(drumchannel_mask, default_drumchannel_mask);
|
|
}
|
|
}
|
|
|
|
void Player::recompute_freq(int v)
|
|
{
|
|
int i;
|
|
int ch = voice[v].channel;
|
|
int note = voice[v].note;
|
|
int32_t tuning = 0;
|
|
int8_t st = channel[ch].scale_tuning[note % 12];
|
|
int8_t tt = channel[ch].temper_type;
|
|
uint8_t tp = channel[ch].rpnmap[RPN_ADDR_0003];
|
|
int32_t f;
|
|
int pb = channel[ch].pitchbend;
|
|
int32_t tmp;
|
|
double pf, root_freq;
|
|
int32_t a;
|
|
Voice *vp = &(voice[v]);
|
|
|
|
if (! voice[v].sample->sample_rate)
|
|
return;
|
|
if (! timidity_modulation_wheel)
|
|
channel[ch].mod.val = 0;
|
|
if (! timidity_portamento)
|
|
voice[v].porta_control_ratio = 0;
|
|
voice[v].vibrato_control_ratio = voice[v].orig_vibrato_control_ratio;
|
|
if (voice[v].vibrato_control_ratio || channel[ch].mod.val > 0) {
|
|
/* This instrument has vibrato. Invalidate any precomputed
|
|
* sample_increments.
|
|
*/
|
|
|
|
/* MIDI controllers LFO pitch depth */
|
|
if (timidity_channel_pressure || timidity_modulation_wheel) {
|
|
vp->vibrato_depth = vp->sample->vibrato_depth + channel[ch].vibrato_depth;
|
|
vp->vibrato_depth += get_midi_controller_pitch_depth(&(channel[ch].mod))
|
|
+ get_midi_controller_pitch_depth(&(channel[ch].bend))
|
|
+ get_midi_controller_pitch_depth(&(channel[ch].caf))
|
|
+ get_midi_controller_pitch_depth(&(channel[ch].paf))
|
|
+ get_midi_controller_pitch_depth(&(channel[ch].cc1))
|
|
+ get_midi_controller_pitch_depth(&(channel[ch].cc2));
|
|
if (vp->vibrato_depth > VIBRATO_DEPTH_MAX) {vp->vibrato_depth = VIBRATO_DEPTH_MAX;}
|
|
else if (vp->vibrato_depth < 1) {vp->vibrato_depth = 1;}
|
|
if (vp->sample->vibrato_depth < 0) { /* in opposite phase */
|
|
vp->vibrato_depth = -vp->vibrato_depth;
|
|
}
|
|
}
|
|
|
|
/* fill parameters for modulation wheel */
|
|
if (channel[ch].mod.val > 0) {
|
|
if(vp->vibrato_control_ratio == 0) {
|
|
vp->vibrato_control_ratio =
|
|
vp->orig_vibrato_control_ratio = (int)(cnv_Hz_to_vib_ratio(5.0) * channel[ch].vibrato_ratio);
|
|
}
|
|
vp->vibrato_delay = 0;
|
|
}
|
|
|
|
for (i = 0; i < VIBRATO_SAMPLE_INCREMENTS; i++)
|
|
vp->vibrato_sample_increment[i] = 0;
|
|
vp->cache = NULL;
|
|
}
|
|
/* At least for GM2, it's recommended not to apply master_tuning for drum channels */
|
|
tuning = ISDRUMCHANNEL(ch) ? 0 : master_tuning;
|
|
/* fine: [0..128] => [-256..256]
|
|
* 1 coarse = 256 fine (= 1 note)
|
|
* 1 fine = 2^5 tuning
|
|
*/
|
|
tuning += (channel[ch].rpnmap[RPN_ADDR_0001] - 0x40
|
|
+ (channel[ch].rpnmap[RPN_ADDR_0002] - 0x40) * 64) << 7;
|
|
/* for NRPN Coarse Pitch of Drum (GS) & Fine Pitch of Drum (XG) */
|
|
if (ISDRUMCHANNEL(ch) && channel[ch].drums[note] != NULL
|
|
&& (channel[ch].drums[note]->fine
|
|
|| channel[ch].drums[note]->coarse)) {
|
|
tuning += (channel[ch].drums[note]->fine
|
|
+ channel[ch].drums[note]->coarse * 64) << 7;
|
|
}
|
|
/* MIDI controllers pitch control */
|
|
if (timidity_channel_pressure) {
|
|
tuning += get_midi_controller_pitch(&(channel[ch].mod))
|
|
+ get_midi_controller_pitch(&(channel[ch].bend))
|
|
+ get_midi_controller_pitch(&(channel[ch].caf))
|
|
+ get_midi_controller_pitch(&(channel[ch].paf))
|
|
+ get_midi_controller_pitch(&(channel[ch].cc1))
|
|
+ get_midi_controller_pitch(&(channel[ch].cc2));
|
|
}
|
|
if (timidity_modulation_envelope) {
|
|
if (voice[v].sample->tremolo_to_pitch) {
|
|
tuning += lookup_triangular(voice[v].tremolo_phase >> RATE_SHIFT)
|
|
* (voice[v].sample->tremolo_to_pitch << 13) / 100.0 + 0.5;
|
|
channel[ch].pitchfactor = 0;
|
|
}
|
|
if (voice[v].sample->modenv_to_pitch) {
|
|
tuning += voice[v].last_modenv_volume
|
|
* (voice[v].sample->modenv_to_pitch << 13) / 100.0 + 0.5;
|
|
channel[ch].pitchfactor = 0;
|
|
}
|
|
}
|
|
/* GS/XG - Scale Tuning */
|
|
if (! ISDRUMCHANNEL(ch)) {
|
|
tuning += ((st << 13) + 50) / 100;
|
|
if (st != channel[ch].prev_scale_tuning) {
|
|
channel[ch].pitchfactor = 0;
|
|
channel[ch].prev_scale_tuning = st;
|
|
}
|
|
}
|
|
if (! opt_pure_intonation
|
|
&& timidity_temper_control && voice[v].temper_instant) {
|
|
switch (tt) {
|
|
case 0:
|
|
f = freq_table_tuning[tp][note];
|
|
break;
|
|
case 1:
|
|
if (current_temper_keysig < 8)
|
|
f = freq_table_pytha[current_temper_freq_table][note];
|
|
else
|
|
f = freq_table_pytha[current_temper_freq_table + 12][note];
|
|
break;
|
|
case 2:
|
|
if (current_temper_keysig < 8)
|
|
f = freq_table_meantone[current_temper_freq_table
|
|
+ ((temper_adj) ? 36 : 0)][note];
|
|
else
|
|
f = freq_table_meantone[current_temper_freq_table
|
|
+ ((temper_adj) ? 24 : 12)][note];
|
|
break;
|
|
case 3:
|
|
if (current_temper_keysig < 8)
|
|
f = freq_table_pureint[current_temper_freq_table
|
|
+ ((temper_adj) ? 36 : 0)][note];
|
|
else
|
|
f = freq_table_pureint[current_temper_freq_table
|
|
+ ((temper_adj) ? 24 : 12)][note];
|
|
break;
|
|
default: /* user-defined temperament */
|
|
if ((tt -= 0x40) >= 0 && tt < 4) {
|
|
if (current_temper_keysig < 8)
|
|
f = freq_table_user[tt][current_temper_freq_table
|
|
+ ((temper_adj) ? 36 : 0)][note];
|
|
else
|
|
f = freq_table_user[tt][current_temper_freq_table
|
|
+ ((temper_adj) ? 24 : 12)][note];
|
|
} else
|
|
f = freq_table[note];
|
|
break;
|
|
}
|
|
voice[v].orig_frequency = f;
|
|
}
|
|
if (! voice[v].porta_control_ratio) {
|
|
if (tuning == 0 && pb == 0x2000)
|
|
voice[v].frequency = voice[v].orig_frequency;
|
|
else {
|
|
pb -= 0x2000;
|
|
if (! channel[ch].pitchfactor) {
|
|
/* Damn. Somebody bent the pitch. */
|
|
tmp = pb * channel[ch].rpnmap[RPN_ADDR_0000] + tuning;
|
|
if (tmp >= 0)
|
|
channel[ch].pitchfactor = bend_fine[tmp >> 5 & 0xff]
|
|
* bend_coarse[tmp >> 13 & 0x7f];
|
|
else
|
|
channel[ch].pitchfactor = 1.0 /
|
|
(bend_fine[-tmp >> 5 & 0xff]
|
|
* bend_coarse[-tmp >> 13 & 0x7f]);
|
|
}
|
|
voice[v].frequency =
|
|
voice[v].orig_frequency * channel[ch].pitchfactor;
|
|
if (voice[v].frequency != voice[v].orig_frequency)
|
|
voice[v].cache = NULL;
|
|
}
|
|
} else { /* Portamento */
|
|
pb -= 0x2000;
|
|
tmp = pb * channel[ch].rpnmap[RPN_ADDR_0000]
|
|
+ (voice[v].porta_pb << 5) + tuning;
|
|
if (tmp >= 0)
|
|
pf = bend_fine[tmp >> 5 & 0xff]
|
|
* bend_coarse[tmp >> 13 & 0x7f];
|
|
else
|
|
pf = 1.0 / (bend_fine[-tmp >> 5 & 0xff]
|
|
* bend_coarse[-tmp >> 13 & 0x7f]);
|
|
voice[v].frequency = voice[v].orig_frequency * pf;
|
|
voice[v].cache = NULL;
|
|
}
|
|
root_freq = voice[v].sample->root_freq;
|
|
a = TIM_FSCALE(((double) voice[v].sample->sample_rate
|
|
* ((double)voice[v].frequency + channel[ch].pitch_offset_fine))
|
|
/ (root_freq * playback_rate), FRACTION_BITS) + 0.5;
|
|
/* need to preserve the loop direction */
|
|
voice[v].sample_increment = (voice[v].sample_increment >= 0) ? a : -a;
|
|
}
|
|
|
|
int32_t Player::calc_velocity(int32_t ch,int32_t vel)
|
|
{
|
|
int32_t velocity;
|
|
velocity = channel[ch].velocity_sense_depth * vel / 64 + (channel[ch].velocity_sense_offset - 64) * 2;
|
|
if(velocity > 127) {velocity = 127;}
|
|
return velocity;
|
|
}
|
|
|
|
void Player::recompute_voice_tremolo(int v)
|
|
{
|
|
Voice *vp = &(voice[v]);
|
|
int ch = vp->channel;
|
|
int32_t depth = vp->sample->tremolo_depth;
|
|
depth += get_midi_controller_amp_depth(&(channel[ch].mod))
|
|
+ get_midi_controller_amp_depth(&(channel[ch].bend))
|
|
+ get_midi_controller_amp_depth(&(channel[ch].caf))
|
|
+ get_midi_controller_amp_depth(&(channel[ch].paf))
|
|
+ get_midi_controller_amp_depth(&(channel[ch].cc1))
|
|
+ get_midi_controller_amp_depth(&(channel[ch].cc2));
|
|
if(depth > 256) {depth = 256;}
|
|
vp->tremolo_depth = depth;
|
|
}
|
|
|
|
void Player::recompute_amp(int v)
|
|
{
|
|
double tempamp;
|
|
int ch = voice[v].channel;
|
|
|
|
/* master_volume and sample->volume are percentages, used to scale
|
|
* amplitude directly, NOT perceived volume
|
|
*
|
|
* all other MIDI volumes are linear in perceived volume, 0-127
|
|
* use a lookup table for the non-linear scalings
|
|
*/
|
|
if (play_system_mode == GM2_SYSTEM_MODE) {
|
|
tempamp = master_volume *
|
|
voice[v].sample->volume *
|
|
gm2_vol_table[calc_velocity(ch, voice[v].velocity)] * /* velocity: not in GM2 standard */
|
|
gm2_vol_table[channel[ch].volume] *
|
|
gm2_vol_table[channel[ch].expression]; /* 21 bits */
|
|
}
|
|
else if (play_system_mode == GS_SYSTEM_MODE) { /* use measured curve */
|
|
tempamp = master_volume *
|
|
voice[v].sample->volume *
|
|
sc_vel_table[calc_velocity(ch, voice[v].velocity)] *
|
|
sc_vol_table[channel[ch].volume] *
|
|
sc_vol_table[channel[ch].expression]; /* 21 bits */
|
|
}
|
|
else { /* use generic exponential curve */
|
|
tempamp = master_volume *
|
|
voice[v].sample->volume *
|
|
perceived_vol_table[calc_velocity(ch, voice[v].velocity)] *
|
|
perceived_vol_table[channel[ch].volume] *
|
|
perceived_vol_table[channel[ch].expression]; /* 21 bits */
|
|
}
|
|
|
|
/* every digital effect increases amplitude,
|
|
* so that it must be reduced in advance.
|
|
*/
|
|
if (
|
|
(timidity_reverb || timidity_chorus || opt_delay_control
|
|
|| (opt_eq_control && (reverb->eq_status_gs.low_gain != 0x40
|
|
|| reverb->eq_status_gs.high_gain != 0x40))
|
|
|| opt_insertion_effect))
|
|
tempamp *= 1.35f * 0.55f;
|
|
else
|
|
tempamp *= 1.35f;
|
|
|
|
/* Reduce amplitude for chorus partners.
|
|
* 2x voices -> 2x power -> sqrt(2)x amplitude.
|
|
* 1 / sqrt(2) = ~0.7071, which is very close to the old
|
|
* CHORUS_VELOCITY_TUNING1 value of 0.7.
|
|
*
|
|
* The previous amp scaling for the various digital effects should
|
|
* really be redone to split them into separate scalings for each
|
|
* effect, rather than a single scaling if any one of them is used
|
|
* (which is NOT correct). As it is now, if partner chorus is the
|
|
* only effect in use, then it is reduced in volume twice and winds
|
|
* up too quiet. Compare the output of "-EFreverb=0 -EFchorus=0",
|
|
* "-EFreverb=0 -EFchorus=2", "-EFreverb=4 -EFchorus=2", and
|
|
* "-EFreverb=4 -EFchorus=0" to see how the digital effect volumes
|
|
* are not scaled properly. Idealy, all the resulting output should
|
|
* have the same volume, regardless of effects used. This will
|
|
* require empirically determining the amount to scale for each
|
|
* individual effect.
|
|
*/
|
|
if (voice[v].chorus_link != v)
|
|
tempamp *= 0.7071067811865f;
|
|
|
|
/* NRPN - drum instrument tva level */
|
|
if (ISDRUMCHANNEL(ch)) {
|
|
if (channel[ch].drums[voice[v].note] != NULL) {
|
|
tempamp *= channel[ch].drums[voice[v].note]->drum_level;
|
|
}
|
|
tempamp *= (double)timidity_drum_power; /* global drum power */
|
|
}
|
|
|
|
/* MIDI controllers amplitude control */
|
|
if (timidity_channel_pressure) {
|
|
tempamp *= get_midi_controller_amp(&(channel[ch].mod))
|
|
* get_midi_controller_amp(&(channel[ch].bend))
|
|
* get_midi_controller_amp(&(channel[ch].caf))
|
|
* get_midi_controller_amp(&(channel[ch].paf))
|
|
* get_midi_controller_amp(&(channel[ch].cc1))
|
|
* get_midi_controller_amp(&(channel[ch].cc2));
|
|
recompute_voice_tremolo(v);
|
|
}
|
|
|
|
if (voice[v].fc.type != 0) {
|
|
tempamp *= voice[v].fc.gain; /* filter gain */
|
|
}
|
|
|
|
/* applying panning to amplitude */
|
|
if (true)
|
|
{
|
|
if (voice[v].panning == 64)
|
|
{
|
|
voice[v].panned = PANNED_CENTER;
|
|
voice[v].left_amp = voice[v].right_amp = TIM_FSCALENEG(tempamp * pan_table[64], 27);
|
|
}
|
|
else if (voice[v].panning < 2)
|
|
{
|
|
voice[v].panned = PANNED_LEFT;
|
|
voice[v].left_amp = TIM_FSCALENEG(tempamp, 20);
|
|
voice[v].right_amp = 0;
|
|
}
|
|
else if (voice[v].panning == 127)
|
|
{
|
|
if (voice[v].panned == PANNED_MYSTERY) {
|
|
voice[v].old_left_mix = voice[v].old_right_mix;
|
|
voice[v].old_right_mix = 0;
|
|
}
|
|
voice[v].panned = PANNED_RIGHT;
|
|
voice[v].left_amp = TIM_FSCALENEG(tempamp, 20);
|
|
voice[v].right_amp = 0;
|
|
}
|
|
else
|
|
{
|
|
if (voice[v].panned == PANNED_RIGHT) {
|
|
voice[v].old_right_mix = voice[v].old_left_mix;
|
|
voice[v].old_left_mix = 0;
|
|
}
|
|
voice[v].panned = PANNED_MYSTERY;
|
|
voice[v].left_amp = TIM_FSCALENEG(tempamp * pan_table[128 - voice[v].panning], 27);
|
|
voice[v].right_amp = TIM_FSCALENEG(tempamp * pan_table[voice[v].panning], 27);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
voice[v].panned = PANNED_CENTER;
|
|
voice[v].left_amp = TIM_FSCALENEG(tempamp, 21);
|
|
}
|
|
}
|
|
|
|
#define RESONANCE_COEFF 0.2393
|
|
|
|
void Player::recompute_channel_filter(int ch, int note)
|
|
{
|
|
double coef = 1.0f, reso = 0;
|
|
|
|
if(channel[ch].special_sample > 0) {return;}
|
|
|
|
/* Soft Pedal */
|
|
if(channel[ch].soft_pedal != 0) {
|
|
if(note > 49) { /* tre corde */
|
|
coef *= 1.0 - 0.20 * ((double)channel[ch].soft_pedal) / 127.0f;
|
|
} else { /* una corda (due corde) */
|
|
coef *= 1.0 - 0.25 * ((double)channel[ch].soft_pedal) / 127.0f;
|
|
}
|
|
}
|
|
|
|
if(!ISDRUMCHANNEL(ch)) {
|
|
/* NRPN Filter Cutoff */
|
|
coef *= pow(1.26, (double)(channel[ch].param_cutoff_freq) / 8.0f);
|
|
/* NRPN Resonance */
|
|
reso = (double)channel[ch].param_resonance * RESONANCE_COEFF;
|
|
}
|
|
|
|
channel[ch].cutoff_freq_coef = coef;
|
|
channel[ch].resonance_dB = reso;
|
|
}
|
|
|
|
void Player::init_voice_filter(int i)
|
|
{
|
|
memset(&(voice[i].fc), 0, sizeof(FilterCoefficients));
|
|
if(timidity_lpf_def && voice[i].sample->cutoff_freq) {
|
|
voice[i].fc.orig_freq = voice[i].sample->cutoff_freq;
|
|
voice[i].fc.orig_reso_dB = (double)voice[i].sample->resonance / 10.0f - 3.01f;
|
|
if (voice[i].fc.orig_reso_dB < 0.0f) {voice[i].fc.orig_reso_dB = 0.0f;}
|
|
if (timidity_lpf_def == 2) {
|
|
voice[i].fc.gain = 1.0;
|
|
voice[i].fc.type = 2;
|
|
} else if(timidity_lpf_def == 1) {
|
|
voice[i].fc.gain = pow(10.0f, -voice[i].fc.orig_reso_dB / 2.0f / 20.0f);
|
|
voice[i].fc.type = 1;
|
|
}
|
|
voice[i].fc.start_flag = 0;
|
|
} else {
|
|
voice[i].fc.type = 0;
|
|
}
|
|
}
|
|
|
|
#define CHAMBERLIN_RESONANCE_MAX 24.0
|
|
|
|
void Player::recompute_voice_filter(int v)
|
|
{
|
|
int ch = voice[v].channel, note = voice[v].note;
|
|
double coef = 1.0, reso = 0, cent = 0, depth_cent = 0, freq;
|
|
FilterCoefficients *fc = &(voice[v].fc);
|
|
Sample *sp = (Sample *) &voice[v].sample;
|
|
|
|
if(fc->type == 0) {return;}
|
|
coef = channel[ch].cutoff_freq_coef;
|
|
|
|
if(ISDRUMCHANNEL(ch) && channel[ch].drums[note] != NULL) {
|
|
/* NRPN Drum Instrument Filter Cutoff */
|
|
coef *= pow(1.26, (double)(channel[ch].drums[note]->drum_cutoff_freq) / 8.0f);
|
|
/* NRPN Drum Instrument Filter Resonance */
|
|
reso += (double)channel[ch].drums[note]->drum_resonance * RESONANCE_COEFF;
|
|
}
|
|
|
|
/* MIDI controllers filter cutoff control and LFO filter depth */
|
|
if(timidity_channel_pressure) {
|
|
cent += get_midi_controller_filter_cutoff(&(channel[ch].mod))
|
|
+ get_midi_controller_filter_cutoff(&(channel[ch].bend))
|
|
+ get_midi_controller_filter_cutoff(&(channel[ch].caf))
|
|
+ get_midi_controller_filter_cutoff(&(channel[ch].paf))
|
|
+ get_midi_controller_filter_cutoff(&(channel[ch].cc1))
|
|
+ get_midi_controller_filter_cutoff(&(channel[ch].cc2));
|
|
depth_cent += get_midi_controller_filter_depth(&(channel[ch].mod))
|
|
+ get_midi_controller_filter_depth(&(channel[ch].bend))
|
|
+ get_midi_controller_filter_depth(&(channel[ch].caf))
|
|
+ get_midi_controller_filter_depth(&(channel[ch].paf))
|
|
+ get_midi_controller_filter_depth(&(channel[ch].cc1))
|
|
+ get_midi_controller_filter_depth(&(channel[ch].cc2));
|
|
}
|
|
|
|
if(sp->vel_to_fc) { /* velocity to filter cutoff frequency */
|
|
if(voice[v].velocity > sp->vel_to_fc_threshold)
|
|
cent += sp->vel_to_fc * (double)(127 - voice[v].velocity) / 127.0f;
|
|
else
|
|
coef += sp->vel_to_fc * (double)(127 - sp->vel_to_fc_threshold) / 127.0f;
|
|
}
|
|
if(sp->vel_to_resonance) { /* velocity to filter resonance */
|
|
reso += (double)voice[v].velocity * sp->vel_to_resonance / 127.0f / 10.0f;
|
|
}
|
|
if(sp->key_to_fc) { /* filter cutoff key-follow */
|
|
cent += sp->key_to_fc * (double)(voice[v].note - sp->key_to_fc_bpo);
|
|
}
|
|
|
|
if(timidity_modulation_envelope) {
|
|
if(voice[v].sample->tremolo_to_fc + (int16_t)depth_cent) {
|
|
cent += ((double)voice[v].sample->tremolo_to_fc + depth_cent) * lookup_triangular(voice[v].tremolo_phase >> RATE_SHIFT);
|
|
}
|
|
if(voice[v].sample->modenv_to_fc) {
|
|
cent += (double)voice[v].sample->modenv_to_fc * voice[v].last_modenv_volume;
|
|
}
|
|
}
|
|
|
|
if(cent != 0) {coef *= pow(2.0, cent / 1200.0f);}
|
|
|
|
freq = (double)fc->orig_freq * coef;
|
|
|
|
if (freq > playback_rate / 2) {freq = playback_rate / 2;}
|
|
else if(freq < 5) {freq = 5;}
|
|
fc->freq = (int32_t)freq;
|
|
|
|
fc->reso_dB = fc->orig_reso_dB + channel[ch].resonance_dB + reso;
|
|
if(fc->reso_dB < 0.0f) {fc->reso_dB = 0.0f;}
|
|
else if(fc->reso_dB > 96.0f) {fc->reso_dB = 96.0f;}
|
|
|
|
if(fc->type == 1) { /* Chamberlin filter */
|
|
if(fc->freq > playback_rate / 6) {
|
|
if (fc->start_flag == 0) {fc->type = 0;} /* turn off. */
|
|
else {fc->freq = playback_rate / 6;}
|
|
}
|
|
if(fc->reso_dB > CHAMBERLIN_RESONANCE_MAX) {fc->reso_dB = CHAMBERLIN_RESONANCE_MAX;}
|
|
} else if(fc->type == 2) { /* Moog VCF */
|
|
if(fc->reso_dB > fc->orig_reso_dB / 2) {
|
|
fc->gain = pow(10.0f, (fc->reso_dB - fc->orig_reso_dB / 2) / 20.0f);
|
|
}
|
|
}
|
|
fc->start_flag = 1; /* filter is started. */
|
|
}
|
|
|
|
float Player::calc_drum_tva_level(int ch, int note, int level)
|
|
{
|
|
int def_level, nbank, nprog;
|
|
const ToneBank *bank;
|
|
|
|
if(channel[ch].special_sample > 0) {return 1.0;}
|
|
|
|
nbank = channel[ch].bank;
|
|
nprog = note;
|
|
instruments->instrument_map(channel[ch].mapID, &nbank, &nprog);
|
|
|
|
if(ISDRUMCHANNEL(ch)) {
|
|
bank = instruments->drumSet(nbank);
|
|
if(bank == NULL) {bank = instruments->drumSet(0);}
|
|
} else {
|
|
return 1.0;
|
|
}
|
|
|
|
def_level = bank->tone[nprog].tva_level;
|
|
|
|
if(def_level == -1 || def_level == 0) {def_level = 127;}
|
|
else if(def_level > 127) {def_level = 127;}
|
|
|
|
return (sc_drum_level_table[level] / sc_drum_level_table[def_level]);
|
|
}
|
|
|
|
int32_t Player::calc_random_delay(int ch, int note)
|
|
{
|
|
int nbank, nprog;
|
|
const ToneBank *bank;
|
|
|
|
if(channel[ch].special_sample > 0) {return 0;}
|
|
|
|
nbank = channel[ch].bank;
|
|
|
|
if(ISDRUMCHANNEL(ch)) {
|
|
nprog = note;
|
|
instruments->instrument_map(channel[ch].mapID, &nbank, &nprog);
|
|
bank = instruments->drumSet(nbank);
|
|
if (bank == NULL) {bank = instruments->drumSet(0);}
|
|
} else {
|
|
nprog = channel[ch].program;
|
|
if(nprog == SPECIAL_PROGRAM) {return 0;}
|
|
instruments->instrument_map(channel[ch].mapID, &nbank, &nprog);
|
|
bank = instruments->toneBank(nbank);
|
|
if(bank == NULL) {bank = instruments->toneBank(0);}
|
|
}
|
|
|
|
if (bank->tone[nprog].rnddelay == 0) {return 0;}
|
|
else {return (int32_t)((double)bank->tone[nprog].rnddelay * playback_rate / 1000.0
|
|
* (reverb->get_pink_noise_light(&reverb->global_pink_noise_light) + 1.0f) * 0.5);}
|
|
}
|
|
|
|
void Player::recompute_bank_parameter(int ch, int note)
|
|
{
|
|
int nbank, nprog;
|
|
const ToneBank *bank;
|
|
struct DrumParts *drum;
|
|
|
|
if(channel[ch].special_sample > 0) {return;}
|
|
|
|
nbank = channel[ch].bank;
|
|
|
|
if(ISDRUMCHANNEL(ch)) {
|
|
nprog = note;
|
|
instruments->instrument_map(channel[ch].mapID, &nbank, &nprog);
|
|
bank = instruments->drumSet(nbank);
|
|
if (bank == NULL) {bank = instruments->drumSet(0);}
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
drum = channel[ch].drums[note];
|
|
if (drum->reverb_level == -1 && bank->tone[nprog].reverb_send != -1) {
|
|
drum->reverb_level = bank->tone[nprog].reverb_send;
|
|
}
|
|
if (drum->chorus_level == -1 && bank->tone[nprog].chorus_send != -1) {
|
|
drum->chorus_level = bank->tone[nprog].chorus_send;
|
|
}
|
|
if (drum->delay_level == -1 && bank->tone[nprog].delay_send != -1) {
|
|
drum->delay_level = bank->tone[nprog].delay_send;
|
|
}
|
|
} else {
|
|
nprog = channel[ch].program;
|
|
if (nprog == SPECIAL_PROGRAM) {return;}
|
|
instruments->instrument_map(channel[ch].mapID, &nbank, &nprog);
|
|
bank = instruments->toneBank(nbank);
|
|
if (bank == NULL) {bank = instruments->toneBank(0);}
|
|
channel[ch].legato = bank->tone[nprog].legato;
|
|
channel[ch].damper_mode = bank->tone[nprog].damper_mode;
|
|
channel[ch].loop_timeout = bank->tone[nprog].loop_timeout;
|
|
}
|
|
}
|
|
|
|
|
|
/* this reduces voices while maintaining sound quality */
|
|
int Player::reduce_voice(void)
|
|
{
|
|
int32_t lv, v;
|
|
int i, j, lowest=-0x7FFFFFFF;
|
|
|
|
i = upper_voices;
|
|
lv = 0x7FFFFFFF;
|
|
|
|
/* Look for the decaying note with the smallest volume */
|
|
/* Protect drum decays. Truncating them early sounds bad, especially on
|
|
snares and cymbals */
|
|
for(j = 0; j < i; j++)
|
|
{
|
|
if(voice[j].status & VOICE_FREE ||
|
|
(voice[j].sample->note_to_use && ISDRUMCHANNEL(voice[j].channel)))
|
|
continue;
|
|
|
|
if(voice[j].status & ~(VOICE_ON | VOICE_DIE | VOICE_SUSTAINED))
|
|
{
|
|
/* find lowest volume */
|
|
v = voice[j].left_mix;
|
|
if(voice[j].panned == PANNED_MYSTERY && voice[j].right_mix > v)
|
|
v = voice[j].right_mix;
|
|
if(v < lv)
|
|
{
|
|
lv = v;
|
|
lowest = j;
|
|
}
|
|
}
|
|
}
|
|
if(lowest != -0x7FFFFFFF)
|
|
{
|
|
/* 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++;
|
|
free_voice(lowest);
|
|
return lowest;
|
|
}
|
|
|
|
/* try to remove VOICE_DIE before VOICE_ON */
|
|
lv = 0x7FFFFFFF;
|
|
lowest = -1;
|
|
for(j = 0; j < i; j++)
|
|
{
|
|
if(voice[j].status & VOICE_FREE)
|
|
continue;
|
|
if(voice[j].status & ~(VOICE_ON | VOICE_SUSTAINED))
|
|
{
|
|
/* continue protecting drum decays */
|
|
if (voice[j].status & ~(VOICE_DIE) &&
|
|
(voice[j].sample->note_to_use && ISDRUMCHANNEL(voice[j].channel)))
|
|
continue;
|
|
/* find lowest volume */
|
|
v = voice[j].left_mix;
|
|
if(voice[j].panned == PANNED_MYSTERY && voice[j].right_mix > v)
|
|
v = voice[j].right_mix;
|
|
if(v < lv)
|
|
{
|
|
lv = v;
|
|
lowest = j;
|
|
}
|
|
}
|
|
}
|
|
if(lowest != -1)
|
|
{
|
|
cut_notes++;
|
|
free_voice(lowest);
|
|
return lowest;
|
|
}
|
|
|
|
/* try to remove VOICE_SUSTAINED before VOICE_ON */
|
|
lv = 0x7FFFFFFF;
|
|
lowest = -0x7FFFFFFF;
|
|
for(j = 0; j < i; j++)
|
|
{
|
|
if(voice[j].status & VOICE_FREE)
|
|
continue;
|
|
if(voice[j].status & VOICE_SUSTAINED)
|
|
{
|
|
/* find lowest volume */
|
|
v = voice[j].left_mix;
|
|
if(voice[j].panned == PANNED_MYSTERY && voice[j].right_mix > v)
|
|
v = voice[j].right_mix;
|
|
if(v < lv)
|
|
{
|
|
lv = v;
|
|
lowest = j;
|
|
}
|
|
}
|
|
}
|
|
if(lowest != -0x7FFFFFFF)
|
|
{
|
|
cut_notes++;
|
|
free_voice(lowest);
|
|
return lowest;
|
|
}
|
|
|
|
/* try to remove chorus before VOICE_ON */
|
|
lv = 0x7FFFFFFF;
|
|
lowest = -0x7FFFFFFF;
|
|
for(j = 0; j < i; j++)
|
|
{
|
|
if(voice[j].status & VOICE_FREE)
|
|
continue;
|
|
if(voice[j].chorus_link < j)
|
|
{
|
|
/* find lowest volume */
|
|
v = voice[j].left_mix;
|
|
if(voice[j].panned == PANNED_MYSTERY && voice[j].right_mix > v)
|
|
v = voice[j].right_mix;
|
|
if(v < lv)
|
|
{
|
|
lv = v;
|
|
lowest = j;
|
|
}
|
|
}
|
|
}
|
|
if(lowest != -0x7FFFFFFF)
|
|
{
|
|
cut_notes++;
|
|
|
|
/* fix pan */
|
|
j = voice[lowest].chorus_link;
|
|
voice[j].panning = channel[voice[lowest].channel].panning;
|
|
recompute_amp(j);
|
|
mixer->apply_envelope_to_amp(j);
|
|
|
|
free_voice(lowest);
|
|
return lowest;
|
|
}
|
|
|
|
lost_notes++;
|
|
|
|
/* remove non-drum VOICE_ON */
|
|
lv = 0x7FFFFFFF;
|
|
lowest = -0x7FFFFFFF;
|
|
for(j = 0; j < i; j++)
|
|
{
|
|
if(voice[j].status & VOICE_FREE ||
|
|
(voice[j].sample->note_to_use && ISDRUMCHANNEL(voice[j].channel)))
|
|
continue;
|
|
|
|
/* find lowest volume */
|
|
v = voice[j].left_mix;
|
|
if(voice[j].panned == PANNED_MYSTERY && voice[j].right_mix > v)
|
|
v = voice[j].right_mix;
|
|
if(v < lv)
|
|
{
|
|
lv = v;
|
|
lowest = j;
|
|
}
|
|
}
|
|
if(lowest != -0x7FFFFFFF)
|
|
{
|
|
free_voice(lowest);
|
|
return lowest;
|
|
}
|
|
|
|
/* remove all other types of notes */
|
|
lv = 0x7FFFFFFF;
|
|
lowest = 0;
|
|
for(j = 0; j < i; j++)
|
|
{
|
|
if(voice[j].status & VOICE_FREE)
|
|
continue;
|
|
/* find lowest volume */
|
|
v = voice[j].left_mix;
|
|
if(voice[j].panned == PANNED_MYSTERY && voice[j].right_mix > v)
|
|
v = voice[j].right_mix;
|
|
if(v < lv)
|
|
{
|
|
lv = v;
|
|
lowest = j;
|
|
}
|
|
}
|
|
|
|
free_voice(lowest);
|
|
return lowest;
|
|
}
|
|
|
|
void Player::free_voice(int v1)
|
|
{
|
|
int v2;
|
|
|
|
#ifdef ENABLE_PAN_DELAY
|
|
if (voice[v1].pan_delay_buf != NULL) {
|
|
free(voice[v1].pan_delay_buf);
|
|
voice[v1].pan_delay_buf = NULL;
|
|
}
|
|
#endif /* ENABLE_PAN_DELAY */
|
|
|
|
v2 = voice[v1].chorus_link;
|
|
if(v1 != v2)
|
|
{
|
|
/* Unlink chorus link */
|
|
voice[v1].chorus_link = v1;
|
|
voice[v2].chorus_link = v2;
|
|
}
|
|
voice[v1].status = VOICE_FREE;
|
|
voice[v1].temper_instant = 0;
|
|
}
|
|
|
|
int Player::find_free_voice(void)
|
|
{
|
|
int i, nv = voices, lowest;
|
|
int32_t lv, v;
|
|
|
|
for(i = 0; i < nv; i++)
|
|
if(voice[i].status == VOICE_FREE)
|
|
{
|
|
if(upper_voices <= i)
|
|
upper_voices = i + 1;
|
|
return i;
|
|
}
|
|
|
|
upper_voices = voices;
|
|
|
|
/* Look for the decaying note with the lowest volume */
|
|
lv = 0x7FFFFFFF;
|
|
lowest = -1;
|
|
for(i = 0; i < nv; i++)
|
|
{
|
|
if(voice[i].status & ~(VOICE_ON | VOICE_DIE) &&
|
|
!(voice[i].sample && voice[i].sample->note_to_use && ISDRUMCHANNEL(voice[i].channel)))
|
|
{
|
|
v = voice[i].left_mix;
|
|
if((voice[i].panned==PANNED_MYSTERY) && (voice[i].right_mix>v))
|
|
v = voice[i].right_mix;
|
|
if(v<lv)
|
|
{
|
|
lv = v;
|
|
lowest = i;
|
|
}
|
|
}
|
|
}
|
|
return lowest;
|
|
}
|
|
|
|
int Player::find_samples(MidiEvent *e, int *vlist)
|
|
{
|
|
int i, j, ch, bank, prog, note, nv;
|
|
const SpecialPatch *s;
|
|
Instrument *ip;
|
|
|
|
ch = e->channel;
|
|
if (channel[ch].special_sample > 0) {
|
|
if ((s = instruments->specialPatch(channel[ch].special_sample)) == NULL) {
|
|
return 0;
|
|
}
|
|
note = e->a + channel[ch].key_shift + note_key_offset;
|
|
note = (note < 0) ? 0 : ((note > 127) ? 127 : note);
|
|
return select_play_sample(s->sample, s->samples, ¬e, vlist, e);
|
|
}
|
|
bank = channel[ch].bank;
|
|
if (ISDRUMCHANNEL(ch)) {
|
|
note = e->a & 0x7f;
|
|
instruments->instrument_map(channel[ch].mapID, &bank, ¬e);
|
|
if (! (ip = play_midi_load_instrument(1, bank, note)))
|
|
return 0; /* No instrument? Then we can't play. */
|
|
|
|
/* "keynum" of SF2, and patch option "note=" */
|
|
if (ip->sample->note_to_use)
|
|
note = ip->sample->note_to_use;
|
|
} else {
|
|
if ((prog = channel[ch].program) == SPECIAL_PROGRAM)
|
|
ip = instruments->defaultInstrument();
|
|
else {
|
|
instruments->instrument_map(channel[ch].mapID, &bank, &prog);
|
|
if (! (ip = play_midi_load_instrument(0, bank, prog)))
|
|
return 0; /* No instrument? Then we can't play. */
|
|
}
|
|
note = ((ip->sample->note_to_use) ? ip->sample->note_to_use : e->a)
|
|
+ channel[ch].key_shift + note_key_offset;
|
|
note = (note < 0) ? 0 : ((note > 127) ? 127 : note);
|
|
}
|
|
nv = select_play_sample(ip->sample, ip->samples, ¬e, vlist, e);
|
|
/* Replace the sample if the sample is cached. */
|
|
if (ip->sample->note_to_use)
|
|
note = MIDI_EVENT_NOTE(e);
|
|
for (i = 0; i < nv; i++) {
|
|
j = vlist[i];
|
|
if (! opt_realtime_playing && allocate_cache_size > 0
|
|
&& ! channel[ch].portamento) {
|
|
voice[j].cache = recache->resamp_cache_fetch(voice[j].sample, note);
|
|
if (voice[j].cache) /* cache hit */
|
|
voice[j].sample = voice[j].cache->resampled;
|
|
} else
|
|
voice[j].cache = NULL;
|
|
}
|
|
return nv;
|
|
}
|
|
|
|
int Player::select_play_sample(Sample *splist, int nsp, int *note, int *vlist, MidiEvent *e)
|
|
{
|
|
int ch = e->channel, kn = e->a & 0x7f, vel = e->b;
|
|
int32_t f, fs, ft, fst, fc, fr, cdiff, diff, sample_link;
|
|
int8_t tt = channel[ch].temper_type;
|
|
uint8_t tp = channel[ch].rpnmap[RPN_ADDR_0003];
|
|
Sample *sp, *spc, *spr;
|
|
int16_t sf, sn;
|
|
double ratio;
|
|
int i, j, k, nv, nvc;
|
|
|
|
if (ISDRUMCHANNEL(ch))
|
|
f = fs = freq_table[*note];
|
|
else {
|
|
if (opt_pure_intonation) {
|
|
if (current_keysig < 8)
|
|
f = freq_table_pureint[current_freq_table][*note];
|
|
else
|
|
f = freq_table_pureint[current_freq_table + 12][*note];
|
|
} else if (timidity_temper_control)
|
|
switch (tt) {
|
|
case 0:
|
|
f = freq_table_tuning[tp][*note];
|
|
break;
|
|
case 1:
|
|
if (current_temper_keysig < 8)
|
|
f = freq_table_pytha[
|
|
current_temper_freq_table][*note];
|
|
else
|
|
f = freq_table_pytha[
|
|
current_temper_freq_table + 12][*note];
|
|
break;
|
|
case 2:
|
|
if (current_temper_keysig < 8)
|
|
f = freq_table_meantone[current_temper_freq_table
|
|
+ ((temper_adj) ? 36 : 0)][*note];
|
|
else
|
|
f = freq_table_meantone[current_temper_freq_table
|
|
+ ((temper_adj) ? 24 : 12)][*note];
|
|
break;
|
|
case 3:
|
|
if (current_temper_keysig < 8)
|
|
f = freq_table_pureint[current_temper_freq_table
|
|
+ ((temper_adj) ? 36 : 0)][*note];
|
|
else
|
|
f = freq_table_pureint[current_temper_freq_table
|
|
+ ((temper_adj) ? 24 : 12)][*note];
|
|
break;
|
|
default: /* user-defined temperament */
|
|
if ((tt -= 0x40) >= 0 && tt < 4) {
|
|
if (current_temper_keysig < 8)
|
|
f = freq_table_user[tt][current_temper_freq_table
|
|
+ ((temper_adj) ? 36 : 0)][*note];
|
|
else
|
|
f = freq_table_user[tt][current_temper_freq_table
|
|
+ ((temper_adj) ? 24 : 12)][*note];
|
|
} else
|
|
f = freq_table[*note];
|
|
break;
|
|
}
|
|
else
|
|
f = freq_table[*note];
|
|
if (! opt_pure_intonation && timidity_temper_control
|
|
&& tt == 0 && f != freq_table[*note]) {
|
|
*note = log(f / 440000.0) / log(2) * 12 + 69.5;
|
|
*note = (*note < 0) ? 0 : ((*note > 127) ? 127 : *note);
|
|
fs = freq_table[*note];
|
|
} else
|
|
fs = freq_table[*note];
|
|
}
|
|
nv = 0;
|
|
for (i = 0, sp = splist; i < nsp; i++, sp++) {
|
|
/* GUS/SF2 - Scale Tuning */
|
|
if ((sf = sp->scale_factor) != 1024) {
|
|
sn = sp->scale_freq;
|
|
ratio = pow(2.0, (*note - sn) * (sf - 1024) / 12288.0);
|
|
ft = f * ratio + 0.5, fst = fs * ratio + 0.5;
|
|
} else
|
|
ft = f, fst = fs;
|
|
if (ISDRUMCHANNEL(ch) && channel[ch].drums[kn] != NULL)
|
|
if ((ratio = get_play_note_ratio(ch, kn)) != 1.0)
|
|
ft = ft * ratio + 0.5, fst = fst * ratio + 0.5;
|
|
if (sp->low_freq <= fst && sp->high_freq >= fst
|
|
&& sp->low_vel <= vel && sp->high_vel >= vel
|
|
&& ! (sp->inst_type == INST_SF2
|
|
&& sp->sample_type == SF_SAMPLETYPE_RIGHT)) {
|
|
j = vlist[nv] = find_voice(e);
|
|
voice[j].orig_frequency = ft;
|
|
voice[j].sample = sp;
|
|
voice[j].status = VOICE_ON;
|
|
nv++;
|
|
}
|
|
}
|
|
if (nv == 0) { /* we must select at least one sample. */
|
|
fr = fc = 0;
|
|
spc = spr = NULL;
|
|
cdiff = 0x7fffffff;
|
|
for (i = 0, sp = splist; i < nsp; i++, sp++) {
|
|
/* GUS/SF2 - Scale Tuning */
|
|
if ((sf = sp->scale_factor) != 1024) {
|
|
sn = sp->scale_freq;
|
|
ratio = pow(2.0, (*note - sn) * (sf - 1024) / 12288.0);
|
|
ft = f * ratio + 0.5, fst = fs * ratio + 0.5;
|
|
} else
|
|
ft = f, fst = fs;
|
|
if (ISDRUMCHANNEL(ch) && channel[ch].drums[kn] != NULL)
|
|
if ((ratio = get_play_note_ratio(ch, kn)) != 1.0)
|
|
ft = ft * ratio + 0.5, fst = fst * ratio + 0.5;
|
|
diff = abs(sp->root_freq - fst);
|
|
if (diff < cdiff) {
|
|
if (sp->inst_type == INST_SF2
|
|
&& sp->sample_type == SF_SAMPLETYPE_RIGHT) {
|
|
fr = ft; /* reserve */
|
|
spr = sp; /* reserve */
|
|
} else {
|
|
fc = ft;
|
|
spc = sp;
|
|
cdiff = diff;
|
|
}
|
|
}
|
|
}
|
|
/* If spc is not NULL, a makeshift sample is found. */
|
|
/* Otherwise, it's a lonely right sample, but better than nothing. */
|
|
j = vlist[nv] = find_voice(e);
|
|
voice[j].orig_frequency = (spc) ? fc : fr;
|
|
voice[j].sample = (spc) ? spc : spr;
|
|
voice[j].status = VOICE_ON;
|
|
nv++;
|
|
}
|
|
nvc = nv;
|
|
for (i = 0; i < nvc; i++) {
|
|
spc = voice[vlist[i]].sample;
|
|
/* If it's left sample, there must be right sample. */
|
|
if (spc->inst_type == INST_SF2
|
|
&& spc->sample_type == SF_SAMPLETYPE_LEFT) {
|
|
sample_link = spc->sf_sample_link;
|
|
for (j = 0, sp = splist; j < nsp; j++, sp++)
|
|
if (sp->inst_type == INST_SF2
|
|
&& sp->sample_type == SF_SAMPLETYPE_RIGHT
|
|
&& sp->sf_sample_index == sample_link) {
|
|
/* right sample is found. */
|
|
/* GUS/SF2 - Scale Tuning */
|
|
if ((sf = sp->scale_factor) != 1024) {
|
|
sn = sp->scale_freq;
|
|
ratio = pow(2.0, (*note - sn) * (sf - 1024) / 12288.0);
|
|
ft = f * ratio + 0.5;
|
|
} else
|
|
ft = f;
|
|
if (ISDRUMCHANNEL(ch) && channel[ch].drums[kn] != NULL)
|
|
if ((ratio = get_play_note_ratio(ch, kn)) != 1.0)
|
|
ft = ft * ratio + 0.5;
|
|
k = vlist[nv] = find_voice(e);
|
|
voice[k].orig_frequency = ft;
|
|
voice[k].sample = sp;
|
|
voice[k].status = VOICE_ON;
|
|
nv++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return nv;
|
|
}
|
|
|
|
double Player::get_play_note_ratio(int ch, int note)
|
|
{
|
|
int play_note = channel[ch].drums[note]->play_note;
|
|
int bank = channel[ch].bank;
|
|
const ToneBank *dbank;
|
|
int def_play_note;
|
|
|
|
if (play_note == -1)
|
|
return 1.0;
|
|
instruments->instrument_map(channel[ch].mapID, &bank, ¬e);
|
|
dbank = (instruments->drumSet(bank)) ? instruments->drumSet(bank) : instruments->drumSet(0);
|
|
if ((def_play_note = dbank->tone[note].play_note) == -1)
|
|
return 1.0;
|
|
if (play_note >= def_play_note)
|
|
return bend_coarse[(play_note - def_play_note) & 0x7f];
|
|
else
|
|
return 1 / bend_coarse[(def_play_note - play_note) & 0x7f];
|
|
}
|
|
|
|
/* Only one instance of a note can be playing on a single channel. */
|
|
int Player::find_voice(MidiEvent *e)
|
|
{
|
|
int ch = e->channel;
|
|
int note = MIDI_EVENT_NOTE(e);
|
|
int status_check, mono_check;
|
|
AlternateAssign *altassign;
|
|
int i, lowest = -1;
|
|
|
|
status_check = (timidity_overlap_voice_allow)
|
|
? (VOICE_OFF | VOICE_SUSTAINED) : 0xff;
|
|
mono_check = channel[ch].mono;
|
|
altassign = instruments->find_altassign(channel[ch].altassign, note);
|
|
for (i = 0; i < upper_voices; i++)
|
|
if (voice[i].status == VOICE_FREE) {
|
|
lowest = i; /* lower volume */
|
|
break;
|
|
}
|
|
for (i = 0; i < upper_voices; i++)
|
|
if (voice[i].status != VOICE_FREE && voice[i].channel == ch) {
|
|
if (voice[i].note == note && (voice[i].status & status_check))
|
|
kill_note(i);
|
|
else if (mono_check)
|
|
kill_note(i);
|
|
else if (altassign && instruments->find_altassign(altassign, voice[i].note))
|
|
kill_note(i);
|
|
else if (voice[i].note == note && (channel[ch].assign_mode == 0
|
|
|| (channel[ch].assign_mode == 1 &&
|
|
voice[i].proximate_flag == 0)))
|
|
kill_note(i);
|
|
}
|
|
for (i = 0; i < upper_voices; i++)
|
|
if (voice[i].channel == ch && voice[i].note == note)
|
|
voice[i].proximate_flag = 0;
|
|
if (lowest != -1) /* Found a free voice. */
|
|
return lowest;
|
|
if (upper_voices < voices)
|
|
return upper_voices++;
|
|
return reduce_voice();
|
|
}
|
|
|
|
int Player::get_panning(int ch, int note,int v)
|
|
{
|
|
int pan;
|
|
|
|
if(channel[ch].panning != NO_PANNING) {pan = (int)channel[ch].panning - 64;}
|
|
else {pan = 0;}
|
|
if(ISDRUMCHANNEL(ch) &&
|
|
channel[ch].drums[note] != NULL &&
|
|
channel[ch].drums[note]->drum_panning != NO_PANNING) {
|
|
pan += channel[ch].drums[note]->drum_panning;
|
|
} else {
|
|
pan += voice[v].sample->panning;
|
|
}
|
|
|
|
if (pan > 127) pan = 127;
|
|
else if (pan < 0) pan = 0;
|
|
|
|
return pan;
|
|
}
|
|
|
|
/*! initialize vibrato parameters for a voice. */
|
|
void Player::init_voice_vibrato(int v)
|
|
{
|
|
Voice *vp = &(voice[v]);
|
|
int ch = vp->channel, j, nrpn_vib_flag;
|
|
double ratio;
|
|
|
|
/* if NRPN vibrato is set, it's believed that there must be vibrato. */
|
|
nrpn_vib_flag = op_nrpn_vibrato
|
|
&& (channel[ch].vibrato_ratio != 1.0 || channel[ch].vibrato_depth != 0);
|
|
|
|
/* vibrato sweep */
|
|
vp->vibrato_sweep = vp->sample->vibrato_sweep_increment;
|
|
vp->vibrato_sweep_position = 0;
|
|
|
|
/* vibrato rate */
|
|
if (nrpn_vib_flag) {
|
|
if(vp->sample->vibrato_control_ratio == 0) {
|
|
ratio = cnv_Hz_to_vib_ratio(5.0) * channel[ch].vibrato_ratio;
|
|
} else {
|
|
ratio = (double)vp->sample->vibrato_control_ratio * channel[ch].vibrato_ratio;
|
|
}
|
|
if (ratio < 0) {ratio = 0;}
|
|
vp->vibrato_control_ratio = (int)ratio;
|
|
} else {
|
|
vp->vibrato_control_ratio = vp->sample->vibrato_control_ratio;
|
|
}
|
|
|
|
/* vibrato depth */
|
|
if (nrpn_vib_flag) {
|
|
vp->vibrato_depth = vp->sample->vibrato_depth + channel[ch].vibrato_depth;
|
|
if (vp->vibrato_depth > VIBRATO_DEPTH_MAX) {vp->vibrato_depth = VIBRATO_DEPTH_MAX;}
|
|
else if (vp->vibrato_depth < 1) {vp->vibrato_depth = 1;}
|
|
if (vp->sample->vibrato_depth < 0) { /* in opposite phase */
|
|
vp->vibrato_depth = -vp->vibrato_depth;
|
|
}
|
|
} else {
|
|
vp->vibrato_depth = vp->sample->vibrato_depth;
|
|
}
|
|
|
|
/* vibrato delay */
|
|
vp->vibrato_delay = vp->sample->vibrato_delay + channel[ch].vibrato_delay;
|
|
|
|
/* internal parameters */
|
|
vp->orig_vibrato_control_ratio = vp->vibrato_control_ratio;
|
|
vp->vibrato_control_counter = vp->vibrato_phase = 0;
|
|
for (j = 0; j < VIBRATO_SAMPLE_INCREMENTS; j++) {
|
|
vp->vibrato_sample_increment[j] = 0;
|
|
}
|
|
}
|
|
|
|
/*! initialize panning-delay for a voice. */
|
|
void Player::init_voice_pan_delay(int v)
|
|
{
|
|
#ifdef ENABLE_PAN_DELAY
|
|
Voice *vp = &(voice[v]);
|
|
int ch = vp->channel;
|
|
double pan_delay_diff;
|
|
|
|
if (vp->pan_delay_buf != NULL) {
|
|
free(vp->pan_delay_buf);
|
|
vp->pan_delay_buf = NULL;
|
|
}
|
|
vp->pan_delay_rpt = 0;
|
|
if (timidity_pan_delay && channel[ch].insertion_effect == 0 && !timidity_surround_chorus) {
|
|
if (vp->panning == 64) {vp->delay += pan_delay_table[64] * playback_rate / 1000;}
|
|
else {
|
|
if(pan_delay_table[vp->panning] > pan_delay_table[127 - vp->panning]) {
|
|
pan_delay_diff = pan_delay_table[vp->panning] - pan_delay_table[127 - vp->panning];
|
|
vp->delay += (pan_delay_table[vp->panning] - pan_delay_diff) * playback_rate / 1000;
|
|
} else {
|
|
pan_delay_diff = pan_delay_table[127 - vp->panning] - pan_delay_table[vp->panning];
|
|
vp->delay += (pan_delay_table[127 - vp->panning] - pan_delay_diff) * playback_rate / 1000;
|
|
}
|
|
vp->pan_delay_rpt = pan_delay_diff * playback_rate / 1000;
|
|
}
|
|
if(vp->pan_delay_rpt < 1) {vp->pan_delay_rpt = 0;}
|
|
vp->pan_delay_wpt = 0;
|
|
vp->pan_delay_spt = vp->pan_delay_wpt - vp->pan_delay_rpt;
|
|
if (vp->pan_delay_spt < 0) {vp->pan_delay_spt += PAN_DELAY_BUF_MAX;}
|
|
vp->pan_delay_buf = (int32_t *)safe_malloc(sizeof(int32_t) * PAN_DELAY_BUF_MAX);
|
|
memset(vp->pan_delay_buf, 0, sizeof(int32_t) * PAN_DELAY_BUF_MAX);
|
|
}
|
|
#endif /* ENABLE_PAN_DELAY */
|
|
}
|
|
|
|
/*! initialize portamento or legato for a voice. */
|
|
void Player::init_voice_portamento(int v)
|
|
{
|
|
Voice *vp = &(voice[v]);
|
|
int ch = vp->channel;
|
|
|
|
vp->porta_control_counter = 0;
|
|
if (channel[ch].legato && channel[ch].legato_flag) {
|
|
update_legato_controls(ch);
|
|
}
|
|
else if (channel[ch].portamento && !channel[ch].porta_control_ratio) {
|
|
update_portamento_controls(ch);
|
|
}
|
|
vp->porta_control_ratio = 0;
|
|
if (channel[ch].porta_control_ratio)
|
|
{
|
|
if (channel[ch].last_note_fine == -1) {
|
|
/* first on */
|
|
channel[ch].last_note_fine = vp->note * 256;
|
|
channel[ch].porta_control_ratio = 0;
|
|
}
|
|
else {
|
|
vp->porta_control_ratio = channel[ch].porta_control_ratio;
|
|
vp->porta_dpb = channel[ch].porta_dpb;
|
|
vp->porta_pb = channel[ch].last_note_fine -
|
|
vp->note * 256;
|
|
if (vp->porta_pb == 0) { vp->porta_control_ratio = 0; }
|
|
}
|
|
}
|
|
}
|
|
|
|
/*! initialize tremolo for a voice. */
|
|
void Player::init_voice_tremolo(int v)
|
|
{
|
|
Voice *vp = &(voice[v]);
|
|
|
|
vp->tremolo_delay = vp->sample->tremolo_delay;
|
|
vp->tremolo_phase = 0;
|
|
vp->tremolo_phase_increment = vp->sample->tremolo_phase_increment;
|
|
vp->tremolo_sweep = vp->sample->tremolo_sweep_increment;
|
|
vp->tremolo_sweep_position = 0;
|
|
vp->tremolo_depth = vp->sample->tremolo_depth;
|
|
}
|
|
|
|
void Player::start_note(MidiEvent *e, int i, int vid, int cnt)
|
|
{
|
|
int j, ch, note;
|
|
|
|
ch = e->channel;
|
|
|
|
note = MIDI_EVENT_NOTE(e);
|
|
voice[i].status = VOICE_ON;
|
|
voice[i].channel = ch;
|
|
voice[i].note = note;
|
|
voice[i].velocity = e->b;
|
|
voice[i].chorus_link = i; /* No link */
|
|
voice[i].proximate_flag = 1;
|
|
|
|
j = channel[ch].special_sample;
|
|
if (j == 0 || instruments->specialPatch(j) == NULL)
|
|
voice[i].sample_offset = 0;
|
|
else
|
|
{
|
|
voice[i].sample_offset = instruments->specialPatch(j)->sample_offset << FRACTION_BITS;
|
|
if (voice[i].sample->modes & MODES_LOOPING)
|
|
{
|
|
if (voice[i].sample_offset > voice[i].sample->loop_end)
|
|
voice[i].sample_offset = voice[i].sample->loop_start;
|
|
}
|
|
else if (voice[i].sample_offset > voice[i].sample->data_length)
|
|
{
|
|
free_voice(i);
|
|
return;
|
|
}
|
|
}
|
|
voice[i].sample_increment = 0; /* make sure it isn't negative */
|
|
voice[i].vid = vid;
|
|
voice[i].delay = voice[i].sample->envelope_delay;
|
|
voice[i].modenv_delay = voice[i].sample->modenv_delay;
|
|
voice[i].delay_counter = 0;
|
|
|
|
init_voice_tremolo(i); /* tremolo */
|
|
init_voice_filter(i); /* resonant lowpass filter */
|
|
init_voice_vibrato(i); /* vibrato */
|
|
voice[i].panning = get_panning(ch, note, i); /* pan */
|
|
init_voice_pan_delay(i); /* panning-delay */
|
|
init_voice_portamento(i); /* portamento or legato */
|
|
|
|
if (cnt == 0)
|
|
channel[ch].last_note_fine = voice[i].note * 256;
|
|
|
|
/* initialize modulation envelope */
|
|
if (voice[i].sample->modes & MODES_ENVELOPE)
|
|
{
|
|
voice[i].modenv_stage = EG_GUS_ATTACK;
|
|
voice[i].modenv_volume = 0;
|
|
mixer->recompute_modulation_envelope(i);
|
|
mixer->apply_modulation_envelope(i);
|
|
}
|
|
else
|
|
{
|
|
voice[i].modenv_increment = 0;
|
|
mixer->apply_modulation_envelope(i);
|
|
}
|
|
recompute_freq(i);
|
|
recompute_voice_filter(i);
|
|
|
|
recompute_amp(i);
|
|
/* initialize volume envelope */
|
|
if (voice[i].sample->modes & MODES_ENVELOPE)
|
|
{
|
|
/* Ramp up from 0 */
|
|
voice[i].envelope_stage = EG_GUS_ATTACK;
|
|
voice[i].envelope_volume = 0;
|
|
voice[i].control_counter = 0;
|
|
mixer->recompute_envelope(i);
|
|
mixer->apply_envelope_to_amp(i);
|
|
}
|
|
else
|
|
{
|
|
voice[i].envelope_increment = 0;
|
|
mixer->apply_envelope_to_amp(i);
|
|
}
|
|
|
|
voice[i].timeout = -1;
|
|
}
|
|
|
|
void Player::finish_note(int i)
|
|
{
|
|
if (voice[i].sample->modes & MODES_ENVELOPE)
|
|
{
|
|
/* We need to get the envelope out of Sustain stage. */
|
|
/* Note that voice[i].envelope_stage < EG_GUS_RELEASE1 */
|
|
voice[i].status = VOICE_OFF;
|
|
voice[i].envelope_stage = EG_GUS_RELEASE1;
|
|
mixer->recompute_envelope(i);
|
|
voice[i].modenv_stage = EG_GUS_RELEASE1;
|
|
mixer->recompute_modulation_envelope(i);
|
|
mixer->apply_modulation_envelope(i);
|
|
mixer->apply_envelope_to_amp(i);
|
|
}
|
|
else
|
|
{
|
|
/* Set status to OFF so resample_voice() will let this voice out
|
|
of its loop, if any. In any case, this voice dies when it
|
|
hits the end of its data (ofs>=data_length). */
|
|
if(voice[i].status != VOICE_OFF)
|
|
{
|
|
voice[i].status = VOICE_OFF;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Player::set_envelope_time(int ch, int val, int stage)
|
|
{
|
|
val = val & 0x7F;
|
|
#if 0
|
|
switch(stage) {
|
|
case EG_ATTACK: /* Attack */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Attack Time (CH:%d VALUE:%d)", ch, val);
|
|
break;
|
|
case EG_DECAY: /* Decay */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Decay Time (CH:%d VALUE:%d)", ch, val);
|
|
break;
|
|
case EG_RELEASE: /* Release */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Release Time (CH:%d VALUE:%d)", ch, val);
|
|
break;
|
|
default:
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"? Time (CH:%d VALUE:%d)", ch, val);
|
|
}
|
|
#endif
|
|
channel[ch].envelope_rate[stage] = val;
|
|
}
|
|
|
|
|
|
|
|
/* Yet another chorus implementation
|
|
* by Eric A. Welsh <ewelsh@gpc.wustl.edu>.
|
|
*/
|
|
void Player::new_chorus_voice_alternate(int v1, int level)
|
|
{
|
|
int v2, ch, panlevel;
|
|
uint8_t pan;
|
|
double delay;
|
|
double freq, frac;
|
|
int note_adjusted;
|
|
|
|
if((v2 = find_free_voice()) == -1)
|
|
return;
|
|
ch = voice[v1].channel;
|
|
voice[v2] = voice[v1];
|
|
|
|
/* NRPN Chorus Send Level of Drum */
|
|
if(ISDRUMCHANNEL(ch) && channel[ch].drums[voice[v1].note] != NULL) {
|
|
level *= (double)channel[ch].drums[voice[v1].note]->chorus_level / 127.0;
|
|
}
|
|
|
|
/* for our purposes, hard left will be equal to 1 instead of 0 */
|
|
pan = voice[v1].panning;
|
|
if (!pan) pan = 1;
|
|
|
|
/* Choose lower voice index for base voice (v1) */
|
|
if(v1 > v2)
|
|
{
|
|
v1 ^= v2;
|
|
v2 ^= v1;
|
|
v1 ^= v2;
|
|
}
|
|
|
|
/* Make doubled link v1 and v2 */
|
|
voice[v1].chorus_link = v2;
|
|
voice[v2].chorus_link = v1;
|
|
|
|
/* detune notes for chorus effect */
|
|
level >>= 2; /* scale to a "better" value */
|
|
if (level)
|
|
{
|
|
if(channel[ch].pitchbend + level < 0x2000)
|
|
voice[v2].orig_frequency *= bend_fine[level];
|
|
else
|
|
voice[v2].orig_frequency /= bend_fine[level];
|
|
voice[v2].cache = NULL;
|
|
}
|
|
|
|
delay = 0.003;
|
|
|
|
/* Try to keep the delayed voice from cancelling out the other voice */
|
|
/* Pitch detection is used to find the real pitches for drums and MODs */
|
|
note_adjusted = voice[v1].note + voice[v1].sample->transpose_detected;
|
|
if (note_adjusted > 127) note_adjusted = 127;
|
|
else if (note_adjusted < 0) note_adjusted = 0;
|
|
freq = pitch_freq_table[note_adjusted];
|
|
delay *= freq;
|
|
frac = delay - floor(delay);
|
|
|
|
/* force the delay away from 0.5 period */
|
|
if (frac < 0.5 && frac > 0.40)
|
|
{
|
|
delay = (floor(delay) + 0.40) / freq;
|
|
delay += (0.5 - frac) * (1.0 - labs(64 - pan) / 63.0) / freq;
|
|
}
|
|
else if (frac >= 0.5 && frac < 0.60)
|
|
{
|
|
delay = (floor(delay) + 0.60) / freq;
|
|
delay += (0.5 - frac) * (1.0 - labs(64 - pan) / 63.0) / freq;
|
|
}
|
|
else
|
|
delay = 0.003;
|
|
|
|
/* set panning & delay for pseudo-surround effect */
|
|
{
|
|
panlevel = 63;
|
|
if (pan - panlevel < 1) panlevel = pan - 1;
|
|
if (pan + panlevel > 127) panlevel = 127 - pan;
|
|
voice[v1].panning -= panlevel;
|
|
voice[v2].panning += panlevel;
|
|
|
|
/* choose which voice is delayed based on panning */
|
|
if (voice[v1].panned == PANNED_CENTER) {
|
|
/* randomly choose which voice is delayed */
|
|
if (int_rand(2))
|
|
voice[v1].delay += (int)(playback_rate * delay);
|
|
else
|
|
voice[v2].delay += (int)(playback_rate * delay);
|
|
}
|
|
else if (pan - 64 < 0) {
|
|
voice[v2].delay += (int)(playback_rate * delay);
|
|
}
|
|
else {
|
|
voice[v1].delay += (int)(playback_rate * delay);
|
|
}
|
|
}
|
|
|
|
/* check for similar drums playing simultaneously with center pans */
|
|
if (ISDRUMCHANNEL(ch) && voice[v1].panned == PANNED_CENTER)
|
|
{
|
|
int i, j;
|
|
|
|
/* force Rimshot (37), Snare1 (38), Snare2 (40), and XG #34 to have
|
|
* the same delay, otherwise there will be bad voice cancellation.
|
|
*/
|
|
if (voice[v1].note == 37 ||
|
|
voice[v1].note == 38 ||
|
|
voice[v1].note == 40 ||
|
|
(voice[v1].note == 34 && play_system_mode == XG_SYSTEM_MODE))
|
|
{
|
|
for (i = 0; i < upper_voices; i++)
|
|
{
|
|
if (voice[i].status & (VOICE_DIE | VOICE_FREE))
|
|
continue;
|
|
|
|
if (!ISDRUMCHANNEL(voice[i].channel))
|
|
continue;
|
|
|
|
if (i == v1 || i == v2)
|
|
continue;
|
|
|
|
if (voice[i].note == 37 ||
|
|
voice[i].note == 38 ||
|
|
voice[i].note == 40 ||
|
|
(voice[i].note == 34 &&
|
|
play_system_mode == XG_SYSTEM_MODE))
|
|
{
|
|
j = voice[i].chorus_link;
|
|
|
|
if (voice[i].panned == PANNED_LEFT &&
|
|
voice[j].panned == PANNED_RIGHT)
|
|
{
|
|
voice[v1].delay = voice[i].delay;
|
|
voice[v2].delay = voice[j].delay;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* force Kick1 (35), Kick2 (36), and XG Kick #33 to have the same
|
|
* delay, otherwise there will be bad voice cancellation.
|
|
*/
|
|
if (voice[v1].note == 35 ||
|
|
voice[v1].note == 36 ||
|
|
(voice[v1].note == 33 && play_system_mode == XG_SYSTEM_MODE))
|
|
{
|
|
for (i = 0; i < upper_voices; i++)
|
|
{
|
|
if (voice[i].status & (VOICE_DIE | VOICE_FREE))
|
|
continue;
|
|
|
|
if (!ISDRUMCHANNEL(voice[i].channel))
|
|
continue;
|
|
|
|
if (i == v1 || i == v2)
|
|
continue;
|
|
|
|
if (voice[i].note == 35 ||
|
|
voice[i].note == 36 ||
|
|
(voice[i].note == 33 &&
|
|
play_system_mode == XG_SYSTEM_MODE))
|
|
{
|
|
j = voice[i].chorus_link;
|
|
|
|
if (voice[i].panned == PANNED_LEFT &&
|
|
voice[j].panned == PANNED_RIGHT)
|
|
{
|
|
voice[v1].delay = voice[i].delay;
|
|
voice[v2].delay = voice[j].delay;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
init_voice_pan_delay(v1);
|
|
init_voice_pan_delay(v2);
|
|
|
|
recompute_amp(v1);
|
|
mixer->apply_envelope_to_amp(v1);
|
|
recompute_amp(v2);
|
|
mixer->apply_envelope_to_amp(v2);
|
|
if (level) recompute_freq(v2);
|
|
}
|
|
|
|
void Player::note_on(MidiEvent *e)
|
|
{
|
|
int i, nv, v, ch, note;
|
|
int vlist[32];
|
|
int vid;
|
|
int32_t random_delay = 0;
|
|
|
|
ch = e->channel;
|
|
note = MIDI_EVENT_NOTE(e);
|
|
|
|
if(ISDRUMCHANNEL(ch) &&
|
|
channel[ch].drums[note] != NULL &&
|
|
!get_rx_drum(channel[ch].drums[note], RX_NOTE_ON)) { /* Rx. Note On */
|
|
return;
|
|
}
|
|
if(channel[ch].note_limit_low > note ||
|
|
channel[ch].note_limit_high < note ||
|
|
channel[ch].vel_limit_low > e->b ||
|
|
channel[ch].vel_limit_high < e->b) {
|
|
return;
|
|
}
|
|
if((nv = find_samples(e, vlist)) == 0)
|
|
return;
|
|
|
|
vid = new_vidq(e->channel, note);
|
|
|
|
recompute_bank_parameter(ch, note);
|
|
recompute_channel_filter(ch, note);
|
|
random_delay = calc_random_delay(ch, note);
|
|
|
|
for(i = 0; i < nv; i++)
|
|
{
|
|
v = vlist[i];
|
|
if(ISDRUMCHANNEL(ch) &&
|
|
channel[ch].drums[note] != NULL &&
|
|
channel[ch].drums[note]->pan_random)
|
|
channel[ch].drums[note]->drum_panning = int_rand(128);
|
|
else if(channel[ch].pan_random)
|
|
{
|
|
channel[ch].panning = int_rand(128);
|
|
}
|
|
start_note(e, v, vid, nv - i - 1);
|
|
voice[v].delay += random_delay;
|
|
voice[v].modenv_delay += random_delay;
|
|
voice[v].old_left_mix = voice[v].old_right_mix =
|
|
voice[v].left_mix_inc = voice[v].left_mix_offset =
|
|
voice[v].right_mix_inc = voice[v].right_mix_offset = 0;
|
|
if(timidity_surround_chorus)
|
|
new_chorus_voice_alternate(v, 0);
|
|
}
|
|
|
|
channel[ch].legato_flag = 1;
|
|
}
|
|
|
|
/*! sostenuto is now implemented as an instant sustain */
|
|
void Player::update_sostenuto_controls(int ch)
|
|
{
|
|
int uv = upper_voices, i;
|
|
|
|
if(ISDRUMCHANNEL(ch) || channel[ch].sostenuto == 0) {return;}
|
|
|
|
for(i = 0; i < uv; i++)
|
|
{
|
|
if ((voice[i].status & (VOICE_ON | VOICE_OFF))
|
|
&& voice[i].channel == ch)
|
|
{
|
|
voice[i].status = VOICE_SUSTAINED;
|
|
voice[i].envelope_stage = EG_GUS_RELEASE1;
|
|
mixer->recompute_envelope(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*! redamper effect for piano instruments */
|
|
void Player::update_redamper_controls(int ch)
|
|
{
|
|
int uv = upper_voices, i;
|
|
|
|
if(ISDRUMCHANNEL(ch) || channel[ch].damper_mode == 0) {return;}
|
|
|
|
for(i = 0; i < uv; i++)
|
|
{
|
|
if ((voice[i].status & (VOICE_ON | VOICE_OFF))
|
|
&& voice[i].channel == ch)
|
|
{
|
|
voice[i].status = VOICE_SUSTAINED;
|
|
voice[i].envelope_stage = EG_GUS_RELEASE1;
|
|
mixer->recompute_envelope(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Player::note_off(MidiEvent *e)
|
|
{
|
|
int uv = upper_voices, i;
|
|
int ch, note, vid, sustain;
|
|
|
|
ch = e->channel;
|
|
note = MIDI_EVENT_NOTE(e);
|
|
|
|
if(ISDRUMCHANNEL(ch))
|
|
{
|
|
int nbank, nprog;
|
|
|
|
nbank = channel[ch].bank;
|
|
nprog = note;
|
|
instruments->instrument_map(channel[ch].mapID, &nbank, &nprog);
|
|
|
|
if (channel[ch].drums[nprog] != NULL &&
|
|
get_rx_drum(channel[ch].drums[nprog], RX_NOTE_OFF))
|
|
{
|
|
auto bank = instruments->drumSet(nbank);
|
|
if(bank == NULL) bank = instruments->drumSet(0);
|
|
|
|
/* uh oh, this drum doesn't have an instrument loaded yet */
|
|
if (bank->tone[nprog].instrument == NULL)
|
|
return;
|
|
|
|
/* this drum is not loaded for some reason (error occured?) */
|
|
if (IS_MAGIC_INSTRUMENT(bank->tone[nprog].instrument))
|
|
return;
|
|
|
|
/* only disallow Note Off if the drum sample is not looped */
|
|
if (!(bank->tone[nprog].instrument->sample->modes & MODES_LOOPING))
|
|
return; /* Note Off is not allowed. */
|
|
}
|
|
}
|
|
|
|
if ((vid = last_vidq(ch, note)) == -1)
|
|
return;
|
|
sustain = channel[ch].sustain;
|
|
for (i = 0; i < uv; i++)
|
|
{
|
|
if(voice[i].status == VOICE_ON &&
|
|
voice[i].channel == ch &&
|
|
voice[i].note == note &&
|
|
voice[i].vid == vid)
|
|
{
|
|
if(sustain)
|
|
{
|
|
voice[i].status = VOICE_SUSTAINED;
|
|
}
|
|
else
|
|
finish_note(i);
|
|
}
|
|
}
|
|
|
|
channel[ch].legato_flag = 0;
|
|
}
|
|
|
|
/* Process the All Notes Off event */
|
|
void Player::all_notes_off(int c)
|
|
{
|
|
int i, uv = upper_voices;
|
|
printMessage(CMSG_INFO, VERB_DEBUG, "All notes off on channel %d", c);
|
|
for(i = 0; i < uv; i++)
|
|
if (voice[i].status==VOICE_ON &&
|
|
voice[i].channel==c)
|
|
{
|
|
if (channel[c].sustain)
|
|
{
|
|
voice[i].status=VOICE_SUSTAINED;
|
|
}
|
|
else
|
|
finish_note(i);
|
|
}
|
|
for(i = 0; i < 128; i++)
|
|
vidq_head[c * 128 + i] = vidq_tail[c * 128 + i] = 0;
|
|
}
|
|
|
|
/* Process the All Sounds Off event */
|
|
void Player::all_sounds_off(int c)
|
|
{
|
|
int i, uv = upper_voices;
|
|
for(i = 0; i < uv; i++)
|
|
if (voice[i].channel==c &&
|
|
(voice[i].status & ~(VOICE_FREE | VOICE_DIE)))
|
|
{
|
|
kill_note(i);
|
|
}
|
|
for(i = 0; i < 128; i++)
|
|
vidq_head[c * 128 + i] = vidq_tail[c * 128 + i] = 0;
|
|
}
|
|
|
|
/*! adjust polyphonic key pressure (PAf, PAT) */
|
|
void Player::adjust_pressure(MidiEvent *e)
|
|
{
|
|
int i, uv = upper_voices;
|
|
int note, ch;
|
|
|
|
if(timidity_channel_pressure)
|
|
{
|
|
ch = e->channel;
|
|
note = MIDI_EVENT_NOTE(e);
|
|
channel[ch].paf.val = e->b;
|
|
if(channel[ch].paf.pitch != 0) {channel[ch].pitchfactor = 0;}
|
|
|
|
for(i = 0; i < uv; i++)
|
|
if(voice[i].status == VOICE_ON &&
|
|
voice[i].channel == ch &&
|
|
voice[i].note == note)
|
|
{
|
|
recompute_amp(i);
|
|
mixer->apply_envelope_to_amp(i);
|
|
recompute_freq(i);
|
|
recompute_voice_filter(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*! adjust channel pressure (channel aftertouch, CAf, CAT) */
|
|
void Player::adjust_channel_pressure(MidiEvent *e)
|
|
{
|
|
if(timidity_channel_pressure)
|
|
{
|
|
int i, uv = upper_voices;
|
|
int ch;
|
|
|
|
ch = e->channel;
|
|
channel[ch].caf.val = e->a;
|
|
if(channel[ch].caf.pitch != 0) {channel[ch].pitchfactor = 0;}
|
|
|
|
for(i = 0; i < uv; i++)
|
|
{
|
|
if(voice[i].status == VOICE_ON && voice[i].channel == ch)
|
|
{
|
|
recompute_amp(i);
|
|
mixer->apply_envelope_to_amp(i);
|
|
recompute_freq(i);
|
|
recompute_voice_filter(i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Player::adjust_panning(int c)
|
|
{
|
|
int i, uv = upper_voices, pan = channel[c].panning;
|
|
for(i = 0; i < uv; i++)
|
|
{
|
|
if ((voice[i].channel==c) &&
|
|
(voice[i].status & (VOICE_ON | VOICE_SUSTAINED)))
|
|
{
|
|
/* adjust pan to include drum/sample pan offsets */
|
|
pan = get_panning(c, voice[i].note, i);
|
|
|
|
/* Hack to handle -EFchorus=2 in a "reasonable" way */
|
|
if(timidity_surround_chorus && voice[i].chorus_link != i)
|
|
{
|
|
int v1, v2;
|
|
|
|
if(i >= voice[i].chorus_link)
|
|
/* `i' is not base chorus voice.
|
|
* This sub voice is already updated.
|
|
*/
|
|
continue;
|
|
|
|
v1 = i; /* base voice */
|
|
v2 = voice[i].chorus_link; /* sub voice (detuned) */
|
|
|
|
if(timidity_surround_chorus) /* Surround chorus mode by Eric. */
|
|
{
|
|
int panlevel;
|
|
|
|
if (!pan) pan = 1; /* make hard left be 1 instead of 0 */
|
|
panlevel = 63;
|
|
if (pan - panlevel < 1) panlevel = pan - 1;
|
|
if (pan + panlevel > 127) panlevel = 127 - pan;
|
|
voice[v1].panning = pan - panlevel;
|
|
voice[v2].panning = pan + panlevel;
|
|
}
|
|
else
|
|
{
|
|
voice[v1].panning = pan;
|
|
if(pan > 60 && pan < 68) /* PANNED_CENTER */
|
|
voice[v2].panning =
|
|
64 + int_rand(40) - 20; /* 64 +- rand(20) */
|
|
else if(pan < CHORUS_OPPOSITE_THRESHOLD)
|
|
voice[v2].panning = 127;
|
|
else if(pan > 127 - CHORUS_OPPOSITE_THRESHOLD)
|
|
voice[v2].panning = 0;
|
|
else
|
|
voice[v2].panning = (pan < 64 ? 0 : 127);
|
|
}
|
|
recompute_amp(v2);
|
|
mixer->apply_envelope_to_amp(v2);
|
|
/* v1 == i, so v1 will be updated next */
|
|
}
|
|
else
|
|
voice[i].panning = pan;
|
|
|
|
recompute_amp(i);
|
|
mixer->apply_envelope_to_amp(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Player::play_midi_setup_drums(int ch, int note)
|
|
{
|
|
channel[ch].drums[note] = (struct DrumParts *)
|
|
new_segment(&playmidi_pool, sizeof(struct DrumParts));
|
|
reset_drum_controllers(channel[ch].drums, note);
|
|
}
|
|
|
|
void Player::adjust_drum_panning(int ch, int note)
|
|
{
|
|
int i, uv = upper_voices;
|
|
|
|
for(i = 0; i < uv; i++) {
|
|
if(voice[i].channel == ch &&
|
|
voice[i].note == note &&
|
|
(voice[i].status & (VOICE_ON | VOICE_SUSTAINED)))
|
|
{
|
|
voice[i].panning = get_panning(ch, note, i);
|
|
recompute_amp(i);
|
|
mixer->apply_envelope_to_amp(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Player::drop_sustain(int c)
|
|
{
|
|
int i, uv = upper_voices;
|
|
for(i = 0; i < uv; i++)
|
|
if (voice[i].status == VOICE_SUSTAINED && voice[i].channel == c)
|
|
finish_note(i);
|
|
}
|
|
|
|
void Player::adjust_all_pitch(void)
|
|
{
|
|
int ch, i, uv = upper_voices;
|
|
|
|
for (ch = 0; ch < MAX_CHANNELS; ch++)
|
|
channel[ch].pitchfactor = 0;
|
|
for (i = 0; i < uv; i++)
|
|
if (voice[i].status != VOICE_FREE)
|
|
recompute_freq(i);
|
|
}
|
|
|
|
void Player::adjust_pitch(int c)
|
|
{
|
|
int i, uv = upper_voices;
|
|
for(i = 0; i < uv; i++)
|
|
if (voice[i].status != VOICE_FREE && voice[i].channel == c)
|
|
recompute_freq(i);
|
|
}
|
|
|
|
void Player::adjust_volume(int c)
|
|
{
|
|
int i, uv = upper_voices;
|
|
for(i = 0; i < uv; i++)
|
|
if (voice[i].channel == c &&
|
|
(voice[i].status & (VOICE_ON | VOICE_SUSTAINED)))
|
|
{
|
|
recompute_amp(i);
|
|
mixer->apply_envelope_to_amp(i);
|
|
}
|
|
}
|
|
|
|
void Player::set_reverb_level(int ch, int level)
|
|
{
|
|
if (level == -1) {
|
|
channel[ch].reverb_level = channel[ch].reverb_id =
|
|
(timidity_reverb < 0)
|
|
? -timidity_reverb & 0x7f : DEFAULT_REVERB_SEND_LEVEL;
|
|
make_rvid_flag = 1;
|
|
return;
|
|
}
|
|
channel[ch].reverb_level = level;
|
|
make_rvid_flag = 0; /* to update reverb_id */
|
|
}
|
|
|
|
int Player::get_reverb_level(int ch)
|
|
{
|
|
if (channel[ch].reverb_level == -1)
|
|
return (timidity_reverb < 0)
|
|
? -timidity_reverb & 0x7f : DEFAULT_REVERB_SEND_LEVEL;
|
|
return channel[ch].reverb_level;
|
|
}
|
|
|
|
int Player::get_chorus_level(int ch)
|
|
{
|
|
#ifdef DISALLOW_DRUM_BENDS
|
|
if(ISDRUMCHANNEL(ch))
|
|
return 0; /* Not supported drum channel chorus */
|
|
#endif
|
|
if(timidity_chorus == 1)
|
|
return channel[ch].chorus_level;
|
|
return -timidity_chorus;
|
|
}
|
|
|
|
|
|
void Player::free_drum_effect(int ch)
|
|
{
|
|
int i;
|
|
if (channel[ch].drum_effect != NULL) {
|
|
for (i = 0; i < channel[ch].drum_effect_num; i++) {
|
|
if (channel[ch].drum_effect[i].buf != NULL) {
|
|
free(channel[ch].drum_effect[i].buf);
|
|
channel[ch].drum_effect[i].buf = NULL;
|
|
}
|
|
}
|
|
free(channel[ch].drum_effect);
|
|
channel[ch].drum_effect = NULL;
|
|
}
|
|
channel[ch].drum_effect_num = 0;
|
|
channel[ch].drum_effect_flag = 0;
|
|
}
|
|
|
|
void Player::make_drum_effect(int ch)
|
|
{
|
|
int i, note, num = 0;
|
|
int8_t note_table[128];
|
|
struct DrumParts *drum;
|
|
struct DrumPartEffect *de;
|
|
|
|
if (channel[ch].drum_effect_flag == 0) {
|
|
free_drum_effect(ch);
|
|
memset(note_table, 0, sizeof(int8_t) * 128);
|
|
|
|
for(i = 0; i < 128; i++) {
|
|
if ((drum = channel[ch].drums[i]) != NULL)
|
|
{
|
|
if (drum->reverb_level != -1
|
|
|| drum->chorus_level != -1 || drum->delay_level != -1) {
|
|
note_table[num++] = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
channel[ch].drum_effect = (struct DrumPartEffect *)safe_malloc(sizeof(struct DrumPartEffect) * num);
|
|
|
|
for(i = 0; i < num; i++) {
|
|
de = &(channel[ch].drum_effect[i]);
|
|
de->note = note = note_table[i];
|
|
drum = channel[ch].drums[note];
|
|
de->reverb_send = (int32_t)drum->reverb_level * (int32_t)get_reverb_level(ch) / 127;
|
|
de->chorus_send = (int32_t)drum->chorus_level * (int32_t)channel[ch].chorus_level / 127;
|
|
de->delay_send = (int32_t)drum->delay_level * (int32_t)channel[ch].delay_level / 127;
|
|
de->buf = (int32_t *)safe_malloc(AUDIO_BUFFER_SIZE * 8);
|
|
memset(de->buf, 0, AUDIO_BUFFER_SIZE * 8);
|
|
}
|
|
|
|
channel[ch].drum_effect_num = num;
|
|
channel[ch].drum_effect_flag = 1;
|
|
}
|
|
}
|
|
|
|
void Player::adjust_master_volume(void)
|
|
{
|
|
int i, uv = upper_voices;
|
|
adjust_amplification();
|
|
for(i = 0; i < uv; i++)
|
|
if(voice[i].status & (VOICE_ON | VOICE_SUSTAINED))
|
|
{
|
|
recompute_amp(i);
|
|
mixer->apply_envelope_to_amp(i);
|
|
}
|
|
}
|
|
|
|
int Player::midi_drumpart_change(int ch, int isdrum)
|
|
{
|
|
if (IS_SET_CHANNELMASK(drumchannel_mask, ch))
|
|
return 0;
|
|
if (isdrum) {
|
|
SET_CHANNELMASK(drumchannels, ch);
|
|
SET_CHANNELMASK(current_file_info->drumchannels, ch);
|
|
} else {
|
|
UNSET_CHANNELMASK(drumchannels, ch);
|
|
UNSET_CHANNELMASK(current_file_info->drumchannels, ch);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void Player::midi_program_change(int ch, int prog)
|
|
{
|
|
int dr = ISDRUMCHANNEL(ch);
|
|
int newbank, b, p, map;
|
|
|
|
switch (play_system_mode) {
|
|
case GS_SYSTEM_MODE: /* GS */
|
|
if ((map = channel[ch].bank_lsb) == 0) {
|
|
map = channel[ch].tone_map0_number;
|
|
}
|
|
switch (map) {
|
|
case 0: /* No change */
|
|
break;
|
|
case 1:
|
|
channel[ch].mapID = (dr) ? SC_55_DRUM_MAP : SC_55_TONE_MAP;
|
|
break;
|
|
case 2:
|
|
channel[ch].mapID = (dr) ? SC_88_DRUM_MAP : SC_88_TONE_MAP;
|
|
break;
|
|
case 3:
|
|
channel[ch].mapID = (dr) ? SC_88PRO_DRUM_MAP : SC_88PRO_TONE_MAP;
|
|
break;
|
|
case 4:
|
|
channel[ch].mapID = (dr) ? SC_8850_DRUM_MAP : SC_8850_TONE_MAP;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
newbank = channel[ch].bank_msb;
|
|
break;
|
|
case XG_SYSTEM_MODE: /* XG */
|
|
switch (channel[ch].bank_msb) {
|
|
case 0: /* Normal */
|
|
#if 0
|
|
if (ch == 9 && channel[ch].bank_lsb == 127
|
|
&& channel[ch].mapID == XG_DRUM_MAP)
|
|
/* FIXME: Why this part is drum? Is this correct? */
|
|
break;
|
|
#endif
|
|
/* Eric's explanation for the FIXME (March 2004):
|
|
*
|
|
* I don't have the original email from my archived inbox, but I found a
|
|
* reply I made in my archived sent-mail from 1999. A September 5th message
|
|
* to Masanao Izumo is discussing a problem with a "reapxg.mid", a file which
|
|
* I still have, and how it issues an MSB=0 with a program change on ch 9,
|
|
* thus turning it into a melodic channel. The strange thing is, this doesn't
|
|
* happen on XG hardware, nor on the XG softsynth. It continues to play as a
|
|
* normal drum. The author of the midi file obviously intended it to be
|
|
* drumset 16 too. The original fix was to detect LSB == -1, then break so
|
|
* as to not set it to a melodic channel. I'm guessing that this somehow got
|
|
* mutated into checking for 127 instead, and the current FIXME is related to
|
|
* the original hack from Sept 1999. The Sept 5th email discusses patches
|
|
* being applied to version 2.5.1 to get XG drums to work properly, and a
|
|
* Sept 7th email to someone else discusses the fixes being part of the
|
|
* latest 2.6.0-beta3. A September 23rd email to Masanao Izumo specifically
|
|
* mentions the LSB == -1 hack (and reapxg.mid not playing "correctly"
|
|
* anymore), as well as new changes in 2.6.0 that broke a lot of other XG
|
|
* files (XG drum support was extremely buggy in 1999 and we were still trying
|
|
* to figure out how to initialize things to reproduce hardware behavior). An
|
|
* October 5th email says that 2.5.1 was correct, 2.6.0 had very broken XG
|
|
* drum changes, and 2.6.1 still has problems. Further discussions ensued
|
|
* over what was "correct": to follow the XG spec, or to reproduce
|
|
* "features" / bugs in the hardware. I can't find the rest of the
|
|
* discussions, but I think it ended with us agreeing to just follow the spec
|
|
* and not try to reproduce the hardware strangeness. I don't know how the
|
|
* current FIXME wound up the way it is now. I'm still going to guess it is
|
|
* related to the old reapxg.mid hack.
|
|
*
|
|
* Now that reset_midi() initializes channel[ch].bank_lsb to 0 instead of -1,
|
|
* checking for LSB == -1 won't do anything anymore, so changing the above
|
|
* FIXME to the original == -1 won't do any good. It is best to just #if 0
|
|
* it out and leave it here as a reminder that there is at least one XG
|
|
* hardware / softsynth "bug" that is not reproduced by timidity at the
|
|
* moment.
|
|
*
|
|
* If the current FIXME actually reproduces some other XG hadware bug that
|
|
* I don't know about, then it may have a valid purpose. I just don't know
|
|
* what that purpose is at the moment. Perhaps someone else does? I still
|
|
* have src going back to 2.10.4, and the FIXME comment was already there by
|
|
* then. I don't see any entries in the Changelog that could explain it
|
|
* either. If someone has src from 2.5.1 through 2.10.3 and wants to
|
|
* investigate this further, go for it :)
|
|
*/
|
|
midi_drumpart_change(ch, 0);
|
|
channel[ch].mapID = XG_NORMAL_MAP;
|
|
dr = ISDRUMCHANNEL(ch);
|
|
break;
|
|
case 64: /* SFX voice */
|
|
midi_drumpart_change(ch, 0);
|
|
channel[ch].mapID = XG_SFX64_MAP;
|
|
dr = ISDRUMCHANNEL(ch);
|
|
break;
|
|
case 126: /* SFX kit */
|
|
midi_drumpart_change(ch, 1);
|
|
channel[ch].mapID = XG_SFX126_MAP;
|
|
dr = ISDRUMCHANNEL(ch);
|
|
break;
|
|
case 127: /* Drum kit */
|
|
midi_drumpart_change(ch, 1);
|
|
channel[ch].mapID = XG_DRUM_MAP;
|
|
dr = ISDRUMCHANNEL(ch);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
newbank = channel[ch].bank_lsb;
|
|
break;
|
|
case GM2_SYSTEM_MODE: /* GM2 */
|
|
if ((channel[ch].bank_msb & 0xfe) == 0x78) { /* 0x78/0x79 */
|
|
midi_drumpart_change(ch, channel[ch].bank_msb == 0x78);
|
|
dr = ISDRUMCHANNEL(ch);
|
|
}
|
|
channel[ch].mapID = (dr) ? GM2_DRUM_MAP : GM2_TONE_MAP;
|
|
newbank = channel[ch].bank_lsb;
|
|
break;
|
|
default:
|
|
newbank = channel[ch].bank_msb;
|
|
break;
|
|
}
|
|
if (dr) {
|
|
channel[ch].bank = prog; /* newbank is ignored */
|
|
channel[ch].program = prog;
|
|
if (instruments->drumSet(prog) == NULL || instruments->drumSet(prog)->alt == NULL)
|
|
channel[ch].altassign = instruments->drumSet(0)->alt;
|
|
else
|
|
channel[ch].altassign = instruments->drumSet(prog)->alt;
|
|
} else {
|
|
channel[ch].bank = (special_tonebank >= 0)
|
|
? special_tonebank : newbank;
|
|
channel[ch].program = (instruments->defaultProgram(ch) == SPECIAL_PROGRAM)
|
|
? SPECIAL_PROGRAM : prog;
|
|
channel[ch].altassign = NULL;
|
|
if (opt_realtime_playing)
|
|
{
|
|
b = channel[ch].bank, p = prog;
|
|
instruments->instrument_map(channel[ch].mapID, &b, &p);
|
|
play_midi_load_instrument(0, b, p);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*! add a new layer. */
|
|
void Player::add_channel_layer(int to_ch, int from_ch)
|
|
{
|
|
if (to_ch >= MAX_CHANNELS || from_ch >= MAX_CHANNELS)
|
|
return;
|
|
/* add a channel layer */
|
|
UNSET_CHANNELMASK(channel[to_ch].channel_layer, to_ch);
|
|
SET_CHANNELMASK(channel[to_ch].channel_layer, from_ch);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Channel Layer (CH:%d -> CH:%d)", from_ch, to_ch);
|
|
}
|
|
|
|
/*! remove all layers for this channel. */
|
|
void Player::remove_channel_layer(int ch)
|
|
{
|
|
int i, offset;
|
|
|
|
if (ch >= MAX_CHANNELS)
|
|
return;
|
|
/* remove channel layers */
|
|
offset = ch & ~0xf;
|
|
for (i = offset; i < offset + REDUCE_CHANNELS; i++)
|
|
UNSET_CHANNELMASK(channel[i].channel_layer, ch);
|
|
SET_CHANNELMASK(channel[ch].channel_layer, ch);
|
|
}
|
|
|
|
/*! process system exclusive sent from parse_sysex_event_multi(). */
|
|
void Player::process_sysex_event(int ev, int ch, int val, int b)
|
|
{
|
|
int temp, msb, note;
|
|
|
|
if (ch >= MAX_CHANNELS)
|
|
return;
|
|
if (ev == ME_SYSEX_MSB) {
|
|
channel[ch].sysex_msb_addr = b;
|
|
channel[ch].sysex_msb_val = val;
|
|
} else if(ev == ME_SYSEX_GS_MSB) {
|
|
channel[ch].sysex_gs_msb_addr = b;
|
|
channel[ch].sysex_gs_msb_val = val;
|
|
} else if(ev == ME_SYSEX_XG_MSB) {
|
|
channel[ch].sysex_xg_msb_addr = b;
|
|
channel[ch].sysex_xg_msb_val = val;
|
|
} else if(ev == ME_SYSEX_LSB) { /* Universal system exclusive message */
|
|
msb = channel[ch].sysex_msb_addr;
|
|
note = channel[ch].sysex_msb_val;
|
|
channel[ch].sysex_msb_addr = channel[ch].sysex_msb_val = 0;
|
|
switch(b)
|
|
{
|
|
case 0x00: /* CAf Pitch Control */
|
|
if(val > 0x58) {val = 0x58;}
|
|
else if(val < 0x28) {val = 0x28;}
|
|
channel[ch].caf.pitch = val - 64;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAf Pitch Control (CH:%d %d semitones)", ch, channel[ch].caf.pitch);
|
|
break;
|
|
case 0x01: /* CAf Filter Cutoff Control */
|
|
channel[ch].caf.cutoff = (val - 64) * 150;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAf Filter Cutoff Control (CH:%d %d cents)", ch, channel[ch].caf.cutoff);
|
|
break;
|
|
case 0x02: /* CAf Amplitude Control */
|
|
channel[ch].caf.amp = (float)val / 64.0f - 1.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAf Amplitude Control (CH:%d %.2f)", ch, channel[ch].caf.amp);
|
|
break;
|
|
case 0x03: /* CAf LFO1 Rate Control */
|
|
channel[ch].caf.lfo1_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAf LFO1 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].caf.lfo1_rate);
|
|
break;
|
|
case 0x04: /* CAf LFO1 Pitch Depth */
|
|
channel[ch].caf.lfo1_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAf LFO1 Pitch Depth (CH:%d %d cents)", ch, channel[ch].caf.lfo1_pitch_depth);
|
|
break;
|
|
case 0x05: /* CAf LFO1 Filter Depth */
|
|
channel[ch].caf.lfo1_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAf LFO1 Filter Depth (CH:%d %d cents)", ch, channel[ch].caf.lfo1_tvf_depth);
|
|
break;
|
|
case 0x06: /* CAf LFO1 Amplitude Depth */
|
|
channel[ch].caf.lfo1_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAf LFO1 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].caf.lfo1_tva_depth);
|
|
break;
|
|
case 0x07: /* CAf LFO2 Rate Control */
|
|
channel[ch].caf.lfo2_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAf LFO2 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].caf.lfo2_rate);
|
|
break;
|
|
case 0x08: /* CAf LFO2 Pitch Depth */
|
|
channel[ch].caf.lfo2_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAf LFO2 Pitch Depth (CH:%d %d cents)", ch, channel[ch].caf.lfo2_pitch_depth);
|
|
break;
|
|
case 0x09: /* CAf LFO2 Filter Depth */
|
|
channel[ch].caf.lfo2_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAf LFO2 Filter Depth (CH:%d %d cents)", ch, channel[ch].caf.lfo2_tvf_depth);
|
|
break;
|
|
case 0x0A: /* CAf LFO2 Amplitude Depth */
|
|
channel[ch].caf.lfo2_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAf LFO2 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].caf.lfo2_tva_depth);
|
|
break;
|
|
case 0x0B: /* PAf Pitch Control */
|
|
if(val > 0x58) {val = 0x58;}
|
|
else if(val < 0x28) {val = 0x28;}
|
|
channel[ch].paf.pitch = val - 64;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"PAf Pitch Control (CH:%d %d semitones)", ch, channel[ch].paf.pitch);
|
|
break;
|
|
case 0x0C: /* PAf Filter Cutoff Control */
|
|
channel[ch].paf.cutoff = (val - 64) * 150;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"PAf Filter Cutoff Control (CH:%d %d cents)", ch, channel[ch].paf.cutoff);
|
|
break;
|
|
case 0x0D: /* PAf Amplitude Control */
|
|
channel[ch].paf.amp = (float)val / 64.0f - 1.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"PAf Amplitude Control (CH:%d %.2f)", ch, channel[ch].paf.amp);
|
|
break;
|
|
case 0x0E: /* PAf LFO1 Rate Control */
|
|
channel[ch].paf.lfo1_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"PAf LFO1 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].paf.lfo1_rate);
|
|
break;
|
|
case 0x0F: /* PAf LFO1 Pitch Depth */
|
|
channel[ch].paf.lfo1_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"PAf LFO1 Pitch Depth (CH:%d %d cents)", ch, channel[ch].paf.lfo1_pitch_depth);
|
|
break;
|
|
case 0x10: /* PAf LFO1 Filter Depth */
|
|
channel[ch].paf.lfo1_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"PAf LFO1 Filter Depth (CH:%d %d cents)", ch, channel[ch].paf.lfo1_tvf_depth);
|
|
break;
|
|
case 0x11: /* PAf LFO1 Amplitude Depth */
|
|
channel[ch].paf.lfo1_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"PAf LFO1 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].paf.lfo1_tva_depth);
|
|
break;
|
|
case 0x12: /* PAf LFO2 Rate Control */
|
|
channel[ch].paf.lfo2_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"PAf LFO2 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].paf.lfo2_rate);
|
|
break;
|
|
case 0x13: /* PAf LFO2 Pitch Depth */
|
|
channel[ch].paf.lfo2_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"PAf LFO2 Pitch Depth (CH:%d %d cents)", ch, channel[ch].paf.lfo2_pitch_depth);
|
|
break;
|
|
case 0x14: /* PAf LFO2 Filter Depth */
|
|
channel[ch].paf.lfo2_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"PAf LFO2 Filter Depth (CH:%d %d cents)", ch, channel[ch].paf.lfo2_tvf_depth);
|
|
break;
|
|
case 0x15: /* PAf LFO2 Amplitude Depth */
|
|
channel[ch].paf.lfo2_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"PAf LFO2 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].paf.lfo2_tva_depth);
|
|
break;
|
|
case 0x16: /* MOD Pitch Control */
|
|
if(val > 0x58) {val = 0x58;}
|
|
else if(val < 0x28) {val = 0x28;}
|
|
channel[ch].mod.pitch = val - 64;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MOD Pitch Control (CH:%d %d semitones)", ch, channel[ch].mod.pitch);
|
|
break;
|
|
case 0x17: /* MOD Filter Cutoff Control */
|
|
channel[ch].mod.cutoff = (val - 64) * 150;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MOD Filter Cutoff Control (CH:%d %d cents)", ch, channel[ch].mod.cutoff);
|
|
break;
|
|
case 0x18: /* MOD Amplitude Control */
|
|
channel[ch].mod.amp = (float)val / 64.0f - 1.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MOD Amplitude Control (CH:%d %.2f)", ch, channel[ch].mod.amp);
|
|
break;
|
|
case 0x19: /* MOD LFO1 Rate Control */
|
|
channel[ch].mod.lfo1_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MOD LFO1 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].mod.lfo1_rate);
|
|
break;
|
|
case 0x1A: /* MOD LFO1 Pitch Depth */
|
|
channel[ch].mod.lfo1_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MOD LFO1 Pitch Depth (CH:%d %d cents)", ch, channel[ch].mod.lfo1_pitch_depth);
|
|
break;
|
|
case 0x1B: /* MOD LFO1 Filter Depth */
|
|
channel[ch].mod.lfo1_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MOD LFO1 Filter Depth (CH:%d %d cents)", ch, channel[ch].mod.lfo1_tvf_depth);
|
|
break;
|
|
case 0x1C: /* MOD LFO1 Amplitude Depth */
|
|
channel[ch].mod.lfo1_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MOD LFO1 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].mod.lfo1_tva_depth);
|
|
break;
|
|
case 0x1D: /* MOD LFO2 Rate Control */
|
|
channel[ch].mod.lfo2_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MOD LFO2 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].mod.lfo2_rate);
|
|
break;
|
|
case 0x1E: /* MOD LFO2 Pitch Depth */
|
|
channel[ch].mod.lfo2_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MOD LFO2 Pitch Depth (CH:%d %d cents)", ch, channel[ch].mod.lfo2_pitch_depth);
|
|
break;
|
|
case 0x1F: /* MOD LFO2 Filter Depth */
|
|
channel[ch].mod.lfo2_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MOD LFO2 Filter Depth (CH:%d %d cents)", ch, channel[ch].mod.lfo2_tvf_depth);
|
|
break;
|
|
case 0x20: /* MOD LFO2 Amplitude Depth */
|
|
channel[ch].mod.lfo2_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MOD LFO2 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].mod.lfo2_tva_depth);
|
|
break;
|
|
case 0x21: /* BEND Pitch Control */
|
|
if(val > 0x58) {val = 0x58;}
|
|
else if(val < 0x28) {val = 0x28;}
|
|
channel[ch].bend.pitch = val - 64;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND Pitch Control (CH:%d %d semitones)", ch, channel[ch].bend.pitch);
|
|
break;
|
|
case 0x22: /* BEND Filter Cutoff Control */
|
|
channel[ch].bend.cutoff = (val - 64) * 150;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND Filter Cutoff Control (CH:%d %d cents)", ch, channel[ch].bend.cutoff);
|
|
break;
|
|
case 0x23: /* BEND Amplitude Control */
|
|
channel[ch].bend.amp = (float)val / 64.0f - 1.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND Amplitude Control (CH:%d %.2f)", ch, channel[ch].bend.amp);
|
|
break;
|
|
case 0x24: /* BEND LFO1 Rate Control */
|
|
channel[ch].bend.lfo1_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND LFO1 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].bend.lfo1_rate);
|
|
break;
|
|
case 0x25: /* BEND LFO1 Pitch Depth */
|
|
channel[ch].bend.lfo1_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND LFO1 Pitch Depth (CH:%d %d cents)", ch, channel[ch].bend.lfo1_pitch_depth);
|
|
break;
|
|
case 0x26: /* BEND LFO1 Filter Depth */
|
|
channel[ch].bend.lfo1_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND LFO1 Filter Depth (CH:%d %d cents)", ch, channel[ch].bend.lfo1_tvf_depth);
|
|
break;
|
|
case 0x27: /* BEND LFO1 Amplitude Depth */
|
|
channel[ch].bend.lfo1_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND LFO1 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].bend.lfo1_tva_depth);
|
|
break;
|
|
case 0x28: /* BEND LFO2 Rate Control */
|
|
channel[ch].bend.lfo2_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND LFO2 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].bend.lfo2_rate);
|
|
break;
|
|
case 0x29: /* BEND LFO2 Pitch Depth */
|
|
channel[ch].bend.lfo2_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND LFO2 Pitch Depth (CH:%d %d cents)", ch, channel[ch].bend.lfo2_pitch_depth);
|
|
break;
|
|
case 0x2A: /* BEND LFO2 Filter Depth */
|
|
channel[ch].bend.lfo2_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND LFO2 Filter Depth (CH:%d %d cents)", ch, channel[ch].bend.lfo2_tvf_depth);
|
|
break;
|
|
case 0x2B: /* BEND LFO2 Amplitude Depth */
|
|
channel[ch].bend.lfo2_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND LFO2 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].bend.lfo2_tva_depth);
|
|
break;
|
|
case 0x2C: /* CC1 Pitch Control */
|
|
if(val > 0x58) {val = 0x58;}
|
|
else if(val < 0x28) {val = 0x28;}
|
|
channel[ch].cc1.pitch = val - 64;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC1 Pitch Control (CH:%d %d semitones)", ch, channel[ch].cc1.pitch);
|
|
break;
|
|
case 0x2D: /* CC1 Filter Cutoff Control */
|
|
channel[ch].cc1.cutoff = (val - 64) * 150;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC1 Filter Cutoff Control (CH:%d %d cents)", ch, channel[ch].cc1.cutoff);
|
|
break;
|
|
case 0x2E: /* CC1 Amplitude Control */
|
|
channel[ch].cc1.amp = (float)val / 64.0f - 1.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC1 Amplitude Control (CH:%d %.2f)", ch, channel[ch].cc1.amp);
|
|
break;
|
|
case 0x2F: /* CC1 LFO1 Rate Control */
|
|
channel[ch].cc1.lfo1_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC1 LFO1 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].cc1.lfo1_rate);
|
|
break;
|
|
case 0x30: /* CC1 LFO1 Pitch Depth */
|
|
channel[ch].cc1.lfo1_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC1 LFO1 Pitch Depth (CH:%d %d cents)", ch, channel[ch].cc1.lfo1_pitch_depth);
|
|
break;
|
|
case 0x31: /* CC1 LFO1 Filter Depth */
|
|
channel[ch].cc1.lfo1_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC1 LFO1 Filter Depth (CH:%d %d cents)", ch, channel[ch].cc1.lfo1_tvf_depth);
|
|
break;
|
|
case 0x32: /* CC1 LFO1 Amplitude Depth */
|
|
channel[ch].cc1.lfo1_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC1 LFO1 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].cc1.lfo1_tva_depth);
|
|
break;
|
|
case 0x33: /* CC1 LFO2 Rate Control */
|
|
channel[ch].cc1.lfo2_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC1 LFO2 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].cc1.lfo2_rate);
|
|
break;
|
|
case 0x34: /* CC1 LFO2 Pitch Depth */
|
|
channel[ch].cc1.lfo2_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC1 LFO2 Pitch Depth (CH:%d %d cents)", ch, channel[ch].cc1.lfo2_pitch_depth);
|
|
break;
|
|
case 0x35: /* CC1 LFO2 Filter Depth */
|
|
channel[ch].cc1.lfo2_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC1 LFO2 Filter Depth (CH:%d %d cents)", ch, channel[ch].cc1.lfo2_tvf_depth);
|
|
break;
|
|
case 0x36: /* CC1 LFO2 Amplitude Depth */
|
|
channel[ch].cc1.lfo2_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC1 LFO2 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].cc1.lfo2_tva_depth);
|
|
break;
|
|
case 0x37: /* CC2 Pitch Control */
|
|
if(val > 0x58) {val = 0x58;}
|
|
else if(val < 0x28) {val = 0x28;}
|
|
channel[ch].cc2.pitch = val - 64;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC2 Pitch Control (CH:%d %d semitones)", ch, channel[ch].cc2.pitch);
|
|
break;
|
|
case 0x38: /* CC2 Filter Cutoff Control */
|
|
channel[ch].cc2.cutoff = (val - 64) * 150;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC2 Filter Cutoff Control (CH:%d %d cents)", ch, channel[ch].cc2.cutoff);
|
|
break;
|
|
case 0x39: /* CC2 Amplitude Control */
|
|
channel[ch].cc2.amp = (float)val / 64.0f - 1.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC2 Amplitude Control (CH:%d %.2f)", ch, channel[ch].cc2.amp);
|
|
break;
|
|
case 0x3A: /* CC2 LFO1 Rate Control */
|
|
channel[ch].cc2.lfo1_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC2 LFO1 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].cc2.lfo1_rate);
|
|
break;
|
|
case 0x3B: /* CC2 LFO1 Pitch Depth */
|
|
channel[ch].cc2.lfo1_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC2 LFO1 Pitch Depth (CH:%d %d cents)", ch, channel[ch].cc2.lfo1_pitch_depth);
|
|
break;
|
|
case 0x3C: /* CC2 LFO1 Filter Depth */
|
|
channel[ch].cc2.lfo1_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC2 LFO1 Filter Depth (CH:%d %d cents)", ch, channel[ch].cc2.lfo1_tvf_depth);
|
|
break;
|
|
case 0x3D: /* CC2 LFO1 Amplitude Depth */
|
|
channel[ch].cc2.lfo1_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC2 LFO1 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].cc2.lfo1_tva_depth);
|
|
break;
|
|
case 0x3E: /* CC2 LFO2 Rate Control */
|
|
channel[ch].cc2.lfo2_rate = (float)(val - 64) / 6.4f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC2 LFO2 Rate Control (CH:%d %.1f Hz)", ch, channel[ch].cc2.lfo2_rate);
|
|
break;
|
|
case 0x3F: /* CC2 LFO2 Pitch Depth */
|
|
channel[ch].cc2.lfo2_pitch_depth = conv_lfo_pitch_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC2 LFO2 Pitch Depth (CH:%d %d cents)", ch, channel[ch].cc2.lfo2_pitch_depth);
|
|
break;
|
|
case 0x40: /* CC2 LFO2 Filter Depth */
|
|
channel[ch].cc2.lfo2_tvf_depth = conv_lfo_filter_depth(val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC2 LFO2 Filter Depth (CH:%d %d cents)", ch, channel[ch].cc2.lfo2_tvf_depth);
|
|
break;
|
|
case 0x41: /* CC2 LFO2 Amplitude Depth */
|
|
channel[ch].cc2.lfo2_tva_depth = (float)val / 127.0f;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CC2 LFO2 Amplitude Depth (CH:%d %.2f)", ch, channel[ch].cc2.lfo2_tva_depth);
|
|
break;
|
|
case 0x42: /* Note Limit Low */
|
|
channel[ch].note_limit_low = val;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Note Limit Low (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x43: /* Note Limit High */
|
|
channel[ch].note_limit_high = val;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Note Limit High (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x44: /* Velocity Limit Low */
|
|
channel[ch].vel_limit_low = val;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Velocity Limit Low (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x45: /* Velocity Limit High */
|
|
channel[ch].vel_limit_high = val;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Velocity Limit High (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x46: /* Rx. Note Off */
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
set_rx_drum(channel[ch].drums[note], RX_NOTE_OFF, val);
|
|
printMessage(CMSG_INFO, VERB_NOISY,
|
|
"Drum Instrument Rx. Note Off (CH:%d NOTE:%d VAL:%d)",
|
|
ch, note, val);
|
|
break;
|
|
case 0x47: /* Rx. Note On */
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
set_rx_drum(channel[ch].drums[note], RX_NOTE_ON, val);
|
|
printMessage(CMSG_INFO, VERB_NOISY,
|
|
"Drum Instrument Rx. Note On (CH:%d NOTE:%d VAL:%d)",
|
|
ch, note, val);
|
|
break;
|
|
case 0x48: /* Rx. Pitch Bend */
|
|
set_rx(ch, RX_PITCH_BEND, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Pitch Bend (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x49: /* Rx. Channel Pressure */
|
|
set_rx(ch, RX_CH_PRESSURE, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Channel Pressure (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x4A: /* Rx. Program Change */
|
|
set_rx(ch, RX_PROGRAM_CHANGE, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Program Change (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x4B: /* Rx. Control Change */
|
|
set_rx(ch, RX_CONTROL_CHANGE, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Control Change (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x4C: /* Rx. Poly Pressure */
|
|
set_rx(ch, RX_POLY_PRESSURE, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Poly Pressure (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x4D: /* Rx. Note Message */
|
|
set_rx(ch, RX_NOTE_MESSAGE, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Note Message (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x4E: /* Rx. RPN */
|
|
set_rx(ch, RX_RPN, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. RPN (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x4F: /* Rx. NRPN */
|
|
set_rx(ch, RX_NRPN, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. NRPN (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x50: /* Rx. Modulation */
|
|
set_rx(ch, RX_MODULATION, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Modulation (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x51: /* Rx. Volume */
|
|
set_rx(ch, RX_VOLUME, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Volume (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x52: /* Rx. Panpot */
|
|
set_rx(ch, RX_PANPOT, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Panpot (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x53: /* Rx. Expression */
|
|
set_rx(ch, RX_EXPRESSION, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Expression (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x54: /* Rx. Hold1 */
|
|
set_rx(ch, RX_HOLD1, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Hold1 (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x55: /* Rx. Portamento */
|
|
set_rx(ch, RX_PORTAMENTO, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Portamento (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x56: /* Rx. Sostenuto */
|
|
set_rx(ch, RX_SOSTENUTO, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Sostenuto (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x57: /* Rx. Soft */
|
|
set_rx(ch, RX_SOFT, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Soft (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x58: /* Rx. Bank Select */
|
|
set_rx(ch, RX_BANK_SELECT, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Bank Select (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x59: /* Rx. Bank Select LSB */
|
|
set_rx(ch, RX_BANK_SELECT_LSB, val);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Rx. Bank Select LSB (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
case 0x60: /* Reverb Type (GM2) */
|
|
if (val > 8) {val = 8;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Type (%d)", val);
|
|
reverb->set_reverb_macro_gm2(val);
|
|
reverb->recompute_reverb_status_gs();
|
|
reverb->init_reverb();
|
|
break;
|
|
case 0x61: /* Chorus Type (GM2) */
|
|
if (val > 5) {val = 5;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Type (%d)", val);
|
|
reverb->set_chorus_macro_gs(val);
|
|
reverb->recompute_chorus_status_gs();
|
|
reverb->init_ch_chorus();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return;
|
|
} else if(ev == ME_SYSEX_GS_LSB) { /* GS system exclusive message */
|
|
msb = channel[ch].sysex_gs_msb_addr;
|
|
note = channel[ch].sysex_gs_msb_val;
|
|
channel[ch].sysex_gs_msb_addr = channel[ch].sysex_gs_msb_val = 0;
|
|
switch(b)
|
|
{
|
|
case 0x00: /* EQ ON/OFF */
|
|
if(!opt_eq_control) {break;}
|
|
channel[ch].eq_gs = val;
|
|
break;
|
|
case 0x01: /* EQ LOW FREQ */
|
|
if(!opt_eq_control) {break;}
|
|
reverb->eq_status_gs.low_freq = val;
|
|
reverb->recompute_eq_status_gs();
|
|
break;
|
|
case 0x02: /* EQ LOW GAIN */
|
|
if(!opt_eq_control) {break;}
|
|
reverb->eq_status_gs.low_gain = val;
|
|
reverb->recompute_eq_status_gs();
|
|
break;
|
|
case 0x03: /* EQ HIGH FREQ */
|
|
if(!opt_eq_control) {break;}
|
|
reverb->eq_status_gs.high_freq = val;
|
|
reverb->recompute_eq_status_gs();
|
|
break;
|
|
case 0x04: /* EQ HIGH GAIN */
|
|
if(!opt_eq_control) {break;}
|
|
reverb->eq_status_gs.high_gain = val;
|
|
reverb->recompute_eq_status_gs();
|
|
break;
|
|
case 0x05: /* Reverb Macro */
|
|
if (val > 7) {val = 7;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Macro (%d)",val);
|
|
reverb->set_reverb_macro_gs(val);
|
|
reverb->recompute_reverb_status_gs();
|
|
reverb->init_reverb();
|
|
break;
|
|
case 0x06: /* Reverb Character */
|
|
if (val > 7) {val = 7;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Character (%d)",val);
|
|
if (reverb->reverb_status_gs.character != val) {
|
|
reverb->reverb_status_gs.character = val;
|
|
reverb->recompute_reverb_status_gs();
|
|
reverb->init_reverb();
|
|
}
|
|
break;
|
|
case 0x07: /* Reverb Pre-LPF */
|
|
if (val > 7) {val = 7;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Pre-LPF (%d)",val);
|
|
if(reverb->reverb_status_gs.pre_lpf != val) {
|
|
reverb->reverb_status_gs.pre_lpf = val;
|
|
reverb->recompute_reverb_status_gs();
|
|
}
|
|
break;
|
|
case 0x08: /* Reverb Level */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Level (%d)",val);
|
|
if(reverb->reverb_status_gs.level != val) {
|
|
reverb->reverb_status_gs.level = val;
|
|
reverb->recompute_reverb_status_gs();
|
|
reverb->init_reverb();
|
|
}
|
|
break;
|
|
case 0x09: /* Reverb Time */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Time (%d)",val);
|
|
if(reverb->reverb_status_gs.time != val) {
|
|
reverb->reverb_status_gs.time = val;
|
|
reverb->recompute_reverb_status_gs();
|
|
reverb->init_reverb();
|
|
}
|
|
break;
|
|
case 0x0A: /* Reverb Delay Feedback */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Delay Feedback (%d)",val);
|
|
if(reverb->reverb_status_gs.delay_feedback != val) {
|
|
reverb->reverb_status_gs.delay_feedback = val;
|
|
reverb->recompute_reverb_status_gs();
|
|
reverb->init_reverb();
|
|
}
|
|
break;
|
|
case 0x0C: /* Reverb Predelay Time */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Predelay Time (%d)",val);
|
|
if(reverb->reverb_status_gs.pre_delay_time != val) {
|
|
reverb->reverb_status_gs.pre_delay_time = val;
|
|
reverb->recompute_reverb_status_gs();
|
|
reverb->init_reverb();
|
|
}
|
|
break;
|
|
case 0x0D: /* Chorus Macro */
|
|
if (val > 7) {val = 7;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Macro (%d)",val);
|
|
reverb->set_chorus_macro_gs(val);
|
|
reverb->recompute_chorus_status_gs();
|
|
reverb->init_ch_chorus();
|
|
break;
|
|
case 0x0E: /* Chorus Pre-LPF */
|
|
if (val > 7) {val = 7;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Pre-LPF (%d)",val);
|
|
if (reverb->chorus_status_gs.pre_lpf != val) {
|
|
reverb->chorus_status_gs.pre_lpf = val;
|
|
reverb->recompute_chorus_status_gs();
|
|
}
|
|
break;
|
|
case 0x0F: /* Chorus Level */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Level (%d)",val);
|
|
if (reverb->chorus_status_gs.level != val) {
|
|
reverb->chorus_status_gs.level = val;
|
|
reverb->recompute_chorus_status_gs();
|
|
reverb->init_ch_chorus();
|
|
}
|
|
break;
|
|
case 0x10: /* Chorus Feedback */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Feedback (%d)",val);
|
|
if (reverb->chorus_status_gs.feedback != val) {
|
|
reverb->chorus_status_gs.feedback = val;
|
|
reverb->recompute_chorus_status_gs();
|
|
reverb->init_ch_chorus();
|
|
}
|
|
break;
|
|
case 0x11: /* Chorus Delay */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Delay (%d)",val);
|
|
if (reverb->chorus_status_gs.delay != val) {
|
|
reverb->chorus_status_gs.delay = val;
|
|
reverb->recompute_chorus_status_gs();
|
|
reverb->init_ch_chorus();
|
|
}
|
|
break;
|
|
case 0x12: /* Chorus Rate */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Rate (%d)",val);
|
|
if (reverb->chorus_status_gs.rate != val) {
|
|
reverb->chorus_status_gs.rate = val;
|
|
reverb->recompute_chorus_status_gs();
|
|
reverb->init_ch_chorus();
|
|
}
|
|
break;
|
|
case 0x13: /* Chorus Depth */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Depth (%d)",val);
|
|
if (reverb->chorus_status_gs.depth != val) {
|
|
reverb->chorus_status_gs.depth = val;
|
|
reverb->recompute_chorus_status_gs();
|
|
reverb->init_ch_chorus();
|
|
}
|
|
break;
|
|
case 0x14: /* Chorus Send Level to Reverb */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Send Level to Reverb (%d)",val);
|
|
if (reverb->chorus_status_gs.send_reverb != val) {
|
|
reverb->chorus_status_gs.send_reverb = val;
|
|
reverb->recompute_chorus_status_gs();
|
|
reverb->init_ch_chorus();
|
|
}
|
|
break;
|
|
case 0x15: /* Chorus Send Level to Delay */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Send Level to Delay (%d)",val);
|
|
if (reverb->chorus_status_gs.send_delay != val) {
|
|
reverb->chorus_status_gs.send_delay = val;
|
|
reverb->recompute_chorus_status_gs();
|
|
reverb->init_ch_chorus();
|
|
}
|
|
break;
|
|
case 0x16: /* Delay Macro */
|
|
if (val > 7) {val = 7;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Macro (%d)",val);
|
|
reverb->set_delay_macro_gs(val);
|
|
reverb->recompute_delay_status_gs();
|
|
reverb->init_ch_delay();
|
|
break;
|
|
case 0x17: /* Delay Pre-LPF */
|
|
if (val > 7) {val = 7;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Pre-LPF (%d)",val);
|
|
val &= 0x7;
|
|
if (reverb->delay_status_gs.pre_lpf != val) {
|
|
reverb->delay_status_gs.pre_lpf = val;
|
|
reverb->recompute_delay_status_gs();
|
|
}
|
|
break;
|
|
case 0x18: /* Delay Time Center */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Time Center (%d)",val);
|
|
if (reverb->delay_status_gs.time_c != val) {
|
|
reverb->delay_status_gs.time_c = val;
|
|
reverb->recompute_delay_status_gs();
|
|
reverb->init_ch_delay();
|
|
}
|
|
break;
|
|
case 0x19: /* Delay Time Ratio Left */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Time Ratio Left (%d)",val);
|
|
if (val == 0) {val = 1;}
|
|
if (reverb->delay_status_gs.time_l != val) {
|
|
reverb->delay_status_gs.time_l = val;
|
|
reverb->recompute_delay_status_gs();
|
|
reverb->init_ch_delay();
|
|
}
|
|
break;
|
|
case 0x1A: /* Delay Time Ratio Right */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Time Ratio Right (%d)",val);
|
|
if (val == 0) {val = 1;}
|
|
if (reverb->delay_status_gs.time_r != val) {
|
|
reverb->delay_status_gs.time_r = val;
|
|
reverb->recompute_delay_status_gs();
|
|
reverb->init_ch_delay();
|
|
}
|
|
break;
|
|
case 0x1B: /* Delay Level Center */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Level Center (%d)",val);
|
|
if (reverb->delay_status_gs.level_center != val) {
|
|
reverb->delay_status_gs.level_center = val;
|
|
reverb->recompute_delay_status_gs();
|
|
reverb->init_ch_delay();
|
|
}
|
|
break;
|
|
case 0x1C: /* Delay Level Left */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Level Left (%d)",val);
|
|
if (reverb->delay_status_gs.level_left != val) {
|
|
reverb->delay_status_gs.level_left = val;
|
|
reverb->recompute_delay_status_gs();
|
|
reverb->init_ch_delay();
|
|
}
|
|
break;
|
|
case 0x1D: /* Delay Level Right */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Level Right (%d)",val);
|
|
if (reverb->delay_status_gs.level_right != val) {
|
|
reverb->delay_status_gs.level_right = val;
|
|
reverb->recompute_delay_status_gs();
|
|
reverb->init_ch_delay();
|
|
}
|
|
break;
|
|
case 0x1E: /* Delay Level */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Level (%d)",val);
|
|
if (reverb->delay_status_gs.level != val) {
|
|
reverb->delay_status_gs.level = val;
|
|
reverb->recompute_delay_status_gs();
|
|
reverb->init_ch_delay();
|
|
}
|
|
break;
|
|
case 0x1F: /* Delay Feedback */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Feedback (%d)",val);
|
|
if (reverb->delay_status_gs.feedback != val) {
|
|
reverb->delay_status_gs.feedback = val;
|
|
reverb->recompute_delay_status_gs();
|
|
reverb->init_ch_delay();
|
|
}
|
|
break;
|
|
case 0x20: /* Delay Send Level to Reverb */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Send Level to Reverb (%d)",val);
|
|
if (reverb->delay_status_gs.send_reverb != val) {
|
|
reverb->delay_status_gs.send_reverb = val;
|
|
reverb->recompute_delay_status_gs();
|
|
reverb->init_ch_delay();
|
|
}
|
|
break;
|
|
case 0x21: /* Velocity Sense Depth */
|
|
channel[ch].velocity_sense_depth = val;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Velocity Sense Depth (CH:%d VAL:%d)",ch,val);
|
|
break;
|
|
case 0x22: /* Velocity Sense Offset */
|
|
channel[ch].velocity_sense_offset = val;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Velocity Sense Offset (CH:%d VAL:%d)",ch,val);
|
|
break;
|
|
case 0x23: /* Insertion Effect ON/OFF */
|
|
if(!opt_insertion_effect) {break;}
|
|
if(channel[ch].insertion_effect != val) {
|
|
//if(val) {//printMessage(CMSG_INFO,VERB_NOISY,"EFX ON (CH:%d)",ch);}
|
|
//else {//printMessage(CMSG_INFO,VERB_NOISY,"EFX OFF (CH:%d)",ch);}
|
|
}
|
|
channel[ch].insertion_effect = val;
|
|
break;
|
|
case 0x24: /* Assign Mode */
|
|
channel[ch].assign_mode = val;
|
|
if(val == 0) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Assign Mode: Single (CH:%d)",ch);
|
|
} else if(val == 1) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Assign Mode: Limited-Multi (CH:%d)",ch);
|
|
} else if(val == 2) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Assign Mode: Full-Multi (CH:%d)",ch);
|
|
}
|
|
break;
|
|
case 0x25: /* TONE MAP-0 NUMBER */
|
|
channel[ch].tone_map0_number = val;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Tone Map-0 Number (CH:%d VAL:%d)",ch,val);
|
|
break;
|
|
case 0x26: /* Pitch Offset Fine */
|
|
channel[ch].pitch_offset_fine = (double)((((int32_t)val << 4) | (int32_t)val) - 0x80) / 10.0;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Pitch Offset Fine (CH:%d %3fHz)",ch,channel[ch].pitch_offset_fine);
|
|
break;
|
|
case 0x27: /* Insertion Effect Parameter */
|
|
if(!opt_insertion_effect) {break;}
|
|
temp = reverb->insertion_effect_gs.type;
|
|
reverb->insertion_effect_gs.type_msb = val;
|
|
reverb->insertion_effect_gs.type = ((int32_t)reverb->insertion_effect_gs.type_msb << 8) | (int32_t)reverb->insertion_effect_gs.type_lsb;
|
|
if(temp == reverb->insertion_effect_gs.type) {
|
|
reverb->recompute_insertion_effect_gs();
|
|
} else {
|
|
reverb->realloc_insertion_effect_gs();
|
|
}
|
|
break;
|
|
case 0x28: /* Insertion Effect Parameter */
|
|
if(!opt_insertion_effect) {break;}
|
|
temp = reverb->insertion_effect_gs.type;
|
|
reverb->insertion_effect_gs.type_lsb = val;
|
|
reverb->insertion_effect_gs.type = ((int32_t)reverb->insertion_effect_gs.type_msb << 8) | (int32_t)reverb->insertion_effect_gs.type_lsb;
|
|
if(temp == reverb->insertion_effect_gs.type) {
|
|
reverb->recompute_insertion_effect_gs();
|
|
} else {
|
|
reverb->realloc_insertion_effect_gs();
|
|
}
|
|
break;
|
|
case 0x29:
|
|
reverb->insertion_effect_gs.parameter[0] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x2A:
|
|
reverb->insertion_effect_gs.parameter[1] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x2B:
|
|
reverb->insertion_effect_gs.parameter[2] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x2C:
|
|
reverb->insertion_effect_gs.parameter[3] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x2D:
|
|
reverb->insertion_effect_gs.parameter[4] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x2E:
|
|
reverb->insertion_effect_gs.parameter[5] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x2F:
|
|
reverb->insertion_effect_gs.parameter[6] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x30:
|
|
reverb->insertion_effect_gs.parameter[7] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x31:
|
|
reverb->insertion_effect_gs.parameter[8] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x32:
|
|
reverb->insertion_effect_gs.parameter[9] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x33:
|
|
reverb->insertion_effect_gs.parameter[10] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x34:
|
|
reverb->insertion_effect_gs.parameter[11] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x35:
|
|
reverb->insertion_effect_gs.parameter[12] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x36:
|
|
reverb->insertion_effect_gs.parameter[13] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x37:
|
|
reverb->insertion_effect_gs.parameter[14] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x38:
|
|
reverb->insertion_effect_gs.parameter[15] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x39:
|
|
reverb->insertion_effect_gs.parameter[16] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x3A:
|
|
reverb->insertion_effect_gs.parameter[17] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x3B:
|
|
reverb->insertion_effect_gs.parameter[18] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x3C:
|
|
reverb->insertion_effect_gs.parameter[19] = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x3D:
|
|
reverb->insertion_effect_gs.send_reverb = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x3E:
|
|
reverb->insertion_effect_gs.send_chorus = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x3F:
|
|
reverb->insertion_effect_gs.send_delay = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x40:
|
|
reverb->insertion_effect_gs.control_source1 = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x41:
|
|
reverb->insertion_effect_gs.control_depth1 = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x42:
|
|
reverb->insertion_effect_gs.control_source2 = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x43:
|
|
reverb->insertion_effect_gs.control_depth2 = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x44:
|
|
reverb->insertion_effect_gs.send_eq_switch = val;
|
|
reverb->recompute_insertion_effect_gs();
|
|
break;
|
|
case 0x45: /* Rx. Channel */
|
|
reset_controllers(ch);
|
|
all_notes_off(ch);
|
|
if (val == 0x80)
|
|
remove_channel_layer(ch);
|
|
else
|
|
add_channel_layer(ch, val);
|
|
break;
|
|
case 0x46: /* Channel Msg Rx Port */
|
|
reset_controllers(ch);
|
|
all_notes_off(ch);
|
|
channel[ch].port_select = val;
|
|
break;
|
|
case 0x47: /* Play Note Number */
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
channel[ch].drums[note]->play_note = val;
|
|
printMessage(CMSG_INFO, VERB_NOISY,
|
|
"Drum Instrument Play Note (CH:%d NOTE:%d VAL:%d)",
|
|
ch, note, channel[ch].drums[note]->play_note);
|
|
channel[ch].pitchfactor = 0;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return;
|
|
} else if(ev == ME_SYSEX_XG_LSB) { /* XG system exclusive message */
|
|
msb = channel[ch].sysex_xg_msb_addr;
|
|
note = channel[ch].sysex_xg_msb_val;
|
|
if (note == 3 && msb == 0) { /* Effect 2 */
|
|
note = 0; /* force insertion effect num 0 ?? */
|
|
if (note >= XG_INSERTION_EFFECT_NUM || note < 0) {return;}
|
|
switch(b)
|
|
{
|
|
case 0x00: /* Insertion Effect Type MSB */
|
|
if (reverb->insertion_effect_xg[note].type_msb != val) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Insertion Effect Type MSB (%d %02X)", note, val);
|
|
reverb->insertion_effect_xg[note].type_msb = val;
|
|
reverb->realloc_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x01: /* Insertion Effect Type LSB */
|
|
if (reverb->insertion_effect_xg[note].type_lsb != val) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Insertion Effect Type LSB (%d %02X)", note, val);
|
|
reverb->insertion_effect_xg[note].type_lsb = val;
|
|
reverb->realloc_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x02: /* Insertion Effect Parameter 1 - 10 */
|
|
case 0x03:
|
|
case 0x04:
|
|
case 0x05:
|
|
case 0x06:
|
|
case 0x07:
|
|
case 0x08:
|
|
case 0x09:
|
|
case 0x0A:
|
|
case 0x0B:
|
|
if (reverb->insertion_effect_xg[note].use_msb) {break;}
|
|
temp = b - 0x02;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Insertion Effect Parameter %d (%d %d)", temp + 1, note, val);
|
|
if (reverb->insertion_effect_xg[note].param_lsb[temp] != val) {
|
|
reverb->insertion_effect_xg[note].param_lsb[temp] = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x0C: /* Insertion Effect Part */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Insertion Effect Part (%d %d)", note, val);
|
|
if (reverb->insertion_effect_xg[note].part != val) {
|
|
reverb->insertion_effect_xg[note].part = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x0D: /* MW Insertion Control Depth */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MW Insertion Control Depth (%d %d)", note, val);
|
|
if (reverb->insertion_effect_xg[note].mw_depth != val) {
|
|
reverb->insertion_effect_xg[note].mw_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x0E: /* BEND Insertion Control Depth */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND Insertion Control Depth (%d %d)", note, val);
|
|
if (reverb->insertion_effect_xg[note].bend_depth != val) {
|
|
reverb->insertion_effect_xg[note].bend_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x0F: /* CAT Insertion Control Depth */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAT Insertion Control Depth (%d %d)", note, val);
|
|
if (reverb->insertion_effect_xg[note].cat_depth != val) {
|
|
reverb->insertion_effect_xg[note].cat_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x10: /* AC1 Insertion Control Depth */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"AC1 Insertion Control Depth (%d %d)", note, val);
|
|
if (reverb->insertion_effect_xg[note].ac1_depth != val) {
|
|
reverb->insertion_effect_xg[note].ac1_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x11: /* AC2 Insertion Control Depth */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"AC2 Insertion Control Depth (%d %d)", note, val);
|
|
if (reverb->insertion_effect_xg[note].ac2_depth != val) {
|
|
reverb->insertion_effect_xg[note].ac2_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x12: /* CBC1 Insertion Control Depth */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CBC1 Insertion Control Depth (%d %d)", note, val);
|
|
if (reverb->insertion_effect_xg[note].cbc1_depth != val) {
|
|
reverb->insertion_effect_xg[note].cbc1_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x13: /* CBC2 Insertion Control Depth */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CBC2 Insertion Control Depth (%d %d)", note, val);
|
|
if (reverb->insertion_effect_xg[note].cbc2_depth != val) {
|
|
reverb->insertion_effect_xg[note].cbc2_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x20: /* Insertion Effect Parameter 11 - 16 */
|
|
case 0x21:
|
|
case 0x22:
|
|
case 0x23:
|
|
case 0x24:
|
|
case 0x25:
|
|
temp = b - 0x20 + 10;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Insertion Effect Parameter %d (%d %d)", temp + 1, note, val);
|
|
if (reverb->insertion_effect_xg[note].param_lsb[temp] != val) {
|
|
reverb->insertion_effect_xg[note].param_lsb[temp] = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x30: /* Insertion Effect Parameter 1 - 10 MSB */
|
|
case 0x32:
|
|
case 0x34:
|
|
case 0x36:
|
|
case 0x38:
|
|
case 0x3A:
|
|
case 0x3C:
|
|
case 0x3E:
|
|
case 0x40:
|
|
case 0x42:
|
|
if (!reverb->insertion_effect_xg[note].use_msb) {break;}
|
|
temp = (b - 0x30) / 2;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Insertion Effect Parameter %d MSB (%d %d)", temp + 1, note, val);
|
|
if (reverb->insertion_effect_xg[note].param_msb[temp] != val) {
|
|
reverb->insertion_effect_xg[note].param_msb[temp] = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x31: /* Insertion Effect Parameter 1 - 10 LSB */
|
|
case 0x33:
|
|
case 0x35:
|
|
case 0x37:
|
|
case 0x39:
|
|
case 0x3B:
|
|
case 0x3D:
|
|
case 0x3F:
|
|
case 0x41:
|
|
case 0x43:
|
|
if (!reverb->insertion_effect_xg[note].use_msb) {break;}
|
|
temp = (b - 0x31) / 2;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Insertion Effect Parameter %d LSB (%d %d)", temp + 1, note, val);
|
|
if (reverb->insertion_effect_xg[note].param_lsb[temp] != val) {
|
|
reverb->insertion_effect_xg[note].param_lsb[temp] = val;
|
|
reverb->recompute_effect_xg(&reverb->insertion_effect_xg[note]);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} else if (note == 2 && msb == 1) { /* Effect 1 */
|
|
note = 0; /* force variation effect num 0 ?? */
|
|
switch(b)
|
|
{
|
|
case 0x00: /* Reverb Type MSB */
|
|
if (reverb->reverb_status_xg.type_msb != val) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Type MSB (%02X)", val);
|
|
reverb->reverb_status_xg.type_msb = val;
|
|
reverb->realloc_effect_xg(&reverb->reverb_status_xg);
|
|
}
|
|
break;
|
|
case 0x01: /* Reverb Type LSB */
|
|
if (reverb->reverb_status_xg.type_lsb != val) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Type LSB (%02X)", val);
|
|
reverb->reverb_status_xg.type_lsb = val;
|
|
reverb->realloc_effect_xg(&reverb->reverb_status_xg);
|
|
}
|
|
break;
|
|
case 0x02: /* Reverb Parameter 1 - 10 */
|
|
case 0x03:
|
|
case 0x04:
|
|
case 0x05:
|
|
case 0x06:
|
|
case 0x07:
|
|
case 0x08:
|
|
case 0x09:
|
|
case 0x0A:
|
|
case 0x0B:
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Parameter %d (%d)", b - 0x02 + 1, val);
|
|
if (reverb->reverb_status_xg.param_lsb[b - 0x02] != val) {
|
|
reverb->reverb_status_xg.param_lsb[b - 0x02] = val;
|
|
reverb->recompute_effect_xg(&reverb->reverb_status_xg);
|
|
}
|
|
break;
|
|
case 0x0C: /* Reverb Return */
|
|
#if 0 /* XG specific reverb is not currently implemented */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Return (%d)", val);
|
|
if (reverb->reverb_status_xg.ret != val) {
|
|
reverb->reverb_status_xg.ret = val;
|
|
reverb->recompute_effect_xg(&reverb->reverb_status_xg);
|
|
}
|
|
#else /* use GS reverb instead */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Return (%d)", val);
|
|
if (reverb->reverb_status_gs.level != val) {
|
|
reverb->reverb_status_gs.level = val;
|
|
reverb->recompute_reverb_status_gs();
|
|
reverb->init_reverb();
|
|
}
|
|
#endif
|
|
break;
|
|
case 0x0D: /* Reverb Pan */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Pan (%d)", val);
|
|
if (reverb->reverb_status_xg.pan != val) {
|
|
reverb->reverb_status_xg.pan = val;
|
|
reverb->recompute_effect_xg(&reverb->reverb_status_xg);
|
|
}
|
|
break;
|
|
case 0x10: /* Reverb Parameter 11 - 16 */
|
|
case 0x11:
|
|
case 0x12:
|
|
case 0x13:
|
|
case 0x14:
|
|
case 0x15:
|
|
temp = b - 0x10 + 10;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Reverb Parameter %d (%d)", temp + 1, val);
|
|
if (reverb->reverb_status_xg.param_lsb[temp] != val) {
|
|
reverb->reverb_status_xg.param_lsb[temp] = val;
|
|
reverb->recompute_effect_xg(&reverb->reverb_status_xg);
|
|
}
|
|
break;
|
|
case 0x20: /* Chorus Type MSB */
|
|
if (reverb->chorus_status_xg.type_msb != val) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Type MSB (%02X)", val);
|
|
reverb->chorus_status_xg.type_msb = val;
|
|
reverb->realloc_effect_xg(&reverb->chorus_status_xg);
|
|
}
|
|
break;
|
|
case 0x21: /* Chorus Type LSB */
|
|
if (reverb->chorus_status_xg.type_lsb != val) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Type LSB (%02X)", val);
|
|
reverb->chorus_status_xg.type_lsb = val;
|
|
reverb->realloc_effect_xg(&reverb->chorus_status_xg);
|
|
}
|
|
break;
|
|
case 0x22: /* Chorus Parameter 1 - 10 */
|
|
case 0x23:
|
|
case 0x24:
|
|
case 0x25:
|
|
case 0x26:
|
|
case 0x27:
|
|
case 0x28:
|
|
case 0x29:
|
|
case 0x2A:
|
|
case 0x2B:
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Parameter %d (%d)", b - 0x22 + 1, val);
|
|
if (reverb->chorus_status_xg.param_lsb[b - 0x22] != val) {
|
|
reverb->chorus_status_xg.param_lsb[b - 0x22] = val;
|
|
reverb->recompute_effect_xg(&reverb->chorus_status_xg);
|
|
}
|
|
break;
|
|
case 0x2C: /* Chorus Return */
|
|
#if 0 /* XG specific chorus is not currently implemented */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Return (%d)", val);
|
|
if (reverb->chorus_status_xg.ret != val) {
|
|
reverb->chorus_status_xg.ret = val;
|
|
reverb->recompute_effect_xg(&reverb->chorus_status_xg);
|
|
}
|
|
#else /* use GS chorus instead */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Return (%d)", val);
|
|
if (reverb->chorus_status_gs.level != val) {
|
|
reverb->chorus_status_gs.level = val;
|
|
reverb->recompute_chorus_status_gs();
|
|
reverb->init_ch_chorus();
|
|
}
|
|
#endif
|
|
break;
|
|
case 0x2D: /* Chorus Pan */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Pan (%d)", val);
|
|
if (reverb->chorus_status_xg.pan != val) {
|
|
reverb->chorus_status_xg.pan = val;
|
|
reverb->recompute_effect_xg(&reverb->chorus_status_xg);
|
|
}
|
|
break;
|
|
case 0x2E: /* Send Chorus To Reverb */
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Send Chorus To Reverb (%d)", val);
|
|
if (reverb->chorus_status_xg.send_reverb != val) {
|
|
reverb->chorus_status_xg.send_reverb = val;
|
|
reverb->recompute_effect_xg(&reverb->chorus_status_xg);
|
|
}
|
|
break;
|
|
case 0x30: /* Chorus Parameter 11 - 16 */
|
|
case 0x31:
|
|
case 0x32:
|
|
case 0x33:
|
|
case 0x34:
|
|
case 0x35:
|
|
temp = b - 0x30 + 10;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Parameter %d (%d)", temp + 1, val);
|
|
if (reverb->chorus_status_xg.param_lsb[temp] != val) {
|
|
reverb->chorus_status_xg.param_lsb[temp] = val;
|
|
reverb->recompute_effect_xg(&reverb->chorus_status_xg);
|
|
}
|
|
break;
|
|
case 0x40: /* Variation Type MSB */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
if (reverb->variation_effect_xg[note].type_msb != val) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Variation Type MSB (%02X)", val);
|
|
reverb->variation_effect_xg[note].type_msb = val;
|
|
reverb->realloc_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x41: /* Variation Type LSB */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
if (reverb->variation_effect_xg[note].type_lsb != val) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Variation Type LSB (%02X)", val);
|
|
reverb->variation_effect_xg[note].type_lsb = val;
|
|
reverb->realloc_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x42: /* Variation Parameter 1 - 10 MSB */
|
|
case 0x44:
|
|
case 0x46:
|
|
case 0x48:
|
|
case 0x4A:
|
|
case 0x4C:
|
|
case 0x4E:
|
|
case 0x50:
|
|
case 0x52:
|
|
case 0x54:
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
temp = (b - 0x42) / 2;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Variation Parameter %d MSB (%d)", temp, val);
|
|
if (reverb->variation_effect_xg[note].param_msb[temp] != val) {
|
|
reverb->variation_effect_xg[note].param_msb[temp] = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x43: /* Variation Parameter 1 - 10 LSB */
|
|
case 0x45:
|
|
case 0x47:
|
|
case 0x49:
|
|
case 0x4B:
|
|
case 0x4D:
|
|
case 0x4F:
|
|
case 0x51:
|
|
case 0x53:
|
|
case 0x55:
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
temp = (b - 0x43) / 2;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Variation Parameter %d LSB (%d)", temp, val);
|
|
if (reverb->variation_effect_xg[note].param_lsb[temp] != val) {
|
|
reverb->variation_effect_xg[note].param_lsb[temp] = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x56: /* Variation Return */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Variation Return (%d)", val);
|
|
if (reverb->variation_effect_xg[note].ret != val) {
|
|
reverb->variation_effect_xg[note].ret = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x57: /* Variation Pan */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Variation Pan (%d)", val);
|
|
if (reverb->variation_effect_xg[note].pan != val) {
|
|
reverb->variation_effect_xg[note].pan = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x58: /* Send Variation To Reverb */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Send Variation To Reverb (%d)", val);
|
|
if (reverb->variation_effect_xg[note].send_reverb != val) {
|
|
reverb->variation_effect_xg[note].send_reverb = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x59: /* Send Variation To Chorus */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Send Variation To Chorus (%d)", val);
|
|
if (reverb->variation_effect_xg[note].send_chorus != val) {
|
|
reverb->variation_effect_xg[note].send_chorus = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x5A: /* Variation Connection */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Variation Connection (%d)", val);
|
|
if (reverb->variation_effect_xg[note].connection != val) {
|
|
reverb->variation_effect_xg[note].connection = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x5B: /* Variation Part */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Variation Part (%d)", val);
|
|
if (reverb->variation_effect_xg[note].part != val) {
|
|
reverb->variation_effect_xg[note].part = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x5C: /* MW Variation Control Depth */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"MW Variation Control Depth (%d)", val);
|
|
if (reverb->variation_effect_xg[note].mw_depth != val) {
|
|
reverb->variation_effect_xg[note].mw_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x5D: /* BEND Variation Control Depth */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"BEND Variation Control Depth (%d)", val);
|
|
if (reverb->variation_effect_xg[note].bend_depth != val) {
|
|
reverb->variation_effect_xg[note].bend_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x5E: /* CAT Variation Control Depth */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CAT Variation Control Depth (%d)", val);
|
|
if (reverb->variation_effect_xg[note].cat_depth != val) {
|
|
reverb->variation_effect_xg[note].cat_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x5F: /* AC1 Variation Control Depth */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"AC1 Variation Control Depth (%d)", val);
|
|
if (reverb->variation_effect_xg[note].ac1_depth != val) {
|
|
reverb->variation_effect_xg[note].ac1_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x60: /* AC2 Variation Control Depth */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"AC2 Variation Control Depth (%d)", val);
|
|
if (reverb->variation_effect_xg[note].ac2_depth != val) {
|
|
reverb->variation_effect_xg[note].ac2_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x61: /* CBC1 Variation Control Depth */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CBC1 Variation Control Depth (%d)", val);
|
|
if (reverb->variation_effect_xg[note].cbc1_depth != val) {
|
|
reverb->variation_effect_xg[note].cbc1_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x62: /* CBC2 Variation Control Depth */
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"CBC2 Variation Control Depth (%d)", val);
|
|
if (reverb->variation_effect_xg[note].cbc2_depth != val) {
|
|
reverb->variation_effect_xg[note].cbc2_depth = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
case 0x70: /* Variation Parameter 11 - 16 */
|
|
case 0x71:
|
|
case 0x72:
|
|
case 0x73:
|
|
case 0x74:
|
|
case 0x75:
|
|
temp = b - 0x70 + 10;
|
|
if (note >= XG_VARIATION_EFFECT_NUM || note < 0) {break;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Variation Parameter %d (%d)", temp + 1, val);
|
|
if (reverb->variation_effect_xg[note].param_lsb[temp] != val) {
|
|
reverb->variation_effect_xg[note].param_lsb[temp] = val;
|
|
reverb->recompute_effect_xg(&reverb->variation_effect_xg[note]);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} else if (note == 2 && msb == 40) { /* Multi EQ */
|
|
switch(b)
|
|
{
|
|
case 0x00: /* EQ type */
|
|
if(opt_eq_control) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ type (%d)", val);
|
|
reverb->multi_eq_xg.type = val;
|
|
reverb->set_multi_eq_type_xg(val);
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x01: /* EQ gain1 */
|
|
if(opt_eq_control) {
|
|
if(val > 0x4C) {val = 0x4C;}
|
|
else if(val < 0x34) {val = 0x34;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ gain1 (%d dB)", val - 0x40);
|
|
reverb->multi_eq_xg.gain1 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x02: /* EQ frequency1 */
|
|
if(opt_eq_control) {
|
|
if(val > 60) {val = 60;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ frequency1 (%d Hz)", (int32_t)eq_freq_table_xg[val]);
|
|
reverb->multi_eq_xg.freq1 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x03: /* EQ Q1 */
|
|
if(opt_eq_control) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ Q1 (%f)", (double)val / 10.0);
|
|
reverb->multi_eq_xg.q1 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x04: /* EQ shape1 */
|
|
if(opt_eq_control) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ shape1 (%d)", val);
|
|
reverb->multi_eq_xg.shape1 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x05: /* EQ gain2 */
|
|
if(opt_eq_control) {
|
|
if(val > 0x4C) {val = 0x4C;}
|
|
else if(val < 0x34) {val = 0x34;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ gain2 (%d dB)", val - 0x40);
|
|
reverb->multi_eq_xg.gain2 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x06: /* EQ frequency2 */
|
|
if(opt_eq_control) {
|
|
if(val > 60) {val = 60;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ frequency2 (%d Hz)", (int32_t)eq_freq_table_xg[val]);
|
|
reverb->multi_eq_xg.freq2 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x07: /* EQ Q2 */
|
|
if(opt_eq_control) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ Q2 (%f)", (double)val / 10.0);
|
|
reverb->multi_eq_xg.q2 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x09: /* EQ gain3 */
|
|
if(opt_eq_control) {
|
|
if(val > 0x4C) {val = 0x4C;}
|
|
else if(val < 0x34) {val = 0x34;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ gain3 (%d dB)", val - 0x40);
|
|
reverb->multi_eq_xg.gain3 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x0A: /* EQ frequency3 */
|
|
if(opt_eq_control) {
|
|
if(val > 60) {val = 60;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ frequency3 (%d Hz)", (int32_t)eq_freq_table_xg[val]);
|
|
reverb->multi_eq_xg.freq3 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x0B: /* EQ Q3 */
|
|
if(opt_eq_control) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ Q3 (%f)", (double)val / 10.0);
|
|
reverb->multi_eq_xg.q3 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x0D: /* EQ gain4 */
|
|
if(opt_eq_control) {
|
|
if(val > 0x4C) {val = 0x4C;}
|
|
else if(val < 0x34) {val = 0x34;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ gain4 (%d dB)", val - 0x40);
|
|
reverb->multi_eq_xg.gain4 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x0E: /* EQ frequency4 */
|
|
if(opt_eq_control) {
|
|
if(val > 60) {val = 60;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ frequency4 (%d Hz)", (int32_t)eq_freq_table_xg[val]);
|
|
reverb->multi_eq_xg.freq4 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x0F: /* EQ Q4 */
|
|
if(opt_eq_control) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ Q4 (%f)", (double)val / 10.0);
|
|
reverb->multi_eq_xg.q4 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x11: /* EQ gain5 */
|
|
if(opt_eq_control) {
|
|
if(val > 0x4C) {val = 0x4C;}
|
|
else if(val < 0x34) {val = 0x34;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ gain5 (%d dB)", val - 0x40);
|
|
reverb->multi_eq_xg.gain5 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x12: /* EQ frequency5 */
|
|
if(opt_eq_control) {
|
|
if(val > 60) {val = 60;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ frequency5 (%d Hz)", (int32_t)eq_freq_table_xg[val]);
|
|
reverb->multi_eq_xg.freq5 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x13: /* EQ Q5 */
|
|
if(opt_eq_control) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ Q5 (%f)", (double)val / 10.0);
|
|
reverb->multi_eq_xg.q5 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
case 0x14: /* EQ shape5 */
|
|
if(opt_eq_control) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ shape5 (%d)", val);
|
|
reverb->multi_eq_xg.shape5 = val;
|
|
reverb->recompute_multi_eq_xg();
|
|
}
|
|
break;
|
|
}
|
|
} else if (note == 8 && msb == 0) { /* Multi Part */
|
|
switch(b)
|
|
{
|
|
case 0x99: /* Rcv CHANNEL, remapped from 0x04 */
|
|
reset_controllers(ch);
|
|
all_notes_off(ch);
|
|
if (val == 0x7f)
|
|
remove_channel_layer(ch);
|
|
else {
|
|
if((ch < REDUCE_CHANNELS) != (val < REDUCE_CHANNELS)) {
|
|
channel[ch].port_select = ch < REDUCE_CHANNELS ? 1 : 0;
|
|
}
|
|
if((ch % REDUCE_CHANNELS) != (val % REDUCE_CHANNELS)) {
|
|
add_channel_layer(ch, val);
|
|
}
|
|
}
|
|
break;
|
|
case 0x06: /* Same Note Number Key On Assign */
|
|
if(val == 0) {
|
|
channel[ch].assign_mode = 0;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Same Note Number Key On Assign: Single (CH:%d)",ch);
|
|
} else if(val == 1) {
|
|
channel[ch].assign_mode = 2;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Same Note Number Key On Assign: Multi (CH:%d)",ch);
|
|
} else if(val == 2) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Same Note Number Key On Assign: Inst is not supported. (CH:%d)",ch);
|
|
}
|
|
break;
|
|
case 0x11: /* Dry Level */
|
|
channel[ch].dry_level = val;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Dry Level (CH:%d VAL:%d)", ch, val);
|
|
break;
|
|
}
|
|
} else if ((note & 0xF0) == 0x30) { /* Drum Setup */
|
|
note = msb;
|
|
switch(b)
|
|
{
|
|
case 0x0E: /* EG Decay1 */
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Drum Instrument EG Decay1 (CH:%d NOTE:%d VAL:%d)", ch, note, val);
|
|
channel[ch].drums[note]->drum_envelope_rate[EG_DECAY1] = val;
|
|
break;
|
|
case 0x0F: /* EG Decay2 */
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Drum Instrument EG Decay2 (CH:%d NOTE:%d VAL:%d)", ch, note, val);
|
|
channel[ch].drums[note]->drum_envelope_rate[EG_DECAY2] = val;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*! convert GS NRPN to vibrato rate ratio. */
|
|
/* from 0 to 3.0. */
|
|
double Player::gs_cnv_vib_rate(int rate)
|
|
{
|
|
double ratio;
|
|
|
|
if(rate == 0) {
|
|
ratio = 1.6 / 100.0;
|
|
} else if(rate == 64) {
|
|
ratio = 1.0;
|
|
} else if(rate <= 100) {
|
|
ratio = (double)rate * 1.6 / 100.0;
|
|
} else {
|
|
ratio = (double)(rate - 101) * 1.33 / 26.0 + 1.67;
|
|
}
|
|
return (1.0 / ratio);
|
|
}
|
|
|
|
/*! convert GS NRPN to vibrato depth. */
|
|
/* from -9.6 cents to +9.45 cents. */
|
|
int32_t Player::gs_cnv_vib_depth(int depth)
|
|
{
|
|
double cent;
|
|
cent = (double)(depth - 64) * 0.15;
|
|
|
|
return (int32_t)(cent * 256.0 / 400.0);
|
|
}
|
|
|
|
/*! convert GS NRPN to vibrato delay. */
|
|
/* from 0 ms to 5074 ms. */
|
|
int32_t Player::gs_cnv_vib_delay(int delay)
|
|
{
|
|
double ms;
|
|
ms = 0.2092 * exp(0.0795 * (double)delay);
|
|
if(delay == 0) {ms = 0;}
|
|
return (int32_t)((double)playback_rate * ms * 0.001);
|
|
}
|
|
|
|
int Player::last_rpn_addr(int ch)
|
|
{
|
|
int lsb, msb, addr, i;
|
|
const struct rpn_tag_map_t *addrmap;
|
|
struct rpn_tag_map_t {
|
|
int addr, mask, tag;
|
|
};
|
|
static const struct rpn_tag_map_t nrpn_addr_map[] = {
|
|
{0x0108, 0xffff, NRPN_ADDR_0108},
|
|
{0x0109, 0xffff, NRPN_ADDR_0109},
|
|
{0x010a, 0xffff, NRPN_ADDR_010A},
|
|
{0x0120, 0xffff, NRPN_ADDR_0120},
|
|
{0x0121, 0xffff, NRPN_ADDR_0121},
|
|
{0x0130, 0xffff, NRPN_ADDR_0130},
|
|
{0x0131, 0xffff, NRPN_ADDR_0131},
|
|
{0x0134, 0xffff, NRPN_ADDR_0134},
|
|
{0x0135, 0xffff, NRPN_ADDR_0135},
|
|
{0x0163, 0xffff, NRPN_ADDR_0163},
|
|
{0x0164, 0xffff, NRPN_ADDR_0164},
|
|
{0x0166, 0xffff, NRPN_ADDR_0166},
|
|
{0x1400, 0xff00, NRPN_ADDR_1400},
|
|
{0x1500, 0xff00, NRPN_ADDR_1500},
|
|
{0x1600, 0xff00, NRPN_ADDR_1600},
|
|
{0x1700, 0xff00, NRPN_ADDR_1700},
|
|
{0x1800, 0xff00, NRPN_ADDR_1800},
|
|
{0x1900, 0xff00, NRPN_ADDR_1900},
|
|
{0x1a00, 0xff00, NRPN_ADDR_1A00},
|
|
{0x1c00, 0xff00, NRPN_ADDR_1C00},
|
|
{0x1d00, 0xff00, NRPN_ADDR_1D00},
|
|
{0x1e00, 0xff00, NRPN_ADDR_1E00},
|
|
{0x1f00, 0xff00, NRPN_ADDR_1F00},
|
|
{0x3000, 0xff00, NRPN_ADDR_3000},
|
|
{0x3100, 0xff00, NRPN_ADDR_3100},
|
|
{0x3400, 0xff00, NRPN_ADDR_3400},
|
|
{0x3500, 0xff00, NRPN_ADDR_3500},
|
|
{-1, -1, 0}
|
|
};
|
|
static const struct rpn_tag_map_t rpn_addr_map[] = {
|
|
{0x0000, 0xffff, RPN_ADDR_0000},
|
|
{0x0001, 0xffff, RPN_ADDR_0001},
|
|
{0x0002, 0xffff, RPN_ADDR_0002},
|
|
{0x0003, 0xffff, RPN_ADDR_0003},
|
|
{0x0004, 0xffff, RPN_ADDR_0004},
|
|
{0x0005, 0xffff, RPN_ADDR_0005},
|
|
{0x7f7f, 0xffff, RPN_ADDR_7F7F},
|
|
{0xffff, 0xffff, RPN_ADDR_FFFF},
|
|
{-1, -1}
|
|
};
|
|
|
|
if (channel[ch].nrpn == -1)
|
|
return -1;
|
|
lsb = channel[ch].lastlrpn;
|
|
msb = channel[ch].lastmrpn;
|
|
if (lsb == 0xff || msb == 0xff)
|
|
return -1;
|
|
addr = (msb << 8 | lsb);
|
|
if (channel[ch].nrpn)
|
|
addrmap = nrpn_addr_map;
|
|
else
|
|
addrmap = rpn_addr_map;
|
|
for (i = 0; addrmap[i].addr != -1; i++)
|
|
if (addrmap[i].addr == (addr & addrmap[i].mask))
|
|
return addrmap[i].tag;
|
|
return -1;
|
|
}
|
|
|
|
void Player::update_rpn_map(int ch, int addr, int update_now)
|
|
{
|
|
int val, drumflag, i, note;
|
|
|
|
val = channel[ch].rpnmap[addr];
|
|
drumflag = 0;
|
|
switch (addr) {
|
|
case NRPN_ADDR_0108: /* Vibrato Rate */
|
|
if (op_nrpn_vibrato) {
|
|
//printMessage(CMSG_INFO, VERB_NOISY, "Vibrato Rate (CH:%d VAL:%d)", ch, val - 64);
|
|
channel[ch].vibrato_ratio = gs_cnv_vib_rate(val);
|
|
}
|
|
if (update_now)
|
|
adjust_pitch(ch);
|
|
break;
|
|
case NRPN_ADDR_0109: /* Vibrato Depth */
|
|
if (op_nrpn_vibrato) {
|
|
//printMessage(CMSG_INFO, VERB_NOISY, "Vibrato Depth (CH:%d VAL:%d)", ch, val - 64);
|
|
channel[ch].vibrato_depth = gs_cnv_vib_depth(val);
|
|
}
|
|
if (update_now)
|
|
adjust_pitch(ch);
|
|
break;
|
|
case NRPN_ADDR_010A: /* Vibrato Delay */
|
|
if (op_nrpn_vibrato) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Vibrato Delay (CH:%d VAL:%d)", ch, val);
|
|
channel[ch].vibrato_delay = gs_cnv_vib_delay(val);
|
|
}
|
|
if (update_now)
|
|
adjust_pitch(ch);
|
|
break;
|
|
case NRPN_ADDR_0120: /* Filter Cutoff Frequency */
|
|
if (timidity_lpf_def) {
|
|
//printMessage(CMSG_INFO, VERB_NOISY, "Filter Cutoff (CH:%d VAL:%d)", ch, val - 64);
|
|
channel[ch].param_cutoff_freq = val - 64;
|
|
}
|
|
break;
|
|
case NRPN_ADDR_0121: /* Filter Resonance */
|
|
if (timidity_lpf_def) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Filter Resonance (CH:%d VAL:%d)", ch, val - 64);
|
|
channel[ch].param_resonance = val - 64;
|
|
}
|
|
break;
|
|
case NRPN_ADDR_0130: /* EQ BASS */
|
|
if (opt_eq_control) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ BASS (CH:%d %.2f dB)", ch, 0.19 * (double)(val - 0x40));
|
|
channel[ch].eq_xg.bass = val;
|
|
recompute_part_eq_xg(&(channel[ch].eq_xg));
|
|
}
|
|
break;
|
|
case NRPN_ADDR_0131: /* EQ TREBLE */
|
|
if (opt_eq_control) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ TREBLE (CH:%d %.2f dB)", ch, 0.19 * (double)(val - 0x40));
|
|
channel[ch].eq_xg.treble = val;
|
|
recompute_part_eq_xg(&(channel[ch].eq_xg));
|
|
}
|
|
break;
|
|
case NRPN_ADDR_0134: /* EQ BASS frequency */
|
|
if (opt_eq_control) {
|
|
if(val < 4) {val = 4;}
|
|
else if(val > 40) {val = 40;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ BASS frequency (CH:%d %d Hz)", ch, (int32_t)eq_freq_table_xg[val]);
|
|
channel[ch].eq_xg.bass_freq = val;
|
|
recompute_part_eq_xg(&(channel[ch].eq_xg));
|
|
}
|
|
break;
|
|
case NRPN_ADDR_0135: /* EQ TREBLE frequency */
|
|
if (opt_eq_control) {
|
|
if(val < 28) {val = 28;}
|
|
else if(val > 58) {val = 58;}
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"EQ TREBLE frequency (CH:%d %d Hz)", ch, (int32_t)eq_freq_table_xg[val]);
|
|
channel[ch].eq_xg.treble_freq = val;
|
|
recompute_part_eq_xg(&(channel[ch].eq_xg));
|
|
}
|
|
break;
|
|
case NRPN_ADDR_0163: /* Attack Time */
|
|
if (opt_tva_attack) {set_envelope_time(ch, val, EG_ATTACK);}
|
|
break;
|
|
case NRPN_ADDR_0164: /* EG Decay Time */
|
|
if (opt_tva_decay) {set_envelope_time(ch, val, EG_DECAY);}
|
|
break;
|
|
case NRPN_ADDR_0166: /* EG Release Time */
|
|
if (opt_tva_release) {set_envelope_time(ch, val, EG_RELEASE);}
|
|
break;
|
|
case NRPN_ADDR_1400: /* Drum Filter Cutoff (XG) */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Drum Instrument Filter Cutoff (CH:%d NOTE:%d VAL:%d)", ch, note, val);
|
|
channel[ch].drums[note]->drum_cutoff_freq = val - 64;
|
|
break;
|
|
case NRPN_ADDR_1500: /* Drum Filter Resonance (XG) */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Drum Instrument Filter Resonance (CH:%d NOTE:%d VAL:%d)", ch, note, val);
|
|
channel[ch].drums[note]->drum_resonance = val - 64;
|
|
break;
|
|
case NRPN_ADDR_1600: /* Drum EG Attack Time (XG) */
|
|
drumflag = 1;
|
|
if (opt_tva_attack) {
|
|
val = val & 0x7f;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
val -= 64;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Drum Instrument Attack Time (CH:%d NOTE:%d VAL:%d)", ch, note, val);
|
|
channel[ch].drums[note]->drum_envelope_rate[EG_ATTACK] = val;
|
|
}
|
|
break;
|
|
case NRPN_ADDR_1700: /* Drum EG Decay Time (XG) */
|
|
drumflag = 1;
|
|
if (opt_tva_decay) {
|
|
val = val & 0x7f;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
val -= 64;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Drum Instrument Decay Time (CH:%d NOTE:%d VAL:%d)", ch, note, val);
|
|
channel[ch].drums[note]->drum_envelope_rate[EG_DECAY1] =
|
|
channel[ch].drums[note]->drum_envelope_rate[EG_DECAY2] = val;
|
|
}
|
|
break;
|
|
case NRPN_ADDR_1800: /* Coarse Pitch of Drum (GS) */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
channel[ch].drums[note]->coarse = val - 64;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Drum Instrument Pitch Coarse (CH:%d NOTE:%d VAL:%d)", ch, note, channel[ch].drums[note]->coarse);
|
|
channel[ch].pitchfactor = 0;
|
|
break;
|
|
case NRPN_ADDR_1900: /* Fine Pitch of Drum (XG) */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
channel[ch].drums[note]->fine = val - 64;
|
|
printMessage(CMSG_INFO, VERB_NOISY, "Drum Instrument Pitch Fine (CH:%d NOTE:%d VAL:%d)", ch, note, channel[ch].drums[note]->fine);
|
|
channel[ch].pitchfactor = 0;
|
|
break;
|
|
case NRPN_ADDR_1A00: /* Level of Drum */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Drum Instrument TVA Level (CH:%d NOTE:%d VAL:%d)", ch, note, val);
|
|
channel[ch].drums[note]->drum_level =
|
|
calc_drum_tva_level(ch, note, val);
|
|
break;
|
|
case NRPN_ADDR_1C00: /* Panpot of Drum */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
if(val == 0) {
|
|
val = int_rand(128);
|
|
channel[ch].drums[note]->pan_random = 1;
|
|
} else
|
|
channel[ch].drums[note]->pan_random = 0;
|
|
channel[ch].drums[note]->drum_panning = val;
|
|
if (update_now && adjust_panning_immediately && ! channel[ch].pan_random)
|
|
adjust_drum_panning(ch, note);
|
|
break;
|
|
case NRPN_ADDR_1D00: /* Reverb Send Level of Drum */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
printMessage(CMSG_INFO, VERB_NOISY, "Reverb Send Level of Drum (CH:%d NOTE:%d VALUE:%d)", ch, note, val);
|
|
if (channel[ch].drums[note]->reverb_level != val) {
|
|
channel[ch].drum_effect_flag = 0;
|
|
}
|
|
channel[ch].drums[note]->reverb_level = val;
|
|
break;
|
|
case NRPN_ADDR_1E00: /* Chorus Send Level of Drum */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
printMessage(CMSG_INFO, VERB_NOISY, "Chorus Send Level of Drum (CH:%d NOTE:%d VALUE:%d)", ch, note, val);
|
|
if (channel[ch].drums[note]->chorus_level != val) {
|
|
channel[ch].drum_effect_flag = 0;
|
|
}
|
|
channel[ch].drums[note]->chorus_level = val;
|
|
|
|
break;
|
|
case NRPN_ADDR_1F00: /* Variation Send Level of Drum */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Send Level of Drum (CH:%d NOTE:%d VALUE:%d)", ch, note, val);
|
|
if (channel[ch].drums[note]->delay_level != val) {
|
|
channel[ch].drum_effect_flag = 0;
|
|
}
|
|
channel[ch].drums[note]->delay_level = val;
|
|
break;
|
|
case NRPN_ADDR_3000: /* Drum EQ BASS */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
break;
|
|
case NRPN_ADDR_3100: /* Drum EQ TREBLE */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
break;
|
|
case NRPN_ADDR_3400: /* Drum EQ BASS frequency */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
break;
|
|
case NRPN_ADDR_3500: /* Drum EQ TREBLE frequency */
|
|
drumflag = 1;
|
|
note = channel[ch].lastlrpn;
|
|
if (channel[ch].drums[note] == NULL)
|
|
play_midi_setup_drums(ch, note);
|
|
break;
|
|
case RPN_ADDR_0000: /* Pitch bend sensitivity */
|
|
printMessage(CMSG_INFO, VERB_DEBUG, "Pitch Bend Sensitivity (CH:%d VALUE:%d)", ch, val);
|
|
/* for mod2mid.c, arpeggio */
|
|
if (channel[ch].rpnmap[RPN_ADDR_0000] > 24)
|
|
channel[ch].rpnmap[RPN_ADDR_0000] = 24;
|
|
channel[ch].pitchfactor = 0;
|
|
break;
|
|
case RPN_ADDR_0001: /* Master Fine Tuning */
|
|
printMessage(CMSG_INFO, VERB_DEBUG, "Master Fine Tuning (CH:%d VALUE:%d)", ch, val);
|
|
channel[ch].pitchfactor = 0;
|
|
break;
|
|
case RPN_ADDR_0002: /* Master Coarse Tuning */
|
|
printMessage(CMSG_INFO, VERB_DEBUG, "Master Coarse Tuning (CH:%d VALUE:%d)", ch, val);
|
|
channel[ch].pitchfactor = 0;
|
|
break;
|
|
case RPN_ADDR_0003: /* Tuning Program Select */
|
|
printMessage(CMSG_INFO, VERB_DEBUG, "Tuning Program Select (CH:%d VALUE:%d)", ch, val);
|
|
for (i = 0; i < upper_voices; i++)
|
|
if (voice[i].status != VOICE_FREE) {
|
|
voice[i].temper_instant = 1;
|
|
recompute_freq(i);
|
|
}
|
|
break;
|
|
case RPN_ADDR_0004: /* Tuning Bank Select */
|
|
printMessage(CMSG_INFO, VERB_DEBUG, "Tuning Bank Select (CH:%d VALUE:%d)", ch, val);
|
|
for (i = 0; i < upper_voices; i++)
|
|
if (voice[i].status != VOICE_FREE) {
|
|
voice[i].temper_instant = 1;
|
|
recompute_freq(i);
|
|
}
|
|
break;
|
|
case RPN_ADDR_0005: /* GM2: Modulation Depth Range */
|
|
channel[ch].mod.lfo1_pitch_depth = (((int32_t)channel[ch].rpnmap[RPN_ADDR_0005] << 7) | channel[ch].rpnmap_lsb[RPN_ADDR_0005]) * 100 / 128;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Modulation Depth Range (CH:%d VALUE:%d)", ch, channel[ch].rpnmap[RPN_ADDR_0005]);
|
|
break;
|
|
case RPN_ADDR_7F7F: /* RPN reset */
|
|
channel[ch].rpn_7f7f_flag = 1;
|
|
break;
|
|
case RPN_ADDR_FFFF: /* RPN initialize */
|
|
/* All reset to defaults */
|
|
channel[ch].rpn_7f7f_flag = 0;
|
|
memset(channel[ch].rpnmap, 0, sizeof(channel[ch].rpnmap));
|
|
channel[ch].lastlrpn = channel[ch].lastmrpn = 0;
|
|
channel[ch].nrpn = 0;
|
|
channel[ch].rpnmap[RPN_ADDR_0000] = 2;
|
|
channel[ch].rpnmap[RPN_ADDR_0001] = 0x40;
|
|
channel[ch].rpnmap[RPN_ADDR_0002] = 0x40;
|
|
channel[ch].rpnmap_lsb[RPN_ADDR_0005] = 0x40;
|
|
channel[ch].rpnmap[RPN_ADDR_0005] = 0; /* +- 50 cents */
|
|
channel[ch].pitchfactor = 0;
|
|
break;
|
|
}
|
|
drumflag = 0;
|
|
if (drumflag && midi_drumpart_change(ch, 1)) {
|
|
midi_program_change(ch, channel[ch].program);
|
|
}
|
|
}
|
|
|
|
void Player::voice_increment(int n)
|
|
{
|
|
int i;
|
|
for(i = 0; i < n; i++)
|
|
{
|
|
if(voices == max_voices)
|
|
break;
|
|
voice[voices].status = VOICE_FREE;
|
|
voice[voices].temper_instant = 0;
|
|
voice[voices].chorus_link = voices;
|
|
voices++;
|
|
}
|
|
}
|
|
|
|
void Player::voice_decrement(int n)
|
|
{
|
|
int i, j, lowest;
|
|
int32_t lv, v;
|
|
|
|
/* decrease voice */
|
|
for(i = 0; i < n && voices > 0; i++)
|
|
{
|
|
voices--;
|
|
if(voice[voices].status == VOICE_FREE)
|
|
continue; /* found */
|
|
|
|
for(j = 0; j < voices; j++)
|
|
if(voice[j].status == VOICE_FREE)
|
|
break;
|
|
if(j != voices)
|
|
{
|
|
voice[j] = voice[voices];
|
|
continue; /* found */
|
|
}
|
|
|
|
/* Look for the decaying note with the lowest volume */
|
|
lv = 0x7FFFFFFF;
|
|
lowest = -1;
|
|
for(j = 0; j <= voices; j++)
|
|
{
|
|
if(voice[j].status & ~(VOICE_ON | VOICE_DIE))
|
|
{
|
|
v = voice[j].left_mix;
|
|
if((voice[j].panned==PANNED_MYSTERY) &&
|
|
(voice[j].right_mix > v))
|
|
v = voice[j].right_mix;
|
|
if(v < lv)
|
|
{
|
|
lv = v;
|
|
lowest = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(lowest != -1)
|
|
{
|
|
cut_notes++;
|
|
free_voice(lowest);
|
|
voice[lowest] = voice[voices];
|
|
}
|
|
else
|
|
lost_notes++;
|
|
}
|
|
if(upper_voices > voices)
|
|
upper_voices = voices;
|
|
}
|
|
|
|
/* EAW -- do not throw away good notes, stop decrementing */
|
|
void Player::voice_decrement_conservative(int n)
|
|
{
|
|
int i, j, lowest, finalnv;
|
|
int32_t lv, v;
|
|
|
|
/* decrease voice */
|
|
finalnv = voices - n;
|
|
for(i = 1; i <= n && voices > 0; i++)
|
|
{
|
|
if(voice[voices-1].status == VOICE_FREE) {
|
|
voices--;
|
|
continue; /* found */
|
|
}
|
|
|
|
for(j = 0; j < finalnv; j++)
|
|
if(voice[j].status == VOICE_FREE)
|
|
break;
|
|
if(j != finalnv)
|
|
{
|
|
voice[j] = voice[voices-1];
|
|
voices--;
|
|
continue; /* found */
|
|
}
|
|
|
|
/* Look for the decaying note with the lowest volume */
|
|
lv = 0x7FFFFFFF;
|
|
lowest = -1;
|
|
for(j = 0; j < voices; j++)
|
|
{
|
|
if(voice[j].status & ~(VOICE_ON | VOICE_DIE) &&
|
|
!(voice[j].sample->note_to_use &&
|
|
ISDRUMCHANNEL(voice[j].channel)))
|
|
{
|
|
v = voice[j].left_mix;
|
|
if((voice[j].panned==PANNED_MYSTERY) &&
|
|
(voice[j].right_mix > v))
|
|
v = voice[j].right_mix;
|
|
if(v < lv)
|
|
{
|
|
lv = v;
|
|
lowest = j;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(lowest != -1)
|
|
{
|
|
voices--;
|
|
cut_notes++;
|
|
free_voice(lowest);
|
|
voice[lowest] = voice[voices];
|
|
}
|
|
else break;
|
|
}
|
|
if(upper_voices > voices)
|
|
upper_voices = voices;
|
|
}
|
|
|
|
void Player::mix_signal(int32_t *dest, int32_t *src, int32_t count)
|
|
{
|
|
int32_t i;
|
|
for (i = 0; i < count; i++) {
|
|
dest[i] += src[i];
|
|
}
|
|
}
|
|
|
|
int Player::is_insertion_effect_xg(int ch)
|
|
{
|
|
int i;
|
|
for (i = 0; i < XG_INSERTION_EFFECT_NUM; i++) {
|
|
if (reverb->insertion_effect_xg[i].part == ch) {
|
|
return 1;
|
|
}
|
|
}
|
|
for (i = 0; i < XG_VARIATION_EFFECT_NUM; i++) {
|
|
if (reverb->variation_effect_xg[i].connection == XG_CONN_INSERTION
|
|
&& reverb->variation_effect_xg[i].part == ch) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* do_compute_data_midi() with DSP Effect */
|
|
void Player::do_compute_data(int32_t count)
|
|
{
|
|
int i, j, uv, stereo, n, ch, note;
|
|
int32_t *vpblist[MAX_CHANNELS];
|
|
int channel_effect, channel_reverb, channel_chorus, channel_delay, channel_eq;
|
|
int32_t cnt = count * 2, rev_max_delay_out;
|
|
struct DrumPartEffect *de;
|
|
|
|
stereo = true;
|
|
n = count * ((stereo) ? 8 : 4); /* in bytes */
|
|
|
|
memset(buffer_pointer, 0, n);
|
|
memset(insertion_effect_buffer, 0, n);
|
|
|
|
if (timidity_reverb == 3) {
|
|
rev_max_delay_out = 0x7fffffff; /* disable */
|
|
} else {
|
|
rev_max_delay_out = REVERB_MAX_DELAY_OUT;
|
|
}
|
|
|
|
/* are effects valid? / don't supported in mono */
|
|
channel_reverb = (stereo && (timidity_reverb == 1
|
|
|| timidity_reverb == 3
|
|
|| (timidity_reverb < 0 && timidity_reverb & 0x80)));
|
|
channel_chorus = (stereo && timidity_chorus && !timidity_surround_chorus);
|
|
channel_delay = 0;
|
|
|
|
/* is EQ valid? */
|
|
channel_eq = 0;
|
|
|
|
channel_effect = (stereo && (channel_reverb || channel_chorus
|
|
|| channel_delay || channel_eq || opt_insertion_effect));
|
|
|
|
uv = upper_voices;
|
|
for(i = 0; i < uv; i++) {
|
|
if(voice[i].status != VOICE_FREE) {
|
|
channel[voice[i].channel].lasttime = current_sample + count;
|
|
}
|
|
}
|
|
|
|
/* appropriate buffers for channels */
|
|
if(channel_effect) {
|
|
int buf_index = 0;
|
|
|
|
if(reverb_buffer == NULL) { /* allocating buffer for channel effect */
|
|
reverb_buffer = (char *)safe_malloc(MAX_CHANNELS * AUDIO_BUFFER_SIZE * 8);
|
|
}
|
|
|
|
for(i = 0; i < MAX_CHANNELS; i++) {
|
|
if(opt_insertion_effect && channel[i].insertion_effect) {
|
|
vpblist[i] = insertion_effect_buffer;
|
|
} else if(channel[i].eq_gs || (get_reverb_level(i) != DEFAULT_REVERB_SEND_LEVEL
|
|
&& current_sample - channel[i].lasttime < rev_max_delay_out)
|
|
|| channel[i].chorus_level > 0 || channel[i].delay_level > 0
|
|
|| channel[i].eq_xg.valid
|
|
|| channel[i].dry_level != 127
|
|
|| (timidity_drum_effect && ISDRUMCHANNEL(i))
|
|
|| is_insertion_effect_xg(i)) {
|
|
vpblist[i] = (int32_t*)(reverb_buffer + buf_index);
|
|
buf_index += n;
|
|
} else {
|
|
vpblist[i] = buffer_pointer;
|
|
}
|
|
/* clear buffers of drum-part effect */
|
|
if (timidity_drum_effect && ISDRUMCHANNEL(i)) {
|
|
for (j = 0; j < channel[i].drum_effect_num; j++) {
|
|
if (channel[i].drum_effect[j].buf != NULL) {
|
|
memset(channel[i].drum_effect[j].buf, 0, n);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(buf_index) {memset(reverb_buffer, 0, buf_index);}
|
|
}
|
|
|
|
for (i = 0; i < uv; i++) {
|
|
if (voice[i].status != VOICE_FREE) {
|
|
int32_t *vpb = NULL;
|
|
int8_t flag;
|
|
|
|
if (channel_effect) {
|
|
flag = 0;
|
|
ch = voice[i].channel;
|
|
if (timidity_drum_effect && ISDRUMCHANNEL(ch)) {
|
|
make_drum_effect(ch);
|
|
note = voice[i].note;
|
|
for (j = 0; j < channel[ch].drum_effect_num; j++) {
|
|
if (channel[ch].drum_effect[j].note == note) {
|
|
vpb = channel[ch].drum_effect[j].buf;
|
|
flag = 1;
|
|
}
|
|
}
|
|
if (flag == 0) {vpb = vpblist[ch];}
|
|
} else {
|
|
vpb = vpblist[ch];
|
|
}
|
|
} else {
|
|
vpb = buffer_pointer;
|
|
}
|
|
|
|
if(!IS_SET_CHANNELMASK(channel_mute, voice[i].channel)) {
|
|
mixer->mix_voice(vpb, i, count);
|
|
} else {
|
|
free_voice(i);
|
|
}
|
|
|
|
if(voice[i].timeout == 1 && voice[i].timeout < current_sample) {
|
|
free_voice(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
while(uv > 0 && voice[uv - 1].status == VOICE_FREE) {uv--;}
|
|
upper_voices = uv;
|
|
|
|
if(play_system_mode == XG_SYSTEM_MODE && channel_effect) { /* XG */
|
|
if (opt_insertion_effect) { /* insertion effect */
|
|
for (i = 0; i < XG_INSERTION_EFFECT_NUM; i++) {
|
|
if (reverb->insertion_effect_xg[i].part <= MAX_CHANNELS) {
|
|
reverb->do_insertion_effect_xg(vpblist[reverb->insertion_effect_xg[i].part], cnt, &reverb->insertion_effect_xg[i]);
|
|
}
|
|
}
|
|
for (i = 0; i < XG_VARIATION_EFFECT_NUM; i++) {
|
|
if (reverb->variation_effect_xg[i].part <= MAX_CHANNELS) {
|
|
reverb->do_insertion_effect_xg(vpblist[reverb->variation_effect_xg[i].part], cnt, &reverb->variation_effect_xg[i]);
|
|
}
|
|
}
|
|
}
|
|
for(i = 0; i < MAX_CHANNELS; i++) { /* system effects */
|
|
int32_t *p;
|
|
p = vpblist[i];
|
|
if(p != buffer_pointer) {
|
|
if (timidity_drum_effect && ISDRUMCHANNEL(i)) {
|
|
for (j = 0; j < channel[i].drum_effect_num; j++) {
|
|
de = &(channel[i].drum_effect[j]);
|
|
if (de->reverb_send > 0) {
|
|
reverb->set_ch_reverb(de->buf, cnt, de->reverb_send);
|
|
}
|
|
if (de->chorus_send > 0) {
|
|
reverb->set_ch_chorus(de->buf, cnt, de->chorus_send);
|
|
}
|
|
if (de->delay_send > 0) {
|
|
reverb->set_ch_delay(de->buf, cnt, de->delay_send);
|
|
}
|
|
mix_signal(p, de->buf, cnt);
|
|
}
|
|
} else {
|
|
if(channel_eq && channel[i].eq_xg.valid) {
|
|
reverb->do_ch_eq_xg(p, cnt, &(channel[i].eq_xg));
|
|
}
|
|
if(channel_chorus && channel[i].chorus_level > 0) {
|
|
reverb->set_ch_chorus(p, cnt, channel[i].chorus_level);
|
|
}
|
|
if(channel_delay && channel[i].delay_level > 0) {
|
|
reverb->set_ch_delay(p, cnt, channel[i].delay_level);
|
|
}
|
|
if(channel_reverb && channel[i].reverb_level > 0
|
|
&& current_sample - channel[i].lasttime < rev_max_delay_out) {
|
|
reverb->set_ch_reverb(p, cnt, channel[i].reverb_level);
|
|
}
|
|
}
|
|
if(channel[i].dry_level == 127) {
|
|
reverb->set_dry_signal(p, cnt);
|
|
} else {
|
|
reverb->set_dry_signal_xg(p, cnt, channel[i].dry_level);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(channel_reverb) {
|
|
reverb->set_ch_reverb(buffer_pointer, cnt, DEFAULT_REVERB_SEND_LEVEL);
|
|
}
|
|
reverb->set_dry_signal(buffer_pointer, cnt);
|
|
|
|
/* mixing signal and applying system effects */
|
|
reverb->mix_dry_signal(buffer_pointer, cnt);
|
|
if(channel_delay) { reverb->do_variation_effect1_xg(buffer_pointer, cnt);}
|
|
if(channel_chorus) { reverb->do_ch_chorus_xg(buffer_pointer, cnt);}
|
|
if(channel_reverb) { reverb->do_ch_reverb(buffer_pointer, cnt);}
|
|
if(reverb->multi_eq_xg.valid) { reverb->do_multi_eq_xg(buffer_pointer, cnt);}
|
|
} else if(channel_effect) { /* GM & GS */
|
|
if(opt_insertion_effect) { /* insertion effect */
|
|
/* applying insertion effect */
|
|
reverb->do_insertion_effect_gs(insertion_effect_buffer, cnt);
|
|
/* sending insertion effect voice to channel effect */
|
|
reverb->set_ch_chorus(insertion_effect_buffer, cnt, reverb->insertion_effect_gs.send_chorus);
|
|
reverb->set_ch_delay(insertion_effect_buffer, cnt, reverb->insertion_effect_gs.send_delay);
|
|
reverb->set_ch_reverb(insertion_effect_buffer, cnt, reverb->insertion_effect_gs.send_reverb);
|
|
if(reverb->insertion_effect_gs.send_eq_switch && channel_eq) {
|
|
reverb->set_ch_eq_gs(insertion_effect_buffer, cnt);
|
|
} else {
|
|
reverb->set_dry_signal(insertion_effect_buffer, cnt);
|
|
}
|
|
}
|
|
|
|
for(i = 0; i < MAX_CHANNELS; i++) { /* system effects */
|
|
int32_t *p;
|
|
p = vpblist[i];
|
|
if(p != buffer_pointer && p != insertion_effect_buffer) {
|
|
if (timidity_drum_effect && ISDRUMCHANNEL(i)) {
|
|
for (j = 0; j < channel[i].drum_effect_num; j++) {
|
|
de = &(channel[i].drum_effect[j]);
|
|
if (de->reverb_send > 0) {
|
|
reverb->set_ch_reverb(de->buf, cnt, de->reverb_send);
|
|
}
|
|
if (de->chorus_send > 0) {
|
|
reverb->set_ch_chorus(de->buf, cnt, de->chorus_send);
|
|
}
|
|
if (de->delay_send > 0) {
|
|
reverb->set_ch_delay(de->buf, cnt, de->delay_send);
|
|
}
|
|
mix_signal(p, de->buf, cnt);
|
|
}
|
|
} else {
|
|
if(channel_chorus && channel[i].chorus_level > 0) {
|
|
reverb->set_ch_chorus(p, cnt, channel[i].chorus_level);
|
|
}
|
|
if(channel_delay && channel[i].delay_level > 0) {
|
|
reverb->set_ch_delay(p, cnt, channel[i].delay_level);
|
|
}
|
|
if(channel_reverb && channel[i].reverb_level > 0
|
|
&& current_sample - channel[i].lasttime < rev_max_delay_out) {
|
|
reverb->set_ch_reverb(p, cnt, channel[i].reverb_level);
|
|
}
|
|
}
|
|
if(channel_eq && channel[i].eq_gs) {
|
|
reverb->set_ch_eq_gs(p, cnt);
|
|
} else {
|
|
reverb->set_dry_signal(p, cnt);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(channel_reverb) {
|
|
reverb->set_ch_reverb(buffer_pointer, cnt, DEFAULT_REVERB_SEND_LEVEL);
|
|
}
|
|
reverb->set_dry_signal(buffer_pointer, cnt);
|
|
|
|
/* mixing signal and applying system effects */
|
|
reverb->mix_dry_signal(buffer_pointer, cnt);
|
|
if(channel_eq) { reverb->do_ch_eq_gs(buffer_pointer, cnt);}
|
|
if(channel_chorus) { reverb->do_ch_chorus(buffer_pointer, cnt);}
|
|
if(channel_delay) { reverb->do_ch_delay(buffer_pointer, cnt);}
|
|
if(channel_reverb) { reverb->do_ch_reverb(buffer_pointer, cnt);}
|
|
}
|
|
|
|
current_sample += count;
|
|
}
|
|
|
|
int Player::compute_data(float *buffer, int32_t count)
|
|
{
|
|
if (count == 0) return RC_OK;
|
|
|
|
std::lock_guard<std::mutex> lock(ConfigMutex);
|
|
|
|
if (last_reverb_setting != timidity_reverb)
|
|
{
|
|
// If the reverb mode has changed some buffers need to be reallocated before doing any sound generation.
|
|
reverb->free_effect_buffers();
|
|
reverb->init_reverb();
|
|
last_reverb_setting = timidity_reverb;
|
|
}
|
|
|
|
buffer_pointer = common_buffer;
|
|
computed_samples += count;
|
|
|
|
while (count > 0)
|
|
{
|
|
int process = std::min(count, AUDIO_BUFFER_SIZE);
|
|
do_compute_data(process);
|
|
count -= process;
|
|
|
|
effect->do_effect(common_buffer, process);
|
|
// pass to caller
|
|
for (int i = 0; i < process*2; i++)
|
|
{
|
|
*buffer++ = (common_buffer[i])*(5.f / 0x80000000u);
|
|
}
|
|
}
|
|
return RC_OK;
|
|
}
|
|
|
|
void Player::update_modulation_wheel(int ch)
|
|
{
|
|
int i, uv = upper_voices;
|
|
channel[ch].pitchfactor = 0;
|
|
for(i = 0; i < uv; i++)
|
|
if(voice[i].status != VOICE_FREE && voice[i].channel == ch)
|
|
{
|
|
/* Set/Reset mod-wheel */
|
|
voice[i].vibrato_control_counter = voice[i].vibrato_phase = 0;
|
|
recompute_amp(i);
|
|
mixer->apply_envelope_to_amp(i);
|
|
recompute_freq(i);
|
|
recompute_voice_filter(i);
|
|
}
|
|
}
|
|
|
|
void Player::drop_portamento(int ch)
|
|
{
|
|
int i, uv = upper_voices;
|
|
|
|
channel[ch].porta_control_ratio = 0;
|
|
for(i = 0; i < uv; i++)
|
|
if(voice[i].status != VOICE_FREE &&
|
|
voice[i].channel == ch &&
|
|
voice[i].porta_control_ratio)
|
|
{
|
|
voice[i].porta_control_ratio = 0;
|
|
recompute_freq(i);
|
|
}
|
|
channel[ch].last_note_fine = -1;
|
|
}
|
|
|
|
void Player::update_portamento_controls(int ch)
|
|
{
|
|
if(!channel[ch].portamento ||
|
|
(channel[ch].portamento_time_msb | channel[ch].portamento_time_lsb)
|
|
== 0)
|
|
drop_portamento(ch);
|
|
else
|
|
{
|
|
double mt, dc;
|
|
int d;
|
|
|
|
mt = midi_time_table[channel[ch].portamento_time_msb & 0x7F] *
|
|
midi_time_table2[channel[ch].portamento_time_lsb & 0x7F] *
|
|
PORTAMENTO_TIME_TUNING;
|
|
dc = playback_rate * mt;
|
|
d = (int)(1.0 / (mt * PORTAMENTO_CONTROL_RATIO));
|
|
d++;
|
|
channel[ch].porta_control_ratio = (int)(d * dc + 0.5);
|
|
channel[ch].porta_dpb = d;
|
|
}
|
|
}
|
|
|
|
void Player::update_portamento_time(int ch)
|
|
{
|
|
int i, uv = upper_voices;
|
|
int dpb;
|
|
int32_t ratio;
|
|
|
|
update_portamento_controls(ch);
|
|
dpb = channel[ch].porta_dpb;
|
|
ratio = channel[ch].porta_control_ratio;
|
|
|
|
for(i = 0; i < uv; i++)
|
|
{
|
|
if(voice[i].status != VOICE_FREE &&
|
|
voice[i].channel == ch &&
|
|
voice[i].porta_control_ratio)
|
|
{
|
|
voice[i].porta_control_ratio = ratio;
|
|
voice[i].porta_dpb = dpb;
|
|
recompute_freq(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Player::update_legato_controls(int ch)
|
|
{
|
|
double mt, dc;
|
|
int d;
|
|
|
|
mt = 0.06250 * PORTAMENTO_TIME_TUNING * 0.3;
|
|
dc = playback_rate * mt;
|
|
d = (int)(1.0 / (mt * PORTAMENTO_CONTROL_RATIO));
|
|
d++;
|
|
channel[ch].porta_control_ratio = (int)(d * dc + 0.5);
|
|
channel[ch].porta_dpb = d;
|
|
}
|
|
|
|
int Player::play_event(MidiEvent *ev)
|
|
{
|
|
int32_t i, j;
|
|
int k, l, ch, orig_ch, port_ch, offset, layered;
|
|
|
|
current_event = ev;
|
|
|
|
#ifndef SUPPRESS_CHANNEL_LAYER
|
|
orig_ch = ev->channel;
|
|
layered = !IS_SYSEX_EVENT_TYPE(ev);
|
|
for (k = 0; k < MAX_CHANNELS; k += 16) {
|
|
port_ch = (orig_ch + k) % MAX_CHANNELS;
|
|
offset = port_ch & ~0xf;
|
|
for (l = offset; l < offset + 16; l++) {
|
|
if (!layered && (k || l != offset))
|
|
continue;
|
|
if (layered) {
|
|
if (!IS_SET_CHANNELMASK(channel[l].channel_layer, port_ch)
|
|
|| channel[l].port_select != (orig_ch >> 4))
|
|
continue;
|
|
ev->channel = l;
|
|
}
|
|
#endif
|
|
ch = ev->channel;
|
|
|
|
switch (ev->type)
|
|
{
|
|
/* MIDI Events */
|
|
case ME_NOTEOFF:
|
|
note_off(ev);
|
|
break;
|
|
|
|
case ME_NOTEON:
|
|
note_on(ev);
|
|
break;
|
|
|
|
case ME_KEYPRESSURE:
|
|
adjust_pressure(ev);
|
|
break;
|
|
|
|
case ME_PROGRAM:
|
|
midi_program_change(ch, ev->a);
|
|
break;
|
|
|
|
case ME_CHANNEL_PRESSURE:
|
|
adjust_channel_pressure(ev);
|
|
break;
|
|
|
|
case ME_PITCHWHEEL:
|
|
channel[ch].pitchbend = ev->a + ev->b * 128;
|
|
channel[ch].pitchfactor = 0;
|
|
/* Adjust pitch for notes already playing */
|
|
adjust_pitch(ch);
|
|
break;
|
|
|
|
/* Controls */
|
|
case ME_TONE_BANK_MSB:
|
|
channel[ch].bank_msb = ev->a;
|
|
break;
|
|
|
|
case ME_TONE_BANK_LSB:
|
|
channel[ch].bank_lsb = ev->a;
|
|
break;
|
|
|
|
case ME_MODULATION_WHEEL:
|
|
channel[ch].mod.val = ev->a;
|
|
update_modulation_wheel(ch);
|
|
break;
|
|
|
|
case ME_MAINVOLUME:
|
|
channel[ch].volume = ev->a;
|
|
adjust_volume(ch);
|
|
break;
|
|
|
|
case ME_PAN:
|
|
channel[ch].panning = ev->a;
|
|
channel[ch].pan_random = 0;
|
|
if (adjust_panning_immediately && !channel[ch].pan_random)
|
|
adjust_panning(ch);
|
|
break;
|
|
|
|
case ME_EXPRESSION:
|
|
channel[ch].expression = ev->a;
|
|
adjust_volume(ch);
|
|
break;
|
|
|
|
case ME_SUSTAIN:
|
|
if (channel[ch].sustain == 0 && ev->a >= 64) {
|
|
update_redamper_controls(ch);
|
|
}
|
|
channel[ch].sustain = ev->a;
|
|
if (channel[ch].damper_mode == 0) { /* half-damper is not allowed. */
|
|
if (channel[ch].sustain >= 64) { channel[ch].sustain = 127; }
|
|
else { channel[ch].sustain = 0; }
|
|
}
|
|
if (channel[ch].sustain == 0 && channel[ch].sostenuto == 0)
|
|
drop_sustain(ch);
|
|
break;
|
|
|
|
case ME_SOSTENUTO:
|
|
channel[ch].sostenuto = (ev->a >= 64);
|
|
if (channel[ch].sustain == 0 && channel[ch].sostenuto == 0)
|
|
drop_sustain(ch);
|
|
else { update_sostenuto_controls(ch); }
|
|
break;
|
|
|
|
case ME_LEGATO_FOOTSWITCH:
|
|
channel[ch].legato = (ev->a >= 64);
|
|
break;
|
|
|
|
case ME_HOLD2:
|
|
break;
|
|
|
|
case ME_BREATH:
|
|
break;
|
|
|
|
case ME_FOOT:
|
|
break;
|
|
|
|
case ME_BALANCE:
|
|
break;
|
|
|
|
case ME_PORTAMENTO_TIME_MSB:
|
|
channel[ch].portamento_time_msb = ev->a;
|
|
update_portamento_time(ch);
|
|
break;
|
|
|
|
case ME_PORTAMENTO_TIME_LSB:
|
|
channel[ch].portamento_time_lsb = ev->a;
|
|
update_portamento_time(ch);
|
|
break;
|
|
|
|
case ME_PORTAMENTO:
|
|
channel[ch].portamento = (ev->a >= 64);
|
|
if (!channel[ch].portamento)
|
|
drop_portamento(ch);
|
|
break;
|
|
|
|
case ME_SOFT_PEDAL:
|
|
if (timidity_lpf_def) {
|
|
channel[ch].soft_pedal = ev->a;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Soft Pedal (CH:%d VAL:%d)", ch, channel[ch].soft_pedal);
|
|
}
|
|
break;
|
|
|
|
case ME_HARMONIC_CONTENT:
|
|
if (timidity_lpf_def) {
|
|
channel[ch].param_resonance = ev->a - 64;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Harmonic Content (CH:%d VAL:%d)", ch, channel[ch].param_resonance);
|
|
}
|
|
break;
|
|
|
|
case ME_BRIGHTNESS:
|
|
if (timidity_lpf_def) {
|
|
channel[ch].param_cutoff_freq = ev->a - 64;
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Brightness (CH:%d VAL:%d)", ch, channel[ch].param_cutoff_freq);
|
|
}
|
|
break;
|
|
|
|
case ME_DATA_ENTRY_MSB:
|
|
if (channel[ch].rpn_7f7f_flag) /* disable */
|
|
break;
|
|
if ((i = last_rpn_addr(ch)) >= 0)
|
|
{
|
|
channel[ch].rpnmap[i] = ev->a;
|
|
update_rpn_map(ch, i, 1);
|
|
}
|
|
break;
|
|
|
|
case ME_DATA_ENTRY_LSB:
|
|
if (channel[ch].rpn_7f7f_flag) /* disable */
|
|
break;
|
|
if ((i = last_rpn_addr(ch)) >= 0)
|
|
{
|
|
channel[ch].rpnmap_lsb[i] = ev->a;
|
|
}
|
|
break;
|
|
|
|
case ME_REVERB_EFFECT:
|
|
if (timidity_reverb) {
|
|
if (ISDRUMCHANNEL(ch) && get_reverb_level(ch) != ev->a) { channel[ch].drum_effect_flag = 0; }
|
|
set_reverb_level(ch, ev->a);
|
|
}
|
|
break;
|
|
|
|
case ME_CHORUS_EFFECT:
|
|
if (timidity_chorus)
|
|
{
|
|
if (timidity_chorus == 1) {
|
|
if (ISDRUMCHANNEL(ch) && channel[ch].chorus_level != ev->a) { channel[ch].drum_effect_flag = 0; }
|
|
channel[ch].chorus_level = ev->a;
|
|
}
|
|
else {
|
|
channel[ch].chorus_level = -timidity_chorus;
|
|
}
|
|
if (ev->a) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Chorus Send (CH:%d LEVEL:%d)", ch, ev->a);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ME_TREMOLO_EFFECT:
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Tremolo Send (CH:%d LEVEL:%d)", ch, ev->a);
|
|
break;
|
|
|
|
case ME_CELESTE_EFFECT:
|
|
if (opt_delay_control) {
|
|
if (ISDRUMCHANNEL(ch) && channel[ch].delay_level != ev->a) { channel[ch].drum_effect_flag = 0; }
|
|
channel[ch].delay_level = ev->a;
|
|
if (play_system_mode == XG_SYSTEM_MODE) {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Variation Send (CH:%d LEVEL:%d)", ch, ev->a);
|
|
}
|
|
else {
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Delay Send (CH:%d LEVEL:%d)", ch, ev->a);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ME_ATTACK_TIME:
|
|
if (!opt_tva_attack) { break; }
|
|
set_envelope_time(ch, ev->a, EG_ATTACK);
|
|
break;
|
|
|
|
case ME_RELEASE_TIME:
|
|
if (!opt_tva_release) { break; }
|
|
set_envelope_time(ch, ev->a, EG_RELEASE);
|
|
break;
|
|
|
|
case ME_PHASER_EFFECT:
|
|
//printMessage(CMSG_INFO,VERB_NOISY,"Phaser Send (CH:%d LEVEL:%d)", ch, ev->a);
|
|
break;
|
|
|
|
case ME_RPN_INC:
|
|
if (channel[ch].rpn_7f7f_flag) /* disable */
|
|
break;
|
|
if ((i = last_rpn_addr(ch)) >= 0)
|
|
{
|
|
if (channel[ch].rpnmap[i] < 127)
|
|
channel[ch].rpnmap[i]++;
|
|
update_rpn_map(ch, i, 1);
|
|
}
|
|
break;
|
|
|
|
case ME_RPN_DEC:
|
|
if (channel[ch].rpn_7f7f_flag) /* disable */
|
|
break;
|
|
if ((i = last_rpn_addr(ch)) >= 0)
|
|
{
|
|
if (channel[ch].rpnmap[i] > 0)
|
|
channel[ch].rpnmap[i]--;
|
|
update_rpn_map(ch, i, 1);
|
|
}
|
|
break;
|
|
|
|
case ME_NRPN_LSB:
|
|
channel[ch].lastlrpn = ev->a;
|
|
channel[ch].nrpn = 1;
|
|
break;
|
|
|
|
case ME_NRPN_MSB:
|
|
channel[ch].lastmrpn = ev->a;
|
|
channel[ch].nrpn = 1;
|
|
break;
|
|
|
|
case ME_RPN_LSB:
|
|
channel[ch].lastlrpn = ev->a;
|
|
channel[ch].nrpn = 0;
|
|
break;
|
|
|
|
case ME_RPN_MSB:
|
|
channel[ch].lastmrpn = ev->a;
|
|
channel[ch].nrpn = 0;
|
|
break;
|
|
|
|
case ME_ALL_SOUNDS_OFF:
|
|
all_sounds_off(ch);
|
|
break;
|
|
|
|
case ME_RESET_CONTROLLERS:
|
|
reset_controllers(ch);
|
|
break;
|
|
|
|
case ME_ALL_NOTES_OFF:
|
|
all_notes_off(ch);
|
|
break;
|
|
|
|
case ME_MONO:
|
|
channel[ch].mono = 1;
|
|
all_notes_off(ch);
|
|
break;
|
|
|
|
case ME_POLY:
|
|
channel[ch].mono = 0;
|
|
all_notes_off(ch);
|
|
break;
|
|
|
|
/* TiMidity Extensionals */
|
|
case ME_RANDOM_PAN:
|
|
channel[ch].panning = int_rand(128);
|
|
channel[ch].pan_random = 1;
|
|
if (adjust_panning_immediately && !channel[ch].pan_random)
|
|
adjust_panning(ch);
|
|
break;
|
|
|
|
case ME_SET_PATCH:
|
|
i = channel[ch].special_sample = current_event->a;
|
|
instruments->setSpecialPatchOffset(i, 0);
|
|
break;
|
|
|
|
case ME_TEMPO:
|
|
current_play_tempo = ch + ev->b * 256 + ev->a * 65536;
|
|
break;
|
|
|
|
case ME_CHORUS_TEXT:
|
|
case ME_LYRIC:
|
|
case ME_MARKER:
|
|
case ME_INSERT_TEXT:
|
|
case ME_TEXT:
|
|
case ME_KARAOKE_LYRIC:
|
|
case ME_GSLCD:
|
|
break;
|
|
|
|
case ME_MASTER_VOLUME:
|
|
master_volume_ratio = (int32_t)ev->a + 256 * (int32_t)ev->b;
|
|
adjust_master_volume();
|
|
break;
|
|
|
|
case ME_RESET:
|
|
change_system_mode(ev->a);
|
|
reset_midi(1);
|
|
break;
|
|
|
|
case ME_PATCH_OFFS:
|
|
i = channel[ch].special_sample;
|
|
instruments->setSpecialPatchOffset(i, current_event->a | (256 * current_event->b));
|
|
break;
|
|
|
|
case ME_WRD:
|
|
break;
|
|
|
|
case ME_SHERRY:
|
|
break;
|
|
|
|
case ME_DRUMPART:
|
|
if (midi_drumpart_change(ch, current_event->a))
|
|
{
|
|
/* Update bank information */
|
|
midi_program_change(ch, channel[ch].program);
|
|
}
|
|
break;
|
|
|
|
case ME_KEYSHIFT:
|
|
i = (int)current_event->a - 0x40;
|
|
if (i != channel[ch].key_shift)
|
|
{
|
|
all_sounds_off(ch);
|
|
channel[ch].key_shift = (int8_t)i;
|
|
}
|
|
break;
|
|
|
|
case ME_KEYSIG:
|
|
if (opt_init_keysig != 8)
|
|
break;
|
|
current_keysig = current_event->a + current_event->b * 16;
|
|
if (opt_force_keysig != 8) {
|
|
i = current_keysig - ((current_keysig < 8) ? 0 : 16), j = 0;
|
|
while (i != opt_force_keysig && i != opt_force_keysig + 12)
|
|
i += (i > 0) ? -5 : 7, j++;
|
|
while (abs(j - note_key_offset) > 7)
|
|
j += (j > note_key_offset) ? -12 : 12;
|
|
if (abs(j - timidity_key_adjust) >= 12)
|
|
j += (j > timidity_key_adjust) ? -12 : 12;
|
|
note_key_offset = j;
|
|
kill_all_voices();
|
|
}
|
|
i = current_keysig + ((current_keysig < 8) ? 7 : -9), j = 0;
|
|
while (i != 7)
|
|
i += (i < 7) ? 5 : -7, j++;
|
|
j += note_key_offset, j -= floor(j / 12.0) * 12;
|
|
current_freq_table = j;
|
|
break;
|
|
|
|
case ME_MASTER_TUNING:
|
|
set_master_tuning((ev->b << 8) | ev->a);
|
|
adjust_all_pitch();
|
|
break;
|
|
|
|
case ME_SCALE_TUNING:
|
|
recache->resamp_cache_refer_alloff(ch, computed_samples);
|
|
channel[ch].scale_tuning[current_event->a] = current_event->b;
|
|
adjust_pitch(ch);
|
|
break;
|
|
|
|
case ME_BULK_TUNING_DUMP:
|
|
set_single_note_tuning(ch, current_event->a, current_event->b, 0);
|
|
break;
|
|
|
|
case ME_SINGLE_NOTE_TUNING:
|
|
set_single_note_tuning(ch, current_event->a, current_event->b, 1);
|
|
break;
|
|
|
|
case ME_TEMPER_KEYSIG:
|
|
current_temper_keysig = (current_event->a + 8) % 32 - 8;
|
|
temper_adj = ((current_event->a + 8) & 0x20) ? 1 : 0;
|
|
i = current_temper_keysig + ((current_temper_keysig < 8) ? 7 : -9);
|
|
j = 0;
|
|
while (i != 7)
|
|
i += (i < 7) ? 5 : -7, j++;
|
|
j += note_key_offset, j -= floor(j / 12.0) * 12;
|
|
current_temper_freq_table = j;
|
|
if (current_event->b)
|
|
for (i = 0; i < upper_voices; i++)
|
|
if (voice[i].status != VOICE_FREE) {
|
|
voice[i].temper_instant = 1;
|
|
recompute_freq(i);
|
|
}
|
|
break;
|
|
|
|
case ME_TEMPER_TYPE:
|
|
channel[ch].temper_type = current_event->a;
|
|
if (temper_type_mute) {
|
|
if (temper_type_mute & (1 << (current_event->a
|
|
- ((current_event->a >= 0x40) ? 0x3c : 0)))) {
|
|
SET_CHANNELMASK(channel_mute, ch);
|
|
}
|
|
else {
|
|
UNSET_CHANNELMASK(channel_mute, ch);
|
|
}
|
|
}
|
|
if (current_event->b)
|
|
for (i = 0; i < upper_voices; i++)
|
|
if (voice[i].status != VOICE_FREE) {
|
|
voice[i].temper_instant = 1;
|
|
recompute_freq(i);
|
|
}
|
|
break;
|
|
|
|
case ME_MASTER_TEMPER_TYPE:
|
|
for (i = 0; i < MAX_CHANNELS; i++) {
|
|
channel[i].temper_type = current_event->a;
|
|
}
|
|
if (temper_type_mute) {
|
|
if (temper_type_mute & (1 << (current_event->a
|
|
- ((current_event->a >= 0x40) ? 0x3c : 0)))) {
|
|
FILL_CHANNELMASK(channel_mute);
|
|
}
|
|
else {
|
|
CLEAR_CHANNELMASK(channel_mute);
|
|
}
|
|
}
|
|
if (current_event->b)
|
|
for (i = 0; i < upper_voices; i++)
|
|
if (voice[i].status != VOICE_FREE) {
|
|
voice[i].temper_instant = 1;
|
|
recompute_freq(i);
|
|
}
|
|
break;
|
|
|
|
case ME_USER_TEMPER_ENTRY:
|
|
set_user_temper_entry(ch, current_event->a, current_event->b);
|
|
break;
|
|
|
|
case ME_SYSEX_LSB:
|
|
process_sysex_event(ME_SYSEX_LSB, ch, current_event->a, current_event->b);
|
|
break;
|
|
|
|
case ME_SYSEX_MSB:
|
|
process_sysex_event(ME_SYSEX_MSB, ch, current_event->a, current_event->b);
|
|
break;
|
|
|
|
case ME_SYSEX_GS_LSB:
|
|
process_sysex_event(ME_SYSEX_GS_LSB, ch, current_event->a, current_event->b);
|
|
break;
|
|
|
|
case ME_SYSEX_GS_MSB:
|
|
process_sysex_event(ME_SYSEX_GS_MSB, ch, current_event->a, current_event->b);
|
|
break;
|
|
|
|
case ME_SYSEX_XG_LSB:
|
|
process_sysex_event(ME_SYSEX_XG_LSB, ch, current_event->a, current_event->b);
|
|
break;
|
|
|
|
case ME_SYSEX_XG_MSB:
|
|
process_sysex_event(ME_SYSEX_XG_MSB, ch, current_event->a, current_event->b);
|
|
break;
|
|
|
|
case ME_NOTE_STEP:
|
|
break;
|
|
|
|
case ME_EOT:
|
|
break;
|
|
}
|
|
#ifndef SUPPRESS_CHANNEL_LAYER
|
|
}
|
|
}
|
|
ev->channel = orig_ch;
|
|
#endif
|
|
|
|
return RC_OK;
|
|
}
|
|
|
|
void Player::set_master_tuning(int tune)
|
|
{
|
|
if (tune & 0x4000) /* 1/8192 semitones + 0x2000 | 0x4000 */
|
|
tune = (tune & 0x3FFF) - 0x2000;
|
|
else if (tune & 0x8000) /* 1 semitones | 0x8000 */
|
|
tune = ((tune & 0x7F) - 0x40) << 13;
|
|
else /* millisemitones + 0x400 */
|
|
tune = (((tune - 0x400) << 13) + 500) / 1000;
|
|
master_tuning = tune;
|
|
}
|
|
|
|
void Player::set_single_note_tuning(int part, int a, int b, int rt)
|
|
{
|
|
static int tp; /* tuning program number */
|
|
static int kn; /* MIDI key number */
|
|
static int st; /* the nearest equal-tempered semitone */
|
|
double f, fst; /* fraction of semitone */
|
|
int i;
|
|
|
|
switch (part) {
|
|
case 0:
|
|
tp = a;
|
|
break;
|
|
case 1:
|
|
kn = a, st = b;
|
|
break;
|
|
case 2:
|
|
if (st == 0x7f && a == 0x7f && b == 0x7f) /* no change */
|
|
break;
|
|
f = 440 * pow(2.0, (st - 69) / 12.0);
|
|
fst = pow(2.0, (a << 7 | b) / 196608.0);
|
|
freq_table_tuning[tp][kn] = f * fst * 1000 + 0.5;
|
|
if (rt)
|
|
for (i = 0; i < upper_voices; i++)
|
|
if (voice[i].status != VOICE_FREE) {
|
|
voice[i].temper_instant = 1;
|
|
recompute_freq(i);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void Player::set_user_temper_entry(int part, int a, int b)
|
|
{
|
|
static int tp; /* temperament program number */
|
|
static int ll; /* number of formula */
|
|
static int fh, fl; /* applying pitch bit mask (forward) */
|
|
static int bh, bl; /* applying pitch bit mask (backward) */
|
|
static int aa, bb; /* fraction (aa/bb) */
|
|
static int cc, dd; /* power (cc/dd)^(ee/ff) */
|
|
static int ee, ff;
|
|
static int ifmax, ibmax, count;
|
|
static double rf[11], rb[11];
|
|
int i, j, k, l, n, m;
|
|
double ratio[12], f, sc;
|
|
|
|
switch (part) {
|
|
case 0:
|
|
for (i = 0; i < 11; i++)
|
|
rf[i] = rb[i] = 1;
|
|
ifmax = ibmax = 0;
|
|
count = 0;
|
|
tp = a, ll = b;
|
|
break;
|
|
case 1:
|
|
fh = a, fl = b;
|
|
break;
|
|
case 2:
|
|
bh = a, bl = b;
|
|
break;
|
|
case 3:
|
|
aa = a, bb = b;
|
|
break;
|
|
case 4:
|
|
cc = a, dd = b;
|
|
break;
|
|
case 5:
|
|
ee = a, ff = b;
|
|
for (i = 0; i < 11; i++) {
|
|
if (((fh & 0xf) << 7 | fl) & 1 << i) {
|
|
rf[i] *= (double) aa / bb
|
|
* pow((double) cc / dd, (double) ee / ff);
|
|
if (ifmax < i + 1)
|
|
ifmax = i + 1;
|
|
}
|
|
if (((bh & 0xf) << 7 | bl) & 1 << i) {
|
|
rb[i] *= (double) aa / bb
|
|
* pow((double) cc / dd, (double) ee / ff);
|
|
if (ibmax < i + 1)
|
|
ibmax = i + 1;
|
|
}
|
|
}
|
|
if (++count < ll)
|
|
break;
|
|
ratio[0] = 1;
|
|
for (i = n = m = 0; i < ifmax; i++, m = n) {
|
|
n += (n > 4) ? -5 : 7;
|
|
ratio[n] = ratio[m] * rf[i];
|
|
if (ratio[n] > 2)
|
|
ratio[n] /= 2;
|
|
}
|
|
for (i = n = m = 0; i < ibmax; i++, m = n) {
|
|
n += (n > 6) ? -7 : 5;
|
|
ratio[n] = ratio[m] / rb[i];
|
|
if (ratio[n] < 1)
|
|
ratio[n] *= 2;
|
|
}
|
|
sc = 27 / ratio[9] / 16; /* syntonic comma */
|
|
for (i = 0; i < 12; i++)
|
|
for (j = -1; j < 11; j++) {
|
|
f = 440 * pow(2.0, (i - 9) / 12.0 + j - 5);
|
|
for (k = 0; k < 12; k++) {
|
|
l = i + j * 12 + k;
|
|
if (l < 0 || l >= 128)
|
|
continue;
|
|
if (! (fh & 0x40)) { /* major */
|
|
freq_table_user[tp][i][l] =
|
|
f * ratio[k] * 1000 + 0.5;
|
|
freq_table_user[tp][i + 36][l] =
|
|
f * ratio[k] * sc * 1000 + 0.5;
|
|
}
|
|
if (! (bh & 0x40)) { /* minor */
|
|
freq_table_user[tp][i + 12][l] =
|
|
f * ratio[k] * sc * 1000 + 0.5;
|
|
freq_table_user[tp][i + 24][l] =
|
|
f * ratio[k] * 1000 + 0.5;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
struct midi_file_info *Player::new_midi_file_info()
|
|
{
|
|
struct midi_file_info *p = &midifileinfo;
|
|
|
|
/* Initialize default members */
|
|
memset(p, 0, sizeof(struct midi_file_info));
|
|
p->hdrsiz = -1;
|
|
p->format = -1;
|
|
p->tracks = -1;
|
|
p->divisions = -1;
|
|
p->time_sig_n = p->time_sig_d = -1;
|
|
p->samples = -1;
|
|
p->max_channel = -1;
|
|
COPY_CHANNELMASK(p->drumchannels, default_drumchannels);
|
|
COPY_CHANNELMASK(p->drumchannel_mask, default_drumchannel_mask);
|
|
return p;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* For MIDI stream player.
|
|
*/
|
|
void Player::playmidi_stream_init(void)
|
|
{
|
|
int i;
|
|
static int first = 1;
|
|
|
|
note_key_offset = timidity_key_adjust;
|
|
midi_time_ratio = timidity_tempo_adjust;
|
|
CLEAR_CHANNELMASK(channel_mute);
|
|
if (temper_type_mute & 1)
|
|
FILL_CHANNELMASK(channel_mute);
|
|
if (first)
|
|
{
|
|
first = 0;
|
|
init_mblock(&playmidi_pool);
|
|
midi_streaming = 1;
|
|
}
|
|
else
|
|
reuse_mblock(&playmidi_pool);
|
|
|
|
/* Fill in current_file_info */
|
|
current_file_info = &midifileinfo;
|
|
current_file_info->readflag = 1;
|
|
current_file_info->hdrsiz = 0;
|
|
current_file_info->format = 0;
|
|
current_file_info->tracks = 0;
|
|
current_file_info->divisions = 192; /* ?? */
|
|
current_file_info->time_sig_n = 4; /* 4/ */
|
|
current_file_info->time_sig_d = 4; /* /4 */
|
|
current_file_info->time_sig_c = 24; /* clock */
|
|
current_file_info->time_sig_b = 8; /* q.n. */
|
|
current_file_info->samples = 0;
|
|
current_file_info->max_channel = MAX_CHANNELS;
|
|
current_file_info->compressed = 0;
|
|
|
|
current_play_tempo = 500000;
|
|
check_eot_flag = 0;
|
|
|
|
/* Setup default drums */
|
|
COPY_CHANNELMASK(current_file_info->drumchannels, default_drumchannels);
|
|
COPY_CHANNELMASK(current_file_info->drumchannel_mask, default_drumchannel_mask);
|
|
for(i = 0; i < MAX_CHANNELS; i++)
|
|
memset(channel[i].drums, 0, sizeof(channel[i].drums));
|
|
change_system_mode(DEFAULT_SYSTEM_MODE);
|
|
reset_midi(0);
|
|
|
|
playmidi_tmr_reset();
|
|
}
|
|
|
|
void Player::playmidi_tmr_reset(void)
|
|
{
|
|
int i;
|
|
|
|
current_sample = 0;
|
|
buffer_pointer = common_buffer;
|
|
for(i = 0; i < MAX_CHANNELS; i++)
|
|
channel[i].lasttime = 0;
|
|
}
|
|
|
|
|
|
/*! initialize Part EQ (XG) */
|
|
void Player::init_part_eq_xg(struct part_eq_xg *p)
|
|
{
|
|
p->bass = 0x40;
|
|
p->treble = 0x40;
|
|
p->bass_freq = 0x0C;
|
|
p->treble_freq = 0x36;
|
|
p->valid = 0;
|
|
}
|
|
|
|
/*! recompute Part EQ (XG) */
|
|
void Player::recompute_part_eq_xg(struct part_eq_xg *p)
|
|
{
|
|
int8_t vbass, vtreble;
|
|
|
|
if(p->bass_freq >= 4 && p->bass_freq <= 40 && p->bass != 0x40) {
|
|
vbass = 1;
|
|
p->basss.q = 0.7;
|
|
p->basss.freq = eq_freq_table_xg[p->bass_freq];
|
|
if(p->bass == 0) {p->basss.gain = -12.0;}
|
|
else {p->basss.gain = 0.19 * (double)(p->bass - 0x40);}
|
|
reverb->calc_filter_shelving_low(&(p->basss));
|
|
} else {vbass = 0;}
|
|
if(p->treble_freq >= 28 && p->treble_freq <= 58 && p->treble != 0x40) {
|
|
vtreble = 1;
|
|
p->trebles.q = 0.7;
|
|
p->trebles.freq = eq_freq_table_xg[p->treble_freq];
|
|
if(p->treble == 0) {p->trebles.gain = -12.0;}
|
|
else {p->trebles.gain = 0.19 * (double)(p->treble - 0x40);}
|
|
reverb->calc_filter_shelving_high(&(p->trebles));
|
|
} else {vtreble = 0;}
|
|
p->valid = vbass || vtreble;
|
|
}
|
|
|
|
void Player::init_midi_controller(midi_controller *p)
|
|
{
|
|
p->val = 0;
|
|
p->pitch = 0;
|
|
p->cutoff = 0;
|
|
p->amp = 0.0;
|
|
p->lfo1_rate = p->lfo2_rate = p->lfo1_tva_depth = p->lfo2_tva_depth = 0;
|
|
p->lfo1_pitch_depth = p->lfo2_pitch_depth = p->lfo1_tvf_depth = p->lfo2_tvf_depth = 0;
|
|
p->variation_control_depth = p->insertion_control_depth = 0;
|
|
}
|
|
|
|
float Player::get_midi_controller_amp(midi_controller *p)
|
|
{
|
|
return (1.0 + (float)p->val * (1.0f / 127.0f) * p->amp);
|
|
}
|
|
|
|
float Player::get_midi_controller_filter_cutoff(midi_controller *p)
|
|
{
|
|
return ((float)p->val * (1.0f / 127.0f) * (float)p->cutoff);
|
|
}
|
|
|
|
float Player::get_midi_controller_filter_depth(midi_controller *p)
|
|
{
|
|
return ((float)p->val * (1.0f / 127.0f) * (float)p->lfo1_tvf_depth);
|
|
}
|
|
|
|
int32_t Player::get_midi_controller_pitch(midi_controller *p)
|
|
{
|
|
return ((int32_t)(p->val * p->pitch) << 6);
|
|
}
|
|
|
|
int16_t Player::get_midi_controller_pitch_depth(midi_controller *p)
|
|
{
|
|
return (int16_t)((float)p->val * (float)p->lfo1_pitch_depth * (1.0f / 127.0f * 256.0 / 400.0));
|
|
}
|
|
|
|
int16_t Player::get_midi_controller_amp_depth(midi_controller *p)
|
|
{
|
|
return (int16_t)((float)p->val * (float)p->lfo1_tva_depth * (1.0f / 127.0f * 256.0));
|
|
}
|
|
|
|
void Player::init_rx(int ch)
|
|
{
|
|
channel[ch].rx = 0xFFFFFFFF; /* all on */
|
|
}
|
|
|
|
void Player::set_rx(int ch, int32_t rx, int flag)
|
|
{
|
|
if(ch > MAX_CHANNELS) {return;}
|
|
if(flag) {channel[ch].rx |= rx;}
|
|
else {channel[ch].rx &= ~rx;}
|
|
}
|
|
|
|
void Player::init_rx_drum(struct DrumParts *p)
|
|
{
|
|
p->rx = 0xFFFFFFFF; /* all on */
|
|
}
|
|
|
|
void Player::set_rx_drum(struct DrumParts *p, int32_t rx, int flag)
|
|
{
|
|
if(flag) {p->rx |= rx;}
|
|
else {p->rx &= ~rx;}
|
|
}
|
|
|
|
int32_t Player::get_rx_drum(struct DrumParts *p, int32_t rx)
|
|
{
|
|
return (p->rx & rx);
|
|
}
|
|
|
|
Instrument *Player::play_midi_load_instrument(int dr, int bk, int prog)
|
|
{
|
|
bool load_success;
|
|
// The inner workings of this function which alters the instrument data has been put into the Instruments class.
|
|
auto instr = instruments->play_midi_load_instrument(dr, bk, prog, &load_success);
|
|
//if (load_success) send_output(NULL, 0); /* Update software buffer */
|
|
return instr;
|
|
}
|
|
|
|
void Player::change_system_mode(int mode)
|
|
{
|
|
pan_table = sc_pan_table;
|
|
switch (mode)
|
|
{
|
|
case GM_SYSTEM_MODE:
|
|
if (play_system_mode == DEFAULT_SYSTEM_MODE)
|
|
{
|
|
play_system_mode = GM_SYSTEM_MODE;
|
|
vol_table = def_vol_table;
|
|
}
|
|
break;
|
|
case GM2_SYSTEM_MODE:
|
|
play_system_mode = GM2_SYSTEM_MODE;
|
|
vol_table = def_vol_table;
|
|
pan_table = gm2_pan_table;
|
|
break;
|
|
case GS_SYSTEM_MODE:
|
|
play_system_mode = GS_SYSTEM_MODE;
|
|
vol_table = gs_vol_table;
|
|
break;
|
|
case XG_SYSTEM_MODE:
|
|
if (play_system_mode != XG_SYSTEM_MODE) { reverb->init_all_effect_xg(); }
|
|
play_system_mode = XG_SYSTEM_MODE;
|
|
vol_table = xg_vol_table;
|
|
break;
|
|
default:
|
|
play_system_mode = DEFAULT_SYSTEM_MODE;
|
|
vol_table = def_vol_table;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*! initialize channel layers. */
|
|
void Player::init_channel_layer(int ch)
|
|
{
|
|
if (ch >= MAX_CHANNELS)
|
|
return;
|
|
CLEAR_CHANNELMASK(channel[ch].channel_layer);
|
|
SET_CHANNELMASK(channel[ch].channel_layer, ch);
|
|
channel[ch].port_select = ch >> 4;
|
|
}
|
|
|
|
|
|
static const struct ctl_chg_types {
|
|
unsigned char mtype;
|
|
int ttype;
|
|
} ctl_chg_list[] = {
|
|
{ 0, ME_TONE_BANK_MSB },
|
|
{ 1, ME_MODULATION_WHEEL },
|
|
{ 2, ME_BREATH },
|
|
{ 4, ME_FOOT },
|
|
{ 5, ME_PORTAMENTO_TIME_MSB },
|
|
{ 6, ME_DATA_ENTRY_MSB },
|
|
{ 7, ME_MAINVOLUME },
|
|
{ 8, ME_BALANCE },
|
|
{ 10, ME_PAN },
|
|
{ 11, ME_EXPRESSION },
|
|
{ 32, ME_TONE_BANK_LSB },
|
|
{ 37, ME_PORTAMENTO_TIME_LSB },
|
|
{ 38, ME_DATA_ENTRY_LSB },
|
|
{ 64, ME_SUSTAIN },
|
|
{ 65, ME_PORTAMENTO },
|
|
{ 66, ME_SOSTENUTO },
|
|
{ 67, ME_SOFT_PEDAL },
|
|
{ 68, ME_LEGATO_FOOTSWITCH },
|
|
{ 69, ME_HOLD2 },
|
|
{ 71, ME_HARMONIC_CONTENT },
|
|
{ 72, ME_RELEASE_TIME },
|
|
{ 73, ME_ATTACK_TIME },
|
|
{ 74, ME_BRIGHTNESS },
|
|
{ 84, ME_PORTAMENTO_CONTROL },
|
|
{ 91, ME_REVERB_EFFECT },
|
|
{ 92, ME_TREMOLO_EFFECT },
|
|
{ 93, ME_CHORUS_EFFECT },
|
|
{ 94, ME_CELESTE_EFFECT },
|
|
{ 95, ME_PHASER_EFFECT },
|
|
{ 96, ME_RPN_INC },
|
|
{ 97, ME_RPN_DEC },
|
|
{ 98, ME_NRPN_LSB },
|
|
{ 99, ME_NRPN_MSB },
|
|
{ 100, ME_RPN_LSB },
|
|
{ 101, ME_RPN_MSB },
|
|
{ 120, ME_ALL_SOUNDS_OFF },
|
|
{ 121, ME_RESET_CONTROLLERS },
|
|
{ 123, ME_ALL_NOTES_OFF },
|
|
{ 126, ME_MONO },
|
|
{ 127, ME_POLY },
|
|
};
|
|
|
|
int Player::convert_midi_control_change(int chn, int type, int val, MidiEvent *ev_ret)
|
|
{
|
|
for (auto &t : ctl_chg_list)
|
|
{
|
|
if (t.mtype == type)
|
|
{
|
|
if (val > 127) val = 127;
|
|
ev_ret->type = t.ttype;
|
|
ev_ret->channel = chn;
|
|
ev_ret->a = val;
|
|
ev_ret->b = 0;
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
int Player::send_event(int status, int parm1, int parm2)
|
|
{
|
|
MidiEvent ev;
|
|
|
|
ev.type = ME_NONE;
|
|
ev.channel = status & 0x0000000f;
|
|
//ev.channel = ev.channel + port * 16;
|
|
ev.a = (uint8_t)parm1;
|
|
ev.b = (uint8_t)parm2;
|
|
switch ((int)(status & 0x000000f0))
|
|
{
|
|
case 0x80:
|
|
ev.type = ME_NOTEOFF;
|
|
break;
|
|
case 0x90:
|
|
ev.type = (ev.b) ? ME_NOTEON : ME_NOTEOFF;
|
|
break;
|
|
case 0xa0:
|
|
ev.type = ME_KEYPRESSURE;
|
|
break;
|
|
case 0xb0:
|
|
if (!convert_midi_control_change(ev.channel, ev.a, ev.b, &ev))
|
|
ev.type = ME_NONE;
|
|
break;
|
|
case 0xc0:
|
|
ev.type = ME_PROGRAM;
|
|
break;
|
|
case 0xd0:
|
|
ev.type = ME_CHANNEL_PRESSURE;
|
|
break;
|
|
case 0xe0:
|
|
ev.type = ME_PITCHWHEEL;
|
|
break;
|
|
/*
|
|
case 0xf0:
|
|
if ((status & 0x000000ff) == 0xf2)
|
|
{
|
|
ev.type = ME_PROGRAM;
|
|
}
|
|
break;
|
|
*/
|
|
default:
|
|
break;
|
|
}
|
|
if (ev.type != ME_NONE)
|
|
{
|
|
play_event(&ev);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void Player::send_long_event(const uint8_t *sysexbuffer, int exlen)
|
|
{
|
|
int i, ne;
|
|
MidiEvent ev;
|
|
MidiEvent evm[260];
|
|
SysexConvert sc;
|
|
|
|
if ((sysexbuffer[0] != 0xf0) && (sysexbuffer[0] != 0xf7)) return;
|
|
|
|
if (sc.parse_sysex_event(sysexbuffer + 1, exlen - 1, &ev, instruments))
|
|
{
|
|
if (ev.type == ME_RESET)
|
|
{
|
|
kill_all_voices();
|
|
for (int i = 0; i < MAX_CHANNELS; i++)
|
|
init_channel_layer(i);
|
|
|
|
/* initialize effect status */
|
|
reverb->init_effect_status(play_system_mode);
|
|
effect->init_effect();
|
|
instruments->init_userdrum();
|
|
instruments->init_userinst();
|
|
playmidi_stream_init();
|
|
}
|
|
play_event(&ev);
|
|
return;
|
|
}
|
|
if ((ne = sc.parse_sysex_event_multi(sysexbuffer + 1, exlen - 1, evm, instruments)))
|
|
{
|
|
for (i = 0; i < ne; i++)
|
|
{
|
|
play_event(&evm[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
}
|