Back to index...

	/*
	* Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package com.sun.media.sound;

	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import javax.sound.midi.MidiChannel;
	import javax.sound.midi.Patch;

	/**
	* Software Synthesizer MIDI channel class.
	*
	* @author Karl Helgason
	*/
	public final class SoftChannel implements MidiChannel, ModelDirectedPlayer {

	private static boolean[] dontResetControls = new boolean[128];
	static {
	for (int i = 0; i < dontResetControls.length; i++)
	dontResetControls[i] = false;

	dontResetControls[0] = true; // Bank Select (MSB)
	dontResetControls[32] = true; // Bank Select (LSB)
	dontResetControls[7] = true; // Channel Volume (MSB)
	dontResetControls[8] = true; // Balance (MSB)
	dontResetControls[10] = true; // Pan (MSB)
	dontResetControls[11] = true; // Expression (MSB)
	dontResetControls[91] = true; // Effects 1 Depth (default: Reverb Send)
	dontResetControls[92] = true; // Effects 2 Depth (default: Tremolo Depth)
	dontResetControls[93] = true; // Effects 3 Depth (default: Chorus Send)
	dontResetControls[94] = true; // Effects 4 Depth (default: Celeste [Detune] Depth)
	dontResetControls[95] = true; // Effects 5 Depth (default: Phaser Depth)
	dontResetControls[70] = true; // Sound Controller 1 (default: Sound Variation)
	dontResetControls[71] = true; // Sound Controller 2 (default: Timbre / Harmonic Quality)
	dontResetControls[72] = true; // Sound Controller 3 (default: Release Time)
	dontResetControls[73] = true; // Sound Controller 4 (default: Attack Time)
	dontResetControls[74] = true; // Sound Controller 5 (default: Brightness)
	dontResetControls[75] = true; // Sound Controller 6 (GM2 default: Decay Time)
	dontResetControls[76] = true; // Sound Controller 7 (GM2 default: Vibrato Rate)
	dontResetControls[77] = true; // Sound Controller 8 (GM2 default: Vibrato Depth)
	dontResetControls[78] = true; // Sound Controller 9 (GM2 default: Vibrato Delay)
	dontResetControls[79] = true; // Sound Controller 10 (GM2 default: Undefined)
	dontResetControls[120] = true; // All Sound Off
	dontResetControls[121] = true; // Reset All Controllers
	dontResetControls[122] = true; // Local Control On/Off
	dontResetControls[123] = true; // All Notes Off
	dontResetControls[124] = true; // Omni Mode Off
	dontResetControls[125] = true; // Omni Mode On
	dontResetControls[126] = true; // Poly Mode Off
	dontResetControls[127] = true; // Poly Mode On

	dontResetControls[6] = true; // Data Entry (MSB)
	dontResetControls[38] = true; // Data Entry (LSB)
	dontResetControls[96] = true; // Data Increment
	dontResetControls[97] = true; // Data Decrement
	dontResetControls[98] = true; // Non-Registered Parameter Number (LSB)
	dontResetControls[99] = true; // Non-Registered Parameter Number(MSB)
	dontResetControls[100] = true; // RPN = Null
	dontResetControls[101] = true; // RPN = Null

	}

	private static final int RPN_NULL_VALUE = (127 << 7) + 127;
	private int rpn_control = RPN_NULL_VALUE;
	private int nrpn_control = RPN_NULL_VALUE;
	double portamento_time = 1; // keyschanges per control buffer time
	int[] portamento_lastnote = new int[128];
	int portamento_lastnote_ix = 0;
	private boolean portamento = false;
	private boolean mono = false;
	private boolean mute = false;
	private boolean solo = false;
	private boolean solomute = false;
	private final Object control_mutex;
	private int channel;
	private SoftVoice[] voices;
	private int bank;
	private int program;
	private SoftSynthesizer synthesizer;
	private SoftMainMixer mainmixer;
	private int[] polypressure = new int[128];
	private int channelpressure = 0;
	private int[] controller = new int[128];
	private int pitchbend;
	private double[] co_midi_pitch = new double[1];
	private double[] co_midi_channel_pressure = new double[1];
	SoftTuning tuning = new SoftTuning();
	int tuning_bank = 0;
	int tuning_program = 0;
	SoftInstrument current_instrument = null;
	ModelChannelMixer current_mixer = null;
	ModelDirector current_director = null;

	// Controller Destination Settings
	int cds_control_number = -1;
	ModelConnectionBlock[] cds_control_connections = null;
	ModelConnectionBlock[] cds_channelpressure_connections = null;
	ModelConnectionBlock[] cds_polypressure_connections = null;
	boolean sustain = false;
	boolean[][] keybasedcontroller_active = null;
	double[][] keybasedcontroller_value = null;

	private class MidiControlObject implements SoftControl {
	double[] pitch = co_midi_pitch;
	double[] channel_pressure = co_midi_channel_pressure;
	double[] poly_pressure = new double[1];

	public double[] get(int instance, String name) {
	if (name == null)
	return null;
	if (name.equals("pitch"))
	return pitch;
	if (name.equals("channel_pressure"))
	return channel_pressure;
	if (name.equals("poly_pressure"))
	return poly_pressure;
	return null;
	}
	}

	private SoftControl[] co_midi = new SoftControl[128];
	{
	for (int i = 0; i < co_midi.length; i++) {
	co_midi[i] = new MidiControlObject();
	}
	}

	private double[][] co_midi_cc_cc = new double[128][1];
	private SoftControl co_midi_cc = new SoftControl() {
	double[][] cc = co_midi_cc_cc;
	public double[] get(int instance, String name) {
	if (name == null)
	return null;
	return cc[Integer.parseInt(name)];
	}
	};
	Map<Integer, int[]> co_midi_rpn_rpn_i = new HashMap<Integer, int[]>();
	Map<Integer, double[]> co_midi_rpn_rpn = new HashMap<Integer, double[]>();
	private SoftControl co_midi_rpn = new SoftControl() {
	Map<Integer, double[]> rpn = co_midi_rpn_rpn;
	public double[] get(int instance, String name) {
	if (name == null)
	return null;
	int iname = Integer.parseInt(name);
	double[] v = rpn.get(iname);
	if (v == null) {
	v = new double[1];
	rpn.put(iname, v);
	}
	return v;
	}
	};
	Map<Integer, int[]> co_midi_nrpn_nrpn_i = new HashMap<Integer, int[]>();
	Map<Integer, double[]> co_midi_nrpn_nrpn = new HashMap<Integer, double[]>();
	private SoftControl co_midi_nrpn = new SoftControl() {
	Map<Integer, double[]> nrpn = co_midi_nrpn_nrpn;
	public double[] get(int instance, String name) {
	if (name == null)
	return null;
	int iname = Integer.parseInt(name);
	double[] v = nrpn.get(iname);
	if (v == null) {
	v = new double[1];
	nrpn.put(iname, v);
	}
	return v;
	}
	};

	private static int restrict7Bit(int value)
	{
	if(value < 0) return 0;
	if(value > 127) return 127;
	return value;
	}

	private static int restrict14Bit(int value)
	{
	if(value < 0) return 0;
	if(value > 16256) return 16256;
	return value;
	}

	public SoftChannel(SoftSynthesizer synth, int channel) {
	this.channel = channel;
	this.voices = synth.getVoices();
	this.synthesizer = synth;
	this.mainmixer = synth.getMainMixer();
	control_mutex = synth.control_mutex;
	resetAllControllers(true);
	}

	private int findFreeVoice(int x) {
	if(x == -1)
	{
	// x = -1 means that there where no available voice
	// last time we called findFreeVoice
	// and it hasn't changed because no audio has been
	// rendered in the meantime.
	// Therefore we have to return -1.
	return -1;
	}
	for (int i = x; i < voices.length; i++)
	if (!voices[i].active)
	return i;

	// No free voice was found, we must steal one

	int vmode = synthesizer.getVoiceAllocationMode();
	if (vmode == 1) {
	// DLS Static Voice Allocation

	// * priority ( 10, 1-9, 11-16)
	// Search for channel to steal from
	int steal_channel = channel;
	for (int j = 0; j < voices.length; j++) {
	if (voices[j].stealer_channel == null) {
	if (steal_channel == 9) {
	steal_channel = voices[j].channel;
	} else {
	if (voices[j].channel != 9) {
	if (voices[j].channel > steal_channel)
	steal_channel = voices[j].channel;
	}
	}
	}
	}

	int voiceNo = -1;

	SoftVoice v = null;
	// Search for oldest voice in off state on steal_channel
	for (int j = 0; j < voices.length; j++) {
	if (voices[j].channel == steal_channel) {
	if (voices[j].stealer_channel == null && !voices[j].on) {
	if (v == null) {
	v = voices[j];
	voiceNo = j;
	}
	if (voices[j].voiceID < v.voiceID) {
	v = voices[j];
	voiceNo = j;
	}
	}
	}
	}
	// Search for oldest voice in on state on steal_channel
	if (voiceNo == -1) {
	for (int j = 0; j < voices.length; j++) {
	if (voices[j].channel == steal_channel) {
	if (voices[j].stealer_channel == null) {
	if (v == null) {
	v = voices[j];
	voiceNo = j;
	}
	if (voices[j].voiceID < v.voiceID) {
	v = voices[j];
	voiceNo = j;
	}
	}
	}
	}
	}

	return voiceNo;

	} else {
	// Default Voice Allocation
	// * Find voice that is on
	// and Find voice which has lowest voiceID ( oldest voice)
	// * Or find voice that is off
	// and Find voice which has lowest voiceID ( oldest voice)

	int voiceNo = -1;

	SoftVoice v = null;
	// Search for oldest voice in off state
	for (int j = 0; j < voices.length; j++) {
	if (voices[j].stealer_channel == null && !voices[j].on) {
	if (v == null) {
	v = voices[j];
	voiceNo = j;
	}
	if (voices[j].voiceID < v.voiceID) {
	v = voices[j];
	voiceNo = j;
	}
	}
	}
	// Search for oldest voice in on state
	if (voiceNo == -1) {

	for (int j = 0; j < voices.length; j++) {
	if (voices[j].stealer_channel == null) {
	if (v == null) {
	v = voices[j];
	voiceNo = j;
	}
	if (voices[j].voiceID < v.voiceID) {
	v = voices[j];
	voiceNo = j;
	}
	}
	}
	}

	return voiceNo;
	}

	}

	void initVoice(SoftVoice voice, SoftPerformer p, int voiceID,
	int noteNumber, int velocity, int delay, ModelConnectionBlock[] connectionBlocks,
	ModelChannelMixer channelmixer, boolean releaseTriggered) {
	if (voice.active) {
	// Voice is active , we must steal the voice
	voice.stealer_channel = this;
	voice.stealer_performer = p;
	voice.stealer_voiceID = voiceID;
	voice.stealer_noteNumber = noteNumber;
	voice.stealer_velocity = velocity;
	voice.stealer_extendedConnectionBlocks = connectionBlocks;
	voice.stealer_channelmixer = channelmixer;
	voice.stealer_releaseTriggered = releaseTriggered;
	for (int i = 0; i < voices.length; i++)
	if (voices[i].active && voices[i].voiceID == voice.voiceID)
	voices[i].soundOff();
	return;
	}

	voice.extendedConnectionBlocks = connectionBlocks;
	voice.channelmixer = channelmixer;
	voice.releaseTriggered = releaseTriggered;
	voice.voiceID = voiceID;
	voice.tuning = tuning;
	voice.exclusiveClass = p.exclusiveClass;
	voice.softchannel = this;
	voice.channel = channel;
	voice.bank = bank;
	voice.program = program;
	voice.instrument = current_instrument;
	voice.performer = p;
	voice.objects.clear();
	voice.objects.put("midi", co_midi[noteNumber]);
	voice.objects.put("midi_cc", co_midi_cc);
	voice.objects.put("midi_rpn", co_midi_rpn);
	voice.objects.put("midi_nrpn", co_midi_nrpn);
	voice.noteOn(noteNumber, velocity, delay);
	voice.setMute(mute);
	voice.setSoloMute(solomute);
	if (releaseTriggered)
	return;
	if (controller[84] != 0) {
	voice.co_noteon_keynumber[0]
	= (tuning.getTuning(controller[84]) / 100.0)
	* (1f / 128f);
	voice.portamento = true;
	controlChange(84, 0);
	} else if (portamento) {
	if (mono) {
	if (portamento_lastnote[0] != -1) {
	voice.co_noteon_keynumber[0]
	= (tuning.getTuning(portamento_lastnote[0]) / 100.0)
	* (1f / 128f);
	voice.portamento = true;
	controlChange(84, 0);
	}
	portamento_lastnote[0] = noteNumber;
	} else {
	if (portamento_lastnote_ix != 0) {
	portamento_lastnote_ix--;
	voice.co_noteon_keynumber[0]
	= (tuning.getTuning(
	portamento_lastnote[portamento_lastnote_ix])
	/ 100.0)
	* (1f / 128f);
	voice.portamento = true;
	}
	}
	}
	}

	public void noteOn(int noteNumber, int velocity) {
	noteOn(noteNumber, velocity, 0);
	}

	/* A special noteOn with delay parameter, which is used to
	* start note within control buffers.
	*/
	void noteOn(int noteNumber, int velocity, int delay) {
	noteNumber = restrict7Bit(noteNumber);
	velocity = restrict7Bit(velocity);
	noteOn_internal(noteNumber, velocity, delay);
	if (current_mixer != null)
	current_mixer.noteOn(noteNumber, velocity);
	}

	private void noteOn_internal(int noteNumber, int velocity, int delay) {

	if (velocity == 0) {
	noteOff_internal(noteNumber, 64);
	return;
	}

	synchronized (control_mutex) {
	if (sustain) {
	sustain = false;
	for (int i = 0; i < voices.length; i++) {
	if ((voices[i].sustain \|\| voices[i].on)
	&& voices[i].channel == channel && voices[i].active
	&& voices[i].note == noteNumber) {
	voices[i].sustain = false;
	voices[i].on = true;
	voices[i].noteOff(0);
	}
	}
	sustain = true;
	}

	mainmixer.activity();

	if (mono) {
	if (portamento) {
	boolean n_found = false;
	for (int i = 0; i < voices.length; i++) {
	if (voices[i].on && voices[i].channel == channel
	&& voices[i].active
	&& voices[i].releaseTriggered == false) {
	voices[i].portamento = true;
	voices[i].setNote(noteNumber);
	n_found = true;
	}
	}
	if (n_found) {
	portamento_lastnote[0] = noteNumber;
	return;
	}
	}

	if (controller[84] != 0) {
	boolean n_found = false;
	for (int i = 0; i < voices.length; i++) {
	if (voices[i].on && voices[i].channel == channel
	&& voices[i].active
	&& voices[i].note == controller[84]
	&& voices[i].releaseTriggered == false) {
	voices[i].portamento = true;
	voices[i].setNote(noteNumber);
	n_found = true;
	}
	}
	controlChange(84, 0);
	if (n_found)
	return;
	}
	}

	if (mono)
	allNotesOff();

	if (current_instrument == null) {
	current_instrument
	= synthesizer.findInstrument(program, bank, channel);
	if (current_instrument == null)
	return;
	if (current_mixer != null)
	mainmixer.stopMixer(current_mixer);
	current_mixer = current_instrument.getSourceInstrument()
	.getChannelMixer(this, synthesizer.getFormat());
	if (current_mixer != null)
	mainmixer.registerMixer(current_mixer);
	current_director = current_instrument.getDirector(this, this);
	applyInstrumentCustomization();
	}
	prevVoiceID = synthesizer.voiceIDCounter++;
	firstVoice = true;
	voiceNo = 0;

	int tunedKey = (int)(Math.round(tuning.getTuning(noteNumber)/100.0));
	play_noteNumber = noteNumber;
	play_velocity = velocity;
	play_delay = delay;
	play_releasetriggered = false;
	lastVelocity[noteNumber] = velocity;
	current_director.noteOn(tunedKey, velocity);

	/*
	SoftPerformer[] performers = current_instrument.getPerformers();
	for (int i = 0; i < performers.length; i++) {
	SoftPerformer p = performers[i];
	if (p.keyFrom <= tunedKey && p.keyTo >= tunedKey) {
	if (p.velFrom <= velocity && p.velTo >= velocity) {
	if (firstVoice) {
	firstVoice = false;
	if (p.exclusiveClass != 0) {
	int x = p.exclusiveClass;
	for (int j = 0; j < voices.length; j++) {
	if (voices[j].active
	&& voices[j].channel == channel
	&& voices[j].exclusiveClass == x) {
	if (!(p.selfNonExclusive
	&& voices[j].note == noteNumber))
	voices[j].shutdown();
	}
	}
	}
	}
	voiceNo = findFreeVoice(voiceNo);
	if (voiceNo == -1)
	return;
	initVoice(voices[voiceNo], p, prevVoiceID, noteNumber,
	velocity);
	}
	}
	}
	*/
	}
	}

	public void noteOff(int noteNumber, int velocity) {
	noteNumber = restrict7Bit(noteNumber);
	velocity = restrict7Bit(velocity);
	noteOff_internal(noteNumber, velocity);

	if (current_mixer != null)
	current_mixer.noteOff(noteNumber, velocity);
	}

	private void noteOff_internal(int noteNumber, int velocity) {
	synchronized (control_mutex) {

	if (!mono) {
	if (portamento) {
	if (portamento_lastnote_ix != 127) {
	portamento_lastnote[portamento_lastnote_ix] = noteNumber;
	portamento_lastnote_ix++;
	}
	}
	}

	mainmixer.activity();
	for (int i = 0; i < voices.length; i++) {
	if (voices[i].on && voices[i].channel == channel
	&& voices[i].note == noteNumber
	&& voices[i].releaseTriggered == false) {
	voices[i].noteOff(velocity);
	}
	// We must also check stolen voices
	if (voices[i].stealer_channel == this && voices[i].stealer_noteNumber == noteNumber) {
	SoftVoice v = voices[i];
	v.stealer_releaseTriggered = false;
	v.stealer_channel = null;
	v.stealer_performer = null;
	v.stealer_voiceID = -1;
	v.stealer_noteNumber = 0;
	v.stealer_velocity = 0;
	v.stealer_extendedConnectionBlocks = null;
	v.stealer_channelmixer = null;
	}
	}

	// Try play back note-off triggered voices,

	if (current_instrument == null) {
	current_instrument
	= synthesizer.findInstrument(program, bank, channel);
	if (current_instrument == null)
	return;
	if (current_mixer != null)
	mainmixer.stopMixer(current_mixer);
	current_mixer = current_instrument.getSourceInstrument()
	.getChannelMixer(this, synthesizer.getFormat());
	if (current_mixer != null)
	mainmixer.registerMixer(current_mixer);
	current_director = current_instrument.getDirector(this, this);
	applyInstrumentCustomization();

	}
	prevVoiceID = synthesizer.voiceIDCounter++;
	firstVoice = true;
	voiceNo = 0;

	int tunedKey = (int)(Math.round(tuning.getTuning(noteNumber)/100.0));
	play_noteNumber = noteNumber;
	play_velocity = lastVelocity[noteNumber];
	play_releasetriggered = true;
	play_delay = 0;
	current_director.noteOff(tunedKey, velocity);

	}
	}
	private int[] lastVelocity = new int[128];
	private int prevVoiceID;
	private boolean firstVoice = true;
	private int voiceNo = 0;
	private int play_noteNumber = 0;
	private int play_velocity = 0;
	private int play_delay = 0;
	private boolean play_releasetriggered = false;

	public void play(int performerIndex, ModelConnectionBlock[] connectionBlocks) {

	int noteNumber = play_noteNumber;
	int velocity = play_velocity;
	int delay = play_delay;
	boolean releasetriggered = play_releasetriggered;

	SoftPerformer p = current_instrument.getPerformer(performerIndex);

	if (firstVoice) {
	firstVoice = false;
	if (p.exclusiveClass != 0) {
	int x = p.exclusiveClass;
	for (int j = 0; j < voices.length; j++) {
	if (voices[j].active && voices[j].channel == channel
	&& voices[j].exclusiveClass == x) {
	if (!(p.selfNonExclusive && voices[j].note == noteNumber))
	voices[j].shutdown();
	}
	}
	}
	}

	voiceNo = findFreeVoice(voiceNo);

	if (voiceNo == -1)
	return;

	initVoice(voices[voiceNo], p, prevVoiceID, noteNumber, velocity, delay,
	connectionBlocks, current_mixer, releasetriggered);
	}

	public void noteOff(int noteNumber) {
	if(noteNumber < 0 \|\| noteNumber > 127) return;
	noteOff_internal(noteNumber, 64);
	}

	public void setPolyPressure(int noteNumber, int pressure) {
	noteNumber = restrict7Bit(noteNumber);
	pressure = restrict7Bit(pressure);

	if (current_mixer != null)
	current_mixer.setPolyPressure(noteNumber, pressure);

	synchronized (control_mutex) {
	mainmixer.activity();
	co_midi[noteNumber].get(0, "poly_pressure")[0] = pressure*(1.0/128.0);
	polypressure[noteNumber] = pressure;
	for (int i = 0; i < voices.length; i++) {
	if (voices[i].active && voices[i].note == noteNumber)
	voices[i].setPolyPressure(pressure);
	}
	}
	}

	public int getPolyPressure(int noteNumber) {
	synchronized (control_mutex) {
	return polypressure[noteNumber];
	}
	}

	public void setChannelPressure(int pressure) {
	pressure = restrict7Bit(pressure);
	if (current_mixer != null)
	current_mixer.setChannelPressure(pressure);
	synchronized (control_mutex) {
	mainmixer.activity();
	co_midi_channel_pressure[0] = pressure * (1.0 / 128.0);
	channelpressure = pressure;
	for (int i = 0; i < voices.length; i++) {
	if (voices[i].active)
	voices[i].setChannelPressure(pressure);
	}
	}
	}

	public int getChannelPressure() {
	synchronized (control_mutex) {
	return channelpressure;
	}
	}

	void applyInstrumentCustomization() {
	if (cds_control_connections == null
	&& cds_channelpressure_connections == null
	&& cds_polypressure_connections == null) {
	return;
	}

	ModelInstrument src_instrument = current_instrument.getSourceInstrument();
	ModelPerformer[] performers = src_instrument.getPerformers();
	ModelPerformer[] new_performers = new ModelPerformer[performers.length];
	for (int i = 0; i < new_performers.length; i++) {
	ModelPerformer performer = performers[i];
	ModelPerformer new_performer = new ModelPerformer();
	new_performer.setName(performer.getName());
	new_performer.setExclusiveClass(performer.getExclusiveClass());
	new_performer.setKeyFrom(performer.getKeyFrom());
	new_performer.setKeyTo(performer.getKeyTo());
	new_performer.setVelFrom(performer.getVelFrom());
	new_performer.setVelTo(performer.getVelTo());
	new_performer.getOscillators().addAll(performer.getOscillators());
	new_performer.getConnectionBlocks().addAll(
	performer.getConnectionBlocks());
	new_performers[i] = new_performer;

	List<ModelConnectionBlock> connblocks =
	new_performer.getConnectionBlocks();

	if (cds_control_connections != null) {
	String cc = Integer.toString(cds_control_number);
	Iterator<ModelConnectionBlock> iter = connblocks.iterator();
	while (iter.hasNext()) {
	ModelConnectionBlock conn = iter.next();
	ModelSource[] sources = conn.getSources();
	boolean removeok = false;
	if (sources != null) {
	for (int j = 0; j < sources.length; j++) {
	ModelSource src = sources[j];
	if ("midi_cc".equals(src.getIdentifier().getObject())
	&& cc.equals(src.getIdentifier().getVariable())) {
	removeok = true;
	}
	}
	}
	if (removeok)
	iter.remove();
	}
	for (int j = 0; j < cds_control_connections.length; j++)
	connblocks.add(cds_control_connections[j]);
	}

	if (cds_polypressure_connections != null) {
	Iterator<ModelConnectionBlock> iter = connblocks.iterator();
	while (iter.hasNext()) {
	ModelConnectionBlock conn = iter.next();
	ModelSource[] sources = conn.getSources();
	boolean removeok = false;
	if (sources != null) {
	for (int j = 0; j < sources.length; j++) {
	ModelSource src = sources[j];
	if ("midi".equals(src.getIdentifier().getObject())
	&& "poly_pressure".equals(
	src.getIdentifier().getVariable())) {
	removeok = true;
	}
	}
	}
	if (removeok)
	iter.remove();
	}
	for (int j = 0; j < cds_polypressure_connections.length; j++)
	connblocks.add(cds_polypressure_connections[j]);
	}


	if (cds_channelpressure_connections != null) {
	Iterator<ModelConnectionBlock> iter = connblocks.iterator();
	while (iter.hasNext()) {
	ModelConnectionBlock conn = iter.next();
	ModelSource[] sources = conn.getSources();
	boolean removeok = false;
	if (sources != null) {
	for (int j = 0; j < sources.length; j++) {
	ModelIdentifier srcid = sources[j].getIdentifier();
	if ("midi".equals(srcid.getObject()) &&
	"channel_pressure".equals(srcid.getVariable())) {
	removeok = true;
	}
	}
	}
	if (removeok)
	iter.remove();
	}
	for (int j = 0; j < cds_channelpressure_connections.length; j++)
	connblocks.add(cds_channelpressure_connections[j]);
	}

	}

	current_instrument = new SoftInstrument(src_instrument, new_performers);

	}

	private ModelConnectionBlock[] createModelConnections(ModelIdentifier sid,
	int[] destination, int[] range) {

	/*
	controlled parameter (pp)\|range (rr)\| Description \|Default
	-------------------------\|----------\|-------------------------\|-------
	00 Pitch Control \| 28H..58H \| -24..+24 semitones \| 40H
	01 Filter Cutoff Control \| 00H..7FH \| -9600..+9450 cents \| 40H
	02 Amplitude Control \| 00H..7FH \| 0..(127/64)*100 percent \| 40H
	03 LFO Pitch Depth \| 00H..7FH \| 0..600 cents \| 0
	04 LFO Filter Depth \| 00H..7FH \| 0..2400 cents \| 0
	05 LFO Amplitude Depth \| 00H..7FH \| 0..100 percent \| 0
	*/

	List<ModelConnectionBlock> conns = new ArrayList<ModelConnectionBlock>();

	for (int i = 0; i < destination.length; i++) {
	int d = destination[i];
	int r = range[i];
	if (d == 0) {
	double scale = (r - 64) * 100;
	ModelConnectionBlock conn = new ModelConnectionBlock(
	new ModelSource(sid,
	ModelStandardTransform.DIRECTION_MIN2MAX,
	ModelStandardTransform.POLARITY_UNIPOLAR,
	ModelStandardTransform.TRANSFORM_LINEAR),
	scale,
	new ModelDestination(
	new ModelIdentifier("osc", "pitch")));
	conns.add(conn);

	}
	if (d == 1) {
	double scale = (r / 64.0 - 1.0) * 9600.0;
	ModelConnectionBlock conn;
	if (scale > 0) {
	conn = new ModelConnectionBlock(
	new ModelSource(sid,
	ModelStandardTransform.DIRECTION_MAX2MIN,
	ModelStandardTransform.POLARITY_UNIPOLAR,
	ModelStandardTransform.TRANSFORM_LINEAR),
	-scale,
	new ModelDestination(
	ModelDestination.DESTINATION_FILTER_FREQ));
	} else {
	conn = new ModelConnectionBlock(
	new ModelSource(sid,
	ModelStandardTransform.DIRECTION_MIN2MAX,
	ModelStandardTransform.POLARITY_UNIPOLAR,
	ModelStandardTransform.TRANSFORM_LINEAR),
	scale,
	new ModelDestination(
	ModelDestination.DESTINATION_FILTER_FREQ));
	}
	conns.add(conn);
	}
	if (d == 2) {
	final double scale = (r / 64.0);
	ModelTransform mt = new ModelTransform() {
	double s = scale;
	public double transform(double value) {
	if (s < 1)
	value = s + (value * (1.0 - s));
	else if (s > 1)
	value = 1 + (value * (s - 1.0));
	else
	return 0;
	return -((5.0 / 12.0) / Math.log(10)) * Math.log(value);
	}
	};

	ModelConnectionBlock conn = new ModelConnectionBlock(
	new ModelSource(sid, mt), -960,
	new ModelDestination(ModelDestination.DESTINATION_GAIN));
	conns.add(conn);

	}
	if (d == 3) {
	double scale = (r / 64.0 - 1.0) * 9600.0;
	ModelConnectionBlock conn = new ModelConnectionBlock(
	new ModelSource(ModelSource.SOURCE_LFO1,
	ModelStandardTransform.DIRECTION_MIN2MAX,
	ModelStandardTransform.POLARITY_BIPOLAR,
	ModelStandardTransform.TRANSFORM_LINEAR),
	new ModelSource(sid,
	ModelStandardTransform.DIRECTION_MIN2MAX,
	ModelStandardTransform.POLARITY_UNIPOLAR,
	ModelStandardTransform.TRANSFORM_LINEAR),
	scale,
	new ModelDestination(
	ModelDestination.DESTINATION_PITCH));
	conns.add(conn);
	}
	if (d == 4) {
	double scale = (r / 128.0) * 2400.0;
	ModelConnectionBlock conn = new ModelConnectionBlock(
	new ModelSource(ModelSource.SOURCE_LFO1,
	ModelStandardTransform.DIRECTION_MIN2MAX,
	ModelStandardTransform.POLARITY_BIPOLAR,
	ModelStandardTransform.TRANSFORM_LINEAR),
	new ModelSource(sid,
	ModelStandardTransform.DIRECTION_MIN2MAX,
	ModelStandardTransform.POLARITY_UNIPOLAR,
	ModelStandardTransform.TRANSFORM_LINEAR),
	scale,
	new ModelDestination(
	ModelDestination.DESTINATION_FILTER_FREQ));
	conns.add(conn);
	}
	if (d == 5) {
	final double scale = (r / 127.0);

	ModelTransform mt = new ModelTransform() {
	double s = scale;
	public double transform(double value) {
	return -((5.0 / 12.0) / Math.log(10))
	* Math.log(1 - value * s);
	}
	};

	ModelConnectionBlock conn = new ModelConnectionBlock(
	new ModelSource(ModelSource.SOURCE_LFO1,
	ModelStandardTransform.DIRECTION_MIN2MAX,
	ModelStandardTransform.POLARITY_UNIPOLAR,
	ModelStandardTransform.TRANSFORM_LINEAR),
	new ModelSource(sid, mt),
	-960,
	new ModelDestination(
	ModelDestination.DESTINATION_GAIN));
	conns.add(conn);
	}
	}

	return conns.toArray(new ModelConnectionBlock[conns.size()]);
	}

	public void mapPolyPressureToDestination(int[] destination, int[] range) {
	current_instrument = null;
	if (destination.length == 0) {
	cds_polypressure_connections = null;
	return;
	}
	cds_polypressure_connections
	= createModelConnections(
	new ModelIdentifier("midi", "poly_pressure"),
	destination, range);
	}

	public void mapChannelPressureToDestination(int[] destination, int[] range) {
	current_instrument = null;
	if (destination.length == 0) {
	cds_channelpressure_connections = null;
	return;
	}
	cds_channelpressure_connections
	= createModelConnections(
	new ModelIdentifier("midi", "channel_pressure"),
	destination, range);
	}

	public void mapControlToDestination(int control, int[] destination, int[] range) {

	if (!((control >= 0x01 && control <= 0x1F)
	\|\| (control >= 0x40 && control <= 0x5F))) {
	cds_control_connections = null;
	return;
	}

	current_instrument = null;
	cds_control_number = control;
	if (destination.length == 0) {
	cds_control_connections = null;
	return;
	}
	cds_control_connections
	= createModelConnections(
	new ModelIdentifier("midi_cc", Integer.toString(control)),
	destination, range);
	}

	public void controlChangePerNote(int noteNumber, int controller, int value) {

	/*
	CC# \| nn \| Name \| vv \| default \| description
	-----\|------\|-------------------------\|----------------\|------------\|-------------------------------
	7 \|07H \|Note Volume \|00H-40H-7FH \|40H \|0-100-(127/64)*100(%)(Relative)
	10 \|0AH \|*Pan \|00H-7FH absolute\|Preset Value\|Left-Center-Right (absolute)
	33-63\|21-3FH\|LSB for \|01H-1FH \| \|
	71 \|47H \|Timbre/Harmonic Intensity\|00H-40H-7FH \|40H (???) \|
	72 \|48H \|Release Time \|00H-40H-7FH \|40H (???) \|
	73 \|49H \|Attack Time \|00H-40H-7FH \|40H (???) \|
	74 \|4AH \|Brightness \|00H-40H-7FH \|40H (???) \|
	75 \|4BH \|Decay Time \|00H-40H-7FH \|40H (???) \|
	76 \|4CH \|Vibrato Rate \|00H-40H-7FH \|40H (???) \|
	77 \|4DH \|Vibrato Depth \|00H-40H-7FH \|40H (???) \|
	78 \|4EH \|Vibrato Delay \|00H-40H-7FH \|40H (???) \|
	91 \|5BH \|*Reverb Send \|00H-7FH absolute\|Preset Value\|Left-Center-Right (absolute)
	93 \|5DH \|*Chorus Send \|00H-7FH absolute\|Preset Value\|Left-Center-Right (absolute)
	120 \|78H \|**Fine Tuning \|00H-40H-7FH \|40H (???) \|
	121 \|79H \|**Coarse Tuning \|00H-40H-7FH \|40H (???) \|
	*/

	if (keybasedcontroller_active == null) {
	keybasedcontroller_active = new boolean[128][];
	keybasedcontroller_value = new double[128][];
	}
	if (keybasedcontroller_active[noteNumber] == null) {
	keybasedcontroller_active[noteNumber] = new boolean[128];
	Arrays.fill(keybasedcontroller_active[noteNumber], false);
	keybasedcontroller_value[noteNumber] = new double[128];
	Arrays.fill(keybasedcontroller_value[noteNumber], 0);
	}

	if (value == -1) {
	keybasedcontroller_active[noteNumber][controller] = false;
	} else {
	keybasedcontroller_active[noteNumber][controller] = true;
	keybasedcontroller_value[noteNumber][controller] = value / 128.0;
	}

	if (controller < 120) {
	for (int i = 0; i < voices.length; i++)
	if (voices[i].active)
	voices[i].controlChange(controller, -1);
	} else if (controller == 120) {
	for (int i = 0; i < voices.length; i++)
	if (voices[i].active)
	voices[i].rpnChange(1, -1);
	} else if (controller == 121) {
	for (int i = 0; i < voices.length; i++)
	if (voices[i].active)
	voices[i].rpnChange(2, -1);
	}

	}

	public int getControlPerNote(int noteNumber, int controller) {
	if (keybasedcontroller_active == null)
	return -1;
	if (keybasedcontroller_active[noteNumber] == null)
	return -1;
	if (!keybasedcontroller_active[noteNumber][controller])
	return -1;
	return (int)(keybasedcontroller_value[noteNumber][controller] * 128);
	}

	public void controlChange(int controller, int value) {
	controller = restrict7Bit(controller);
	value = restrict7Bit(value);
	if (current_mixer != null)
	current_mixer.controlChange(controller, value);

	synchronized (control_mutex) {
	switch (controller) {
	/*
	Map<String, int[]>co_midi_rpn_rpn_i = new HashMap<String, int[]>();
	Map<String, double[]>co_midi_rpn_rpn = new HashMap<String, double[]>();
	Map<String, int[]>co_midi_nrpn_nrpn_i = new HashMap<String, int[]>();
	Map<String, double[]>co_midi_nrpn_nrpn = new HashMap<String, double[]>();
	*/

	case 5:
	// This produce asin-like curve
	// as described in General Midi Level 2 Specification, page 6
	double x = -Math.asin((value / 128.0) * 2 - 1) / Math.PI + 0.5;
	x = Math.pow(100000.0, x) / 100.0; // x is now cent/msec
	// Convert x from cent/msec to key/controlbuffertime
	x = x / 100.0; // x is now keys/msec
	x = x * 1000.0; // x is now keys/sec
	x = x / synthesizer.getControlRate(); // x is now keys/controlbuffertime
	portamento_time = x;
	break;
	case 6:
	case 38:
	case 96:
	case 97:
	int val = 0;
	if (nrpn_control != RPN_NULL_VALUE) {
	int[] val_i = co_midi_nrpn_nrpn_i.get(nrpn_control);
	if (val_i != null)
	val = val_i[0];
	}
	if (rpn_control != RPN_NULL_VALUE) {
	int[] val_i = co_midi_rpn_rpn_i.get(rpn_control);
	if (val_i != null)
	val = val_i[0];
	}

	if (controller == 6)
	val = (val & 127) + (value << 7);
	else if (controller == 38)
	val = (val & (127 << 7)) + value;
	else if (controller == 96 \|\| controller == 97) {
	int step = 1;
	if (rpn_control == 2 \|\| rpn_control == 3 \|\| rpn_control == 4)
	step = 128;
	if (controller == 96)
	val += step;
	if (controller == 97)
	val -= step;
	}

	if (nrpn_control != RPN_NULL_VALUE)
	nrpnChange(nrpn_control, val);
	if (rpn_control != RPN_NULL_VALUE)
	rpnChange(rpn_control, val);

	break;
	case 64: // Hold1 (Damper) (cc#64)
	boolean on = value >= 64;
	if (sustain != on) {
	sustain = on;
	if (!on) {
	for (int i = 0; i < voices.length; i++) {
	if (voices[i].active && voices[i].sustain &&
	voices[i].channel == channel) {
	voices[i].sustain = false;
	if (!voices[i].on) {
	voices[i].on = true;
	voices[i].noteOff(0);
	}
	}
	}
	} else {
	for (int i = 0; i < voices.length; i++)
	if (voices[i].active && voices[i].channel == channel)
	voices[i].redamp();
	}
	}
	break;
	case 65:
	//allNotesOff();
	portamento = value >= 64;
	portamento_lastnote[0] = -1;
	/*
	for (int i = 0; i < portamento_lastnote.length; i++)
	portamento_lastnote[i] = -1;
	*/
	portamento_lastnote_ix = 0;
	break;
	case 66: // Sostenuto (cc#66)
	on = value >= 64;
	if (on) {
	for (int i = 0; i < voices.length; i++) {
	if (voices[i].active && voices[i].on &&
	voices[i].channel == channel) {
	voices[i].sostenuto = true;
	}
	}
	}
	if (!on) {
	for (int i = 0; i < voices.length; i++) {
	if (voices[i].active && voices[i].sostenuto &&
	voices[i].channel == channel) {
	voices[i].sostenuto = false;
	if (!voices[i].on) {
	voices[i].on = true;
	voices[i].noteOff(0);
	}
	}
	}
	}
	break;
	case 98:
	nrpn_control = (nrpn_control & (127 << 7)) + value;
	rpn_control = RPN_NULL_VALUE;
	break;
	case 99:
	nrpn_control = (nrpn_control & 127) + (value << 7);
	rpn_control = RPN_NULL_VALUE;
	break;
	case 100:
	rpn_control = (rpn_control & (127 << 7)) + value;
	nrpn_control = RPN_NULL_VALUE;
	break;
	case 101:
	rpn_control = (rpn_control & 127) + (value << 7);
	nrpn_control = RPN_NULL_VALUE;
	break;
	case 120:
	allSoundOff();
	break;
	case 121:
	resetAllControllers(value == 127);
	break;
	case 122:
	localControl(value >= 64);
	break;
	case 123:
	allNotesOff();
	break;
	case 124:
	setOmni(false);
	break;
	case 125:
	setOmni(true);
	break;
	case 126:
	if (value == 1)
	setMono(true);
	break;
	case 127:
	setMono(false);
	break;

	default:
	break;
	}

	co_midi_cc_cc[controller][0] = value * (1.0 / 128.0);

	if (controller == 0x00) {
	bank = /(bank & 127) +/ (value << 7);
	return;
	}

	if (controller == 0x20) {
	bank = (bank & (127 << 7)) + value;
	return;
	}

	this.controller[controller] = value;
	if(controller < 0x20)
	this.controller[controller + 0x20] = 0;

	for (int i = 0; i < voices.length; i++)
	if (voices[i].active)
	voices[i].controlChange(controller, value);

	}
	}

	public int getController(int controller) {
	synchronized (control_mutex) {
	// Should only return lower 7 bits,
	// even when controller is "boosted" higher.
	return this.controller[controller] & 127;
	}
	}

	public void tuningChange(int program) {
	tuningChange(0, program);
	}

	public void tuningChange(int bank, int program) {
	synchronized (control_mutex) {
	tuning = synthesizer.getTuning(new Patch(bank, program));
	}
	}

	public void programChange(int program) {
	programChange(bank, program);
	}

	public void programChange(int bank, int program) {
	bank = restrict14Bit(bank);
	program = restrict7Bit(program);
	synchronized (control_mutex) {
	mainmixer.activity();
	if(this.bank != bank \|\| this.program != program)
	{
	this.bank = bank;
	this.program = program;
	current_instrument = null;
	}
	}
	}

	public int getProgram() {
	synchronized (control_mutex) {
	return program;
	}
	}

	public void setPitchBend(int bend) {
	bend = restrict14Bit(bend);
	if (current_mixer != null)
	current_mixer.setPitchBend(bend);
	synchronized (control_mutex) {
	mainmixer.activity();
	co_midi_pitch[0] = bend * (1.0 / 16384.0);
	pitchbend = bend;
	for (int i = 0; i < voices.length; i++)
	if (voices[i].active)
	voices[i].setPitchBend(bend);
	}
	}

	public int getPitchBend() {
	synchronized (control_mutex) {
	return pitchbend;
	}
	}

	public void nrpnChange(int controller, int value) {

	/*
	System.out.println("(" + channel + ").nrpnChange("
	+ Integer.toHexString(controller >> 7)
	+ " " + Integer.toHexString(controller & 127)
	+ ", " + Integer.toHexString(value >> 7)
	+ " " + Integer.toHexString(value & 127) + ")");
	*/

	if (synthesizer.getGeneralMidiMode() == 0) {
	if (controller == (0x01 << 7) + (0x08)) // Vibrato Rate
	controlChange(76, value >> 7);
	if (controller == (0x01 << 7) + (0x09)) // Vibrato Depth
	controlChange(77, value >> 7);
	if (controller == (0x01 << 7) + (0x0A)) // Vibrato Delay
	controlChange(78, value >> 7);
	if (controller == (0x01 << 7) + (0x20)) // Brightness
	controlChange(74, value >> 7);
	if (controller == (0x01 << 7) + (0x21)) // Filter Resonance
	controlChange(71, value >> 7);
	if (controller == (0x01 << 7) + (0x63)) // Attack Time
	controlChange(73, value >> 7);
	if (controller == (0x01 << 7) + (0x64)) // Decay Time
	controlChange(75, value >> 7);
	if (controller == (0x01 << 7) + (0x66)) // Release Time
	controlChange(72, value >> 7);

	if (controller >> 7 == 0x18) // Pitch coarse
	controlChangePerNote(controller % 128, 120, value >> 7);
	if (controller >> 7 == 0x1A) // Volume
	controlChangePerNote(controller % 128, 7, value >> 7);
	if (controller >> 7 == 0x1C) // Panpot
	controlChangePerNote(controller % 128, 10, value >> 7);
	if (controller >> 7 == 0x1D) // Reverb
	controlChangePerNote(controller % 128, 91, value >> 7);
	if (controller >> 7 == 0x1E) // Chorus
	controlChangePerNote(controller % 128, 93, value >> 7);
	}

	int[] val_i = co_midi_nrpn_nrpn_i.get(controller);
	double[] val_d = co_midi_nrpn_nrpn.get(controller);
	if (val_i == null) {
	val_i = new int[1];
	co_midi_nrpn_nrpn_i.put(controller, val_i);
	}
	if (val_d == null) {
	val_d = new double[1];
	co_midi_nrpn_nrpn.put(controller, val_d);
	}
	val_i[0] = value;
	val_d[0] = val_i[0] * (1.0 / 16384.0);

	for (int i = 0; i < voices.length; i++)
	if (voices[i].active)
	voices[i].nrpnChange(controller, val_i[0]);

	}

	public void rpnChange(int controller, int value) {

	/*
	System.out.println("(" + channel + ").rpnChange("
	+ Integer.toHexString(controller >> 7)
	+ " " + Integer.toHexString(controller & 127)
	+ ", " + Integer.toHexString(value >> 7)
	+ " " + Integer.toHexString(value & 127) + ")");
	*/

	if (controller == 3) {
	tuning_program = (value >> 7) & 127;
	tuningChange(tuning_bank, tuning_program);
	}
	if (controller == 4) {
	tuning_bank = (value >> 7) & 127;
	}

	int[] val_i = co_midi_rpn_rpn_i.get(controller);
	double[] val_d = co_midi_rpn_rpn.get(controller);
	if (val_i == null) {
	val_i = new int[1];
	co_midi_rpn_rpn_i.put(controller, val_i);
	}
	if (val_d == null) {
	val_d = new double[1];
	co_midi_rpn_rpn.put(controller, val_d);
	}
	val_i[0] = value;
	val_d[0] = val_i[0] * (1.0 / 16384.0);

	for (int i = 0; i < voices.length; i++)
	if (voices[i].active)
	voices[i].rpnChange(controller, val_i[0]);
	}

	public void resetAllControllers() {
	resetAllControllers(false);
	}

	public void resetAllControllers(boolean allControls) {
	synchronized (control_mutex) {
	mainmixer.activity();

	for (int i = 0; i < 128; i++) {
	setPolyPressure(i, 0);
	}
	setChannelPressure(0);
	setPitchBend(8192);
	for (int i = 0; i < 128; i++) {
	if (!dontResetControls[i])
	controlChange(i, 0);
	}

	controlChange(71, 64); // Filter Resonance
	controlChange(72, 64); // Release Time
	controlChange(73, 64); // Attack Time
	controlChange(74, 64); // Brightness
	controlChange(75, 64); // Decay Time
	controlChange(76, 64); // Vibrato Rate
	controlChange(77, 64); // Vibrato Depth
	controlChange(78, 64); // Vibrato Delay

	controlChange(8, 64); // Balance
	controlChange(11, 127); // Expression
	controlChange(98, 127); // NRPN Null
	controlChange(99, 127); // NRPN Null
	controlChange(100, 127); // RPN = Null
	controlChange(101, 127); // RPN = Null

	// see DLS 2.1 (Power-on Default Values)
	if (allControls) {

	keybasedcontroller_active = null;
	keybasedcontroller_value = null;

	controlChange(7, 100); // Volume
	controlChange(10, 64); // Pan
	controlChange(91, 40); // Reverb

	for (int controller : co_midi_rpn_rpn.keySet()) {
	// don't reset tuning settings
	if (controller != 3 && controller != 4)
	rpnChange(controller, 0);
	}
	for (int controller : co_midi_nrpn_nrpn.keySet())
	nrpnChange(controller, 0);
	rpnChange(0, 2 << 7); // Bitch Bend sensitivity
	rpnChange(1, 64 << 7); // Channel fine tunning
	rpnChange(2, 64 << 7); // Channel Coarse Tuning
	rpnChange(5, 64); // Modulation Depth, +/- 50 cent

	tuning_bank = 0;
	tuning_program = 0;
	tuning = new SoftTuning();

	}

	}
	}

	public void allNotesOff() {
	if (current_mixer != null)
	current_mixer.allNotesOff();
	synchronized (control_mutex) {
	for (int i = 0; i < voices.length; i++)
	if (voices[i].on && voices[i].channel == channel
	&& voices[i].releaseTriggered == false) {
	voices[i].noteOff(0);
	}
	}
	}

	public void allSoundOff() {
	if (current_mixer != null)
	current_mixer.allSoundOff();
	synchronized (control_mutex) {
	for (int i = 0; i < voices.length; i++)
	if (voices[i].on && voices[i].channel == channel)
	voices[i].soundOff();
	}
	}

	public boolean localControl(boolean on) {
	return false;
	}

	public void setMono(boolean on) {
	if (current_mixer != null)
	current_mixer.setMono(on);
	synchronized (control_mutex) {
	allNotesOff();
	mono = on;
	}
	}

	public boolean getMono() {
	synchronized (control_mutex) {
	return mono;
	}
	}

	public void setOmni(boolean on) {
	if (current_mixer != null)
	current_mixer.setOmni(on);
	allNotesOff();
	// Omni is not supported by GM2
	}

	public boolean getOmni() {
	return false;
	}

	public void setMute(boolean mute) {
	if (current_mixer != null)
	current_mixer.setMute(mute);
	synchronized (control_mutex) {
	this.mute = mute;
	for (int i = 0; i < voices.length; i++)
	if (voices[i].active && voices[i].channel == channel)
	voices[i].setMute(mute);
	}
	}

	public boolean getMute() {
	synchronized (control_mutex) {
	return mute;
	}
	}

	public void setSolo(boolean soloState) {
	if (current_mixer != null)
	current_mixer.setSolo(soloState);

	synchronized (control_mutex) {
	this.solo = soloState;

	boolean soloinuse = false;
	for (SoftChannel c : synthesizer.channels) {
	if (c.solo) {
	soloinuse = true;
	break;
	}
	}

	if (!soloinuse) {
	for (SoftChannel c : synthesizer.channels)
	c.setSoloMute(false);
	return;
	}

	for (SoftChannel c : synthesizer.channels)
	c.setSoloMute(!c.solo);

	}

	}

	private void setSoloMute(boolean mute) {
	synchronized (control_mutex) {
	if (solomute == mute)
	return;
	this.solomute = mute;
	for (int i = 0; i < voices.length; i++)
	if (voices[i].active && voices[i].channel == channel)
	voices[i].setSoloMute(solomute);
	}
	}

	public boolean getSolo() {
	synchronized (control_mutex) {
	return solo;
	}
	}
	}

Back to index...