| /* |
| * 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.io.IOException; |
| import java.io.InputStream; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Set; |
| import java.util.TreeMap; |
| import java.util.Map.Entry; |
| |
| import javax.sound.midi.MidiMessage; |
| import javax.sound.midi.Patch; |
| import javax.sound.midi.ShortMessage; |
| import javax.sound.sampled.AudioInputStream; |
| import javax.sound.sampled.AudioSystem; |
| |
| /** |
| * Software synthesizer main audio mixer. |
| * |
| * @author Karl Helgason |
| */ |
| public final class SoftMainMixer { |
| |
| // A private class thats contains a ModelChannelMixer and it's private buffers. |
| // This becomes necessary when we want to have separate delay buffers for each channel mixer. |
| private class SoftChannelMixerContainer |
| { |
| ModelChannelMixer mixer; |
| SoftAudioBuffer[] buffers; |
| } |
| |
| public final static int CHANNEL_LEFT = 0; |
| public final static int CHANNEL_RIGHT = 1; |
| public final static int CHANNEL_MONO = 2; |
| public final static int CHANNEL_DELAY_LEFT = 3; |
| public final static int CHANNEL_DELAY_RIGHT = 4; |
| public final static int CHANNEL_DELAY_MONO = 5; |
| public final static int CHANNEL_EFFECT1 = 6; |
| public final static int CHANNEL_EFFECT2 = 7; |
| public final static int CHANNEL_DELAY_EFFECT1 = 8; |
| public final static int CHANNEL_DELAY_EFFECT2 = 9; |
| public final static int CHANNEL_LEFT_DRY = 10; |
| public final static int CHANNEL_RIGHT_DRY = 11; |
| public final static int CHANNEL_SCRATCH1 = 12; |
| public final static int CHANNEL_SCRATCH2 = 13; |
| boolean active_sensing_on = false; |
| private long msec_last_activity = -1; |
| private boolean pusher_silent = false; |
| private int pusher_silent_count = 0; |
| private long sample_pos = 0; |
| boolean readfully = true; |
| private final Object control_mutex; |
| private SoftSynthesizer synth; |
| private float samplerate = 44100; |
| private int nrofchannels = 2; |
| private SoftVoice[] voicestatus = null; |
| private SoftAudioBuffer[] buffers; |
| private SoftReverb reverb; |
| private SoftAudioProcessor chorus; |
| private SoftAudioProcessor agc; |
| private long msec_buffer_len = 0; |
| private int buffer_len = 0; |
| TreeMap<Long, Object> midimessages = new TreeMap<Long, Object>(); |
| private int delay_midievent = 0; |
| private int max_delay_midievent = 0; |
| double last_volume_left = 1.0; |
| double last_volume_right = 1.0; |
| private double[] co_master_balance = new double[1]; |
| private double[] co_master_volume = new double[1]; |
| private double[] co_master_coarse_tuning = new double[1]; |
| private double[] co_master_fine_tuning = new double[1]; |
| private AudioInputStream ais; |
| private Set<SoftChannelMixerContainer> registeredMixers = null; |
| private Set<ModelChannelMixer> stoppedMixers = null; |
| private SoftChannelMixerContainer[] cur_registeredMixers = null; |
| SoftControl co_master = new SoftControl() { |
| |
| double[] balance = co_master_balance; |
| double[] volume = co_master_volume; |
| double[] coarse_tuning = co_master_coarse_tuning; |
| double[] fine_tuning = co_master_fine_tuning; |
| |
| public double[] get(int instance, String name) { |
| if (name == null) |
| return null; |
| if (name.equals("balance")) |
| return balance; |
| if (name.equals("volume")) |
| return volume; |
| if (name.equals("coarse_tuning")) |
| return coarse_tuning; |
| if (name.equals("fine_tuning")) |
| return fine_tuning; |
| return null; |
| } |
| }; |
| |
| private void processSystemExclusiveMessage(byte[] data) { |
| synchronized (synth.control_mutex) { |
| activity(); |
| |
| // Universal Non-Real-Time SysEx |
| if ((data[1] & 0xFF) == 0x7E) { |
| int deviceID = data[2] & 0xFF; |
| if (deviceID == 0x7F || deviceID == synth.getDeviceID()) { |
| int subid1 = data[3] & 0xFF; |
| int subid2; |
| switch (subid1) { |
| case 0x08: // MIDI Tuning Standard |
| subid2 = data[4] & 0xFF; |
| switch (subid2) { |
| case 0x01: // BULK TUNING DUMP |
| { |
| // http://www.midi.org/about-midi/tuning.shtml |
| SoftTuning tuning = synth.getTuning(new Patch(0, |
| data[5] & 0xFF)); |
| tuning.load(data); |
| break; |
| } |
| case 0x04: // KEY-BASED TUNING DUMP |
| case 0x05: // SCALE/OCTAVE TUNING DUMP, 1 byte format |
| case 0x06: // SCALE/OCTAVE TUNING DUMP, 2 byte format |
| case 0x07: // SINGLE NOTE TUNING CHANGE (NON REAL-TIME) |
| // (BANK) |
| { |
| // http://www.midi.org/about-midi/tuning_extens.shtml |
| SoftTuning tuning = synth.getTuning(new Patch( |
| data[5] & 0xFF, data[6] & 0xFF)); |
| tuning.load(data); |
| break; |
| } |
| case 0x08: // scale/octave tuning 1-byte form (Non |
| // Real-Time) |
| case 0x09: // scale/octave tuning 2-byte form (Non |
| // Real-Time) |
| { |
| // http://www.midi.org/about-midi/tuning-scale.shtml |
| SoftTuning tuning = new SoftTuning(data); |
| int channelmask = (data[5] & 0xFF) * 16384 |
| + (data[6] & 0xFF) * 128 + (data[7] & 0xFF); |
| SoftChannel[] channels = synth.channels; |
| for (int i = 0; i < channels.length; i++) |
| if ((channelmask & (1 << i)) != 0) |
| channels[i].tuning = tuning; |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| case 0x09: // General Midi Message |
| subid2 = data[4] & 0xFF; |
| switch (subid2) { |
| case 0x01: // General Midi 1 On |
| synth.setGeneralMidiMode(1); |
| reset(); |
| break; |
| case 0x02: // General Midi Off |
| synth.setGeneralMidiMode(0); |
| reset(); |
| break; |
| case 0x03: // General MidI Level 2 On |
| synth.setGeneralMidiMode(2); |
| reset(); |
| break; |
| default: |
| break; |
| } |
| break; |
| case 0x0A: // DLS Message |
| subid2 = data[4] & 0xFF; |
| switch (subid2) { |
| case 0x01: // DLS On |
| if (synth.getGeneralMidiMode() == 0) |
| synth.setGeneralMidiMode(1); |
| synth.voice_allocation_mode = 1; |
| reset(); |
| break; |
| case 0x02: // DLS Off |
| synth.setGeneralMidiMode(0); |
| synth.voice_allocation_mode = 0; |
| reset(); |
| break; |
| case 0x03: // DLS Static Voice Allocation Off |
| synth.voice_allocation_mode = 0; |
| break; |
| case 0x04: // DLS Static Voice Allocation On |
| synth.voice_allocation_mode = 1; |
| break; |
| default: |
| break; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| } |
| |
| // Universal Real-Time SysEx |
| if ((data[1] & 0xFF) == 0x7F) { |
| int deviceID = data[2] & 0xFF; |
| if (deviceID == 0x7F || deviceID == synth.getDeviceID()) { |
| int subid1 = data[3] & 0xFF; |
| int subid2; |
| switch (subid1) { |
| case 0x04: // Device Control |
| |
| subid2 = data[4] & 0xFF; |
| switch (subid2) { |
| case 0x01: // Master Volume |
| case 0x02: // Master Balane |
| case 0x03: // Master fine tuning |
| case 0x04: // Master coarse tuning |
| int val = (data[5] & 0x7F) |
| + ((data[6] & 0x7F) * 128); |
| if (subid2 == 0x01) |
| setVolume(val); |
| else if (subid2 == 0x02) |
| setBalance(val); |
| else if (subid2 == 0x03) |
| setFineTuning(val); |
| else if (subid2 == 0x04) |
| setCoarseTuning(val); |
| break; |
| case 0x05: // Global Parameter Control |
| int ix = 5; |
| int slotPathLen = (data[ix++] & 0xFF); |
| int paramWidth = (data[ix++] & 0xFF); |
| int valueWidth = (data[ix++] & 0xFF); |
| int[] slotPath = new int[slotPathLen]; |
| for (int i = 0; i < slotPathLen; i++) { |
| int msb = (data[ix++] & 0xFF); |
| int lsb = (data[ix++] & 0xFF); |
| slotPath[i] = msb * 128 + lsb; |
| } |
| int paramCount = (data.length - 1 - ix) |
| / (paramWidth + valueWidth); |
| long[] params = new long[paramCount]; |
| long[] values = new long[paramCount]; |
| for (int i = 0; i < paramCount; i++) { |
| values[i] = 0; |
| for (int j = 0; j < paramWidth; j++) |
| params[i] = params[i] * 128 |
| + (data[ix++] & 0xFF); |
| for (int j = 0; j < valueWidth; j++) |
| values[i] = values[i] * 128 |
| + (data[ix++] & 0xFF); |
| |
| } |
| globalParameterControlChange(slotPath, params, values); |
| break; |
| default: |
| break; |
| } |
| break; |
| |
| case 0x08: // MIDI Tuning Standard |
| subid2 = data[4] & 0xFF; |
| switch (subid2) { |
| case 0x02: // SINGLE NOTE TUNING CHANGE (REAL-TIME) |
| { |
| // http://www.midi.org/about-midi/tuning.shtml |
| SoftTuning tuning = synth.getTuning(new Patch(0, |
| data[5] & 0xFF)); |
| tuning.load(data); |
| SoftVoice[] voices = synth.getVoices(); |
| for (int i = 0; i < voices.length; i++) |
| if (voices[i].active) |
| if (voices[i].tuning == tuning) |
| voices[i].updateTuning(tuning); |
| break; |
| } |
| case 0x07: // SINGLE NOTE TUNING CHANGE (REAL-TIME) |
| // (BANK) |
| { |
| // http://www.midi.org/about-midi/tuning_extens.shtml |
| SoftTuning tuning = synth.getTuning(new Patch( |
| data[5] & 0xFF, data[6] & 0xFF)); |
| tuning.load(data); |
| SoftVoice[] voices = synth.getVoices(); |
| for (int i = 0; i < voices.length; i++) |
| if (voices[i].active) |
| if (voices[i].tuning == tuning) |
| voices[i].updateTuning(tuning); |
| break; |
| } |
| case 0x08: // scale/octave tuning 1-byte form |
| //(Real-Time) |
| case 0x09: // scale/octave tuning 2-byte form |
| // (Real-Time) |
| { |
| // http://www.midi.org/about-midi/tuning-scale.shtml |
| SoftTuning tuning = new SoftTuning(data); |
| int channelmask = (data[5] & 0xFF) * 16384 |
| + (data[6] & 0xFF) * 128 + (data[7] & 0xFF); |
| SoftChannel[] channels = synth.channels; |
| for (int i = 0; i < channels.length; i++) |
| if ((channelmask & (1 << i)) != 0) |
| channels[i].tuning = tuning; |
| SoftVoice[] voices = synth.getVoices(); |
| for (int i = 0; i < voices.length; i++) |
| if (voices[i].active) |
| if ((channelmask & (1 << (voices[i].channel))) != 0) |
| voices[i].updateTuning(tuning); |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| case 0x09: // Control Destination Settings |
| subid2 = data[4] & 0xFF; |
| switch (subid2) { |
| case 0x01: // Channel Pressure |
| { |
| int[] destinations = new int[(data.length - 7) / 2]; |
| int[] ranges = new int[(data.length - 7) / 2]; |
| int ix = 0; |
| for (int j = 6; j < data.length - 1; j += 2) { |
| destinations[ix] = data[j] & 0xFF; |
| ranges[ix] = data[j + 1] & 0xFF; |
| ix++; |
| } |
| int channel = data[5] & 0xFF; |
| SoftChannel softchannel = synth.channels[channel]; |
| softchannel.mapChannelPressureToDestination( |
| destinations, ranges); |
| break; |
| } |
| case 0x02: // Poly Pressure |
| { |
| int[] destinations = new int[(data.length - 7) / 2]; |
| int[] ranges = new int[(data.length - 7) / 2]; |
| int ix = 0; |
| for (int j = 6; j < data.length - 1; j += 2) { |
| destinations[ix] = data[j] & 0xFF; |
| ranges[ix] = data[j + 1] & 0xFF; |
| ix++; |
| } |
| int channel = data[5] & 0xFF; |
| SoftChannel softchannel = synth.channels[channel]; |
| softchannel.mapPolyPressureToDestination( |
| destinations, ranges); |
| break; |
| } |
| case 0x03: // Control Change |
| { |
| int[] destinations = new int[(data.length - 7) / 2]; |
| int[] ranges = new int[(data.length - 7) / 2]; |
| int ix = 0; |
| for (int j = 7; j < data.length - 1; j += 2) { |
| destinations[ix] = data[j] & 0xFF; |
| ranges[ix] = data[j + 1] & 0xFF; |
| ix++; |
| } |
| int channel = data[5] & 0xFF; |
| SoftChannel softchannel = synth.channels[channel]; |
| int control = data[6] & 0xFF; |
| softchannel.mapControlToDestination(control, |
| destinations, ranges); |
| break; |
| } |
| default: |
| break; |
| } |
| break; |
| |
| case 0x0A: // Key Based Instrument Control |
| { |
| subid2 = data[4] & 0xFF; |
| switch (subid2) { |
| case 0x01: // Basic Message |
| int channel = data[5] & 0xFF; |
| int keynumber = data[6] & 0xFF; |
| SoftChannel softchannel = synth.channels[channel]; |
| for (int j = 7; j < data.length - 1; j += 2) { |
| int controlnumber = data[j] & 0xFF; |
| int controlvalue = data[j + 1] & 0xFF; |
| softchannel.controlChangePerNote(keynumber, |
| controlnumber, controlvalue); |
| } |
| break; |
| default: |
| break; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| } |
| |
| } |
| } |
| |
| private void processMessages(long timeStamp) { |
| Iterator<Entry<Long, Object>> iter = midimessages.entrySet().iterator(); |
| while (iter.hasNext()) { |
| Entry<Long, Object> entry = iter.next(); |
| if (entry.getKey() >= (timeStamp + msec_buffer_len)) |
| return; |
| long msec_delay = entry.getKey() - timeStamp; |
| delay_midievent = (int)(msec_delay * (samplerate / 1000000.0) + 0.5); |
| if(delay_midievent > max_delay_midievent) |
| delay_midievent = max_delay_midievent; |
| if(delay_midievent < 0) |
| delay_midievent = 0; |
| processMessage(entry.getValue()); |
| iter.remove(); |
| } |
| delay_midievent = 0; |
| } |
| |
| void processAudioBuffers() { |
| |
| if(synth.weakstream != null && synth.weakstream.silent_samples != 0) |
| { |
| sample_pos += synth.weakstream.silent_samples; |
| synth.weakstream.silent_samples = 0; |
| } |
| |
| for (int i = 0; i < buffers.length; i++) { |
| if(i != CHANNEL_DELAY_LEFT && |
| i != CHANNEL_DELAY_RIGHT && |
| i != CHANNEL_DELAY_MONO && |
| i != CHANNEL_DELAY_EFFECT1 && |
| i != CHANNEL_DELAY_EFFECT2) |
| buffers[i].clear(); |
| } |
| |
| if(!buffers[CHANNEL_DELAY_LEFT].isSilent()) |
| { |
| buffers[CHANNEL_LEFT].swap(buffers[CHANNEL_DELAY_LEFT]); |
| } |
| if(!buffers[CHANNEL_DELAY_RIGHT].isSilent()) |
| { |
| buffers[CHANNEL_RIGHT].swap(buffers[CHANNEL_DELAY_RIGHT]); |
| } |
| if(!buffers[CHANNEL_DELAY_MONO].isSilent()) |
| { |
| buffers[CHANNEL_MONO].swap(buffers[CHANNEL_DELAY_MONO]); |
| } |
| if(!buffers[CHANNEL_DELAY_EFFECT1].isSilent()) |
| { |
| buffers[CHANNEL_EFFECT1].swap(buffers[CHANNEL_DELAY_EFFECT1]); |
| } |
| if(!buffers[CHANNEL_DELAY_EFFECT2].isSilent()) |
| { |
| buffers[CHANNEL_EFFECT2].swap(buffers[CHANNEL_DELAY_EFFECT2]); |
| } |
| |
| double volume_left; |
| double volume_right; |
| |
| SoftChannelMixerContainer[] act_registeredMixers; |
| |
| // perform control logic |
| synchronized (control_mutex) { |
| |
| long msec_pos = (long)(sample_pos * (1000000.0 / samplerate)); |
| |
| processMessages(msec_pos); |
| |
| if (active_sensing_on) { |
| // Active Sensing |
| // if no message occurs for max 1000 ms |
| // then do AllSoundOff on all channels |
| if ((msec_pos - msec_last_activity) > 1000000) { |
| active_sensing_on = false; |
| for (SoftChannel c : synth.channels) |
| c.allSoundOff(); |
| } |
| |
| } |
| |
| for (int i = 0; i < voicestatus.length; i++) |
| if (voicestatus[i].active) |
| voicestatus[i].processControlLogic(); |
| sample_pos += buffer_len; |
| |
| double volume = co_master_volume[0]; |
| volume_left = volume; |
| volume_right = volume; |
| |
| double balance = co_master_balance[0]; |
| if (balance > 0.5) |
| volume_left *= (1 - balance) * 2; |
| else |
| volume_right *= balance * 2; |
| |
| chorus.processControlLogic(); |
| reverb.processControlLogic(); |
| agc.processControlLogic(); |
| |
| if (cur_registeredMixers == null) { |
| if (registeredMixers != null) { |
| cur_registeredMixers = |
| new SoftChannelMixerContainer[registeredMixers.size()]; |
| registeredMixers.toArray(cur_registeredMixers); |
| } |
| } |
| |
| act_registeredMixers = cur_registeredMixers; |
| if (act_registeredMixers != null) |
| if (act_registeredMixers.length == 0) |
| act_registeredMixers = null; |
| |
| } |
| |
| if (act_registeredMixers != null) { |
| |
| // Make backup of left,right,mono channels |
| SoftAudioBuffer leftbak = buffers[CHANNEL_LEFT]; |
| SoftAudioBuffer rightbak = buffers[CHANNEL_RIGHT]; |
| SoftAudioBuffer monobak = buffers[CHANNEL_MONO]; |
| SoftAudioBuffer delayleftbak = buffers[CHANNEL_DELAY_LEFT]; |
| SoftAudioBuffer delayrightbak = buffers[CHANNEL_DELAY_RIGHT]; |
| SoftAudioBuffer delaymonobak = buffers[CHANNEL_DELAY_MONO]; |
| |
| int bufferlen = buffers[CHANNEL_LEFT].getSize(); |
| |
| float[][] cbuffer = new float[nrofchannels][]; |
| float[][] obuffer = new float[nrofchannels][]; |
| obuffer[0] = leftbak.array(); |
| if (nrofchannels != 1) |
| obuffer[1] = rightbak.array(); |
| |
| for (SoftChannelMixerContainer cmixer : act_registeredMixers) { |
| |
| // Reroute default left,right output |
| // to channelmixer left,right input/output |
| buffers[CHANNEL_LEFT] = cmixer.buffers[CHANNEL_LEFT]; |
| buffers[CHANNEL_RIGHT] = cmixer.buffers[CHANNEL_RIGHT]; |
| buffers[CHANNEL_MONO] = cmixer.buffers[CHANNEL_MONO]; |
| buffers[CHANNEL_DELAY_LEFT] = cmixer.buffers[CHANNEL_DELAY_LEFT]; |
| buffers[CHANNEL_DELAY_RIGHT] = cmixer.buffers[CHANNEL_DELAY_RIGHT]; |
| buffers[CHANNEL_DELAY_MONO] = cmixer.buffers[CHANNEL_DELAY_MONO]; |
| |
| buffers[CHANNEL_LEFT].clear(); |
| buffers[CHANNEL_RIGHT].clear(); |
| buffers[CHANNEL_MONO].clear(); |
| |
| if(!buffers[CHANNEL_DELAY_LEFT].isSilent()) |
| { |
| buffers[CHANNEL_LEFT].swap(buffers[CHANNEL_DELAY_LEFT]); |
| } |
| if(!buffers[CHANNEL_DELAY_RIGHT].isSilent()) |
| { |
| buffers[CHANNEL_RIGHT].swap(buffers[CHANNEL_DELAY_RIGHT]); |
| } |
| if(!buffers[CHANNEL_DELAY_MONO].isSilent()) |
| { |
| buffers[CHANNEL_MONO].swap(buffers[CHANNEL_DELAY_MONO]); |
| } |
| |
| cbuffer[0] = buffers[CHANNEL_LEFT].array(); |
| if (nrofchannels != 1) |
| cbuffer[1] = buffers[CHANNEL_RIGHT].array(); |
| |
| boolean hasactivevoices = false; |
| for (int i = 0; i < voicestatus.length; i++) |
| if (voicestatus[i].active) |
| if (voicestatus[i].channelmixer == cmixer.mixer) { |
| voicestatus[i].processAudioLogic(buffers); |
| hasactivevoices = true; |
| } |
| |
| if(!buffers[CHANNEL_MONO].isSilent()) |
| { |
| float[] mono = buffers[CHANNEL_MONO].array(); |
| float[] left = buffers[CHANNEL_LEFT].array(); |
| if (nrofchannels != 1) { |
| float[] right = buffers[CHANNEL_RIGHT].array(); |
| for (int i = 0; i < bufferlen; i++) { |
| float v = mono[i]; |
| left[i] += v; |
| right[i] += v; |
| } |
| } |
| else |
| { |
| for (int i = 0; i < bufferlen; i++) { |
| left[i] += mono[i]; |
| } |
| } |
| } |
| |
| if (!cmixer.mixer.process(cbuffer, 0, bufferlen)) { |
| synchronized (control_mutex) { |
| registeredMixers.remove(cmixer); |
| cur_registeredMixers = null; |
| } |
| } |
| |
| for (int i = 0; i < cbuffer.length; i++) { |
| float[] cbuff = cbuffer[i]; |
| float[] obuff = obuffer[i]; |
| for (int j = 0; j < bufferlen; j++) |
| obuff[j] += cbuff[j]; |
| } |
| |
| if (!hasactivevoices) { |
| synchronized (control_mutex) { |
| if (stoppedMixers != null) { |
| if (stoppedMixers.contains(cmixer)) { |
| stoppedMixers.remove(cmixer); |
| cmixer.mixer.stop(); |
| } |
| } |
| } |
| } |
| |
| } |
| |
| buffers[CHANNEL_LEFT] = leftbak; |
| buffers[CHANNEL_RIGHT] = rightbak; |
| buffers[CHANNEL_MONO] = monobak; |
| buffers[CHANNEL_DELAY_LEFT] = delayleftbak; |
| buffers[CHANNEL_DELAY_RIGHT] = delayrightbak; |
| buffers[CHANNEL_DELAY_MONO] = delaymonobak; |
| |
| } |
| |
| for (int i = 0; i < voicestatus.length; i++) |
| if (voicestatus[i].active) |
| if (voicestatus[i].channelmixer == null) |
| voicestatus[i].processAudioLogic(buffers); |
| |
| if(!buffers[CHANNEL_MONO].isSilent()) |
| { |
| float[] mono = buffers[CHANNEL_MONO].array(); |
| float[] left = buffers[CHANNEL_LEFT].array(); |
| int bufferlen = buffers[CHANNEL_LEFT].getSize(); |
| if (nrofchannels != 1) { |
| float[] right = buffers[CHANNEL_RIGHT].array(); |
| for (int i = 0; i < bufferlen; i++) { |
| float v = mono[i]; |
| left[i] += v; |
| right[i] += v; |
| } |
| } |
| else |
| { |
| for (int i = 0; i < bufferlen; i++) { |
| left[i] += mono[i]; |
| } |
| } |
| } |
| |
| // Run effects |
| if (synth.chorus_on) |
| chorus.processAudio(); |
| |
| if (synth.reverb_on) |
| reverb.processAudio(); |
| |
| if (nrofchannels == 1) |
| volume_left = (volume_left + volume_right) / 2; |
| |
| // Set Volume / Balance |
| if (last_volume_left != volume_left || last_volume_right != volume_right) { |
| float[] left = buffers[CHANNEL_LEFT].array(); |
| float[] right = buffers[CHANNEL_RIGHT].array(); |
| int bufferlen = buffers[CHANNEL_LEFT].getSize(); |
| |
| float amp; |
| float amp_delta; |
| amp = (float)(last_volume_left * last_volume_left); |
| amp_delta = (float)((volume_left * volume_left - amp) / bufferlen); |
| for (int i = 0; i < bufferlen; i++) { |
| amp += amp_delta; |
| left[i] *= amp; |
| } |
| if (nrofchannels != 1) { |
| amp = (float)(last_volume_right * last_volume_right); |
| amp_delta = (float)((volume_right*volume_right - amp) / bufferlen); |
| for (int i = 0; i < bufferlen; i++) { |
| amp += amp_delta; |
| right[i] *= volume_right; |
| } |
| } |
| last_volume_left = volume_left; |
| last_volume_right = volume_right; |
| |
| } else { |
| if (volume_left != 1.0 || volume_right != 1.0) { |
| float[] left = buffers[CHANNEL_LEFT].array(); |
| float[] right = buffers[CHANNEL_RIGHT].array(); |
| int bufferlen = buffers[CHANNEL_LEFT].getSize(); |
| float amp; |
| amp = (float) (volume_left * volume_left); |
| for (int i = 0; i < bufferlen; i++) |
| left[i] *= amp; |
| if (nrofchannels != 1) { |
| amp = (float)(volume_right * volume_right); |
| for (int i = 0; i < bufferlen; i++) |
| right[i] *= amp; |
| } |
| |
| } |
| } |
| |
| if(buffers[CHANNEL_LEFT].isSilent() |
| && buffers[CHANNEL_RIGHT].isSilent()) |
| { |
| |
| int midimessages_size; |
| synchronized (control_mutex) { |
| midimessages_size = midimessages.size(); |
| } |
| |
| if(midimessages_size == 0) |
| { |
| pusher_silent_count++; |
| if(pusher_silent_count > 5) |
| { |
| pusher_silent_count = 0; |
| synchronized (control_mutex) { |
| pusher_silent = true; |
| if(synth.weakstream != null) |
| synth.weakstream.setInputStream(null); |
| } |
| } |
| } |
| } |
| else |
| pusher_silent_count = 0; |
| |
| if (synth.agc_on) |
| agc.processAudio(); |
| |
| } |
| |
| // Must only we called within control_mutex synchronization |
| public void activity() |
| { |
| long silent_samples = 0; |
| if(pusher_silent) |
| { |
| pusher_silent = false; |
| if(synth.weakstream != null) |
| { |
| synth.weakstream.setInputStream(ais); |
| silent_samples = synth.weakstream.silent_samples; |
| } |
| } |
| msec_last_activity = (long)((sample_pos + silent_samples) |
| * (1000000.0 / samplerate)); |
| } |
| |
| public void stopMixer(ModelChannelMixer mixer) { |
| if (stoppedMixers == null) |
| stoppedMixers = new HashSet<ModelChannelMixer>(); |
| stoppedMixers.add(mixer); |
| } |
| |
| public void registerMixer(ModelChannelMixer mixer) { |
| if (registeredMixers == null) |
| registeredMixers = new HashSet<SoftChannelMixerContainer>(); |
| SoftChannelMixerContainer mixercontainer = new SoftChannelMixerContainer(); |
| mixercontainer.buffers = new SoftAudioBuffer[6]; |
| for (int i = 0; i < mixercontainer.buffers.length; i++) { |
| mixercontainer.buffers[i] = |
| new SoftAudioBuffer(buffer_len, synth.getFormat()); |
| } |
| mixercontainer.mixer = mixer; |
| registeredMixers.add(mixercontainer); |
| cur_registeredMixers = null; |
| } |
| |
| public SoftMainMixer(SoftSynthesizer synth) { |
| this.synth = synth; |
| |
| sample_pos = 0; |
| |
| co_master_balance[0] = 0.5; |
| co_master_volume[0] = 1; |
| co_master_coarse_tuning[0] = 0.5; |
| co_master_fine_tuning[0] = 0.5; |
| |
| msec_buffer_len = (long) (1000000.0 / synth.getControlRate()); |
| samplerate = synth.getFormat().getSampleRate(); |
| nrofchannels = synth.getFormat().getChannels(); |
| |
| int buffersize = (int) (synth.getFormat().getSampleRate() |
| / synth.getControlRate()); |
| |
| buffer_len = buffersize; |
| |
| max_delay_midievent = buffersize; |
| |
| control_mutex = synth.control_mutex; |
| buffers = new SoftAudioBuffer[14]; |
| for (int i = 0; i < buffers.length; i++) { |
| buffers[i] = new SoftAudioBuffer(buffersize, synth.getFormat()); |
| } |
| voicestatus = synth.getVoices(); |
| |
| reverb = new SoftReverb(); |
| chorus = new SoftChorus(); |
| agc = new SoftLimiter(); |
| |
| float samplerate = synth.getFormat().getSampleRate(); |
| float controlrate = synth.getControlRate(); |
| reverb.init(samplerate, controlrate); |
| chorus.init(samplerate, controlrate); |
| agc.init(samplerate, controlrate); |
| |
| reverb.setLightMode(synth.reverb_light); |
| |
| reverb.setMixMode(true); |
| chorus.setMixMode(true); |
| agc.setMixMode(false); |
| |
| chorus.setInput(0, buffers[CHANNEL_EFFECT2]); |
| chorus.setOutput(0, buffers[CHANNEL_LEFT]); |
| if (nrofchannels != 1) |
| chorus.setOutput(1, buffers[CHANNEL_RIGHT]); |
| chorus.setOutput(2, buffers[CHANNEL_EFFECT1]); |
| |
| reverb.setInput(0, buffers[CHANNEL_EFFECT1]); |
| reverb.setOutput(0, buffers[CHANNEL_LEFT]); |
| if (nrofchannels != 1) |
| reverb.setOutput(1, buffers[CHANNEL_RIGHT]); |
| |
| agc.setInput(0, buffers[CHANNEL_LEFT]); |
| if (nrofchannels != 1) |
| agc.setInput(1, buffers[CHANNEL_RIGHT]); |
| agc.setOutput(0, buffers[CHANNEL_LEFT]); |
| if (nrofchannels != 1) |
| agc.setOutput(1, buffers[CHANNEL_RIGHT]); |
| |
| InputStream in = new InputStream() { |
| |
| private final SoftAudioBuffer[] buffers = SoftMainMixer.this.buffers; |
| private final int nrofchannels |
| = SoftMainMixer.this.synth.getFormat().getChannels(); |
| private final int buffersize = buffers[0].getSize(); |
| private final byte[] bbuffer = new byte[buffersize |
| * (SoftMainMixer.this.synth.getFormat() |
| .getSampleSizeInBits() / 8) |
| * nrofchannels]; |
| private int bbuffer_pos = 0; |
| private final byte[] single = new byte[1]; |
| |
| public void fillBuffer() { |
| /* |
| boolean pusher_silent2; |
| synchronized (control_mutex) { |
| pusher_silent2 = pusher_silent; |
| } |
| if(!pusher_silent2)*/ |
| processAudioBuffers(); |
| for (int i = 0; i < nrofchannels; i++) |
| buffers[i].get(bbuffer, i); |
| bbuffer_pos = 0; |
| } |
| |
| public int read(byte[] b, int off, int len) { |
| int bbuffer_len = bbuffer.length; |
| int offlen = off + len; |
| int orgoff = off; |
| byte[] bbuffer = this.bbuffer; |
| while (off < offlen) { |
| if (available() == 0) |
| fillBuffer(); |
| else { |
| int bbuffer_pos = this.bbuffer_pos; |
| while (off < offlen && bbuffer_pos < bbuffer_len) |
| b[off++] = bbuffer[bbuffer_pos++]; |
| this.bbuffer_pos = bbuffer_pos; |
| if (!readfully) |
| return off - orgoff; |
| } |
| } |
| return len; |
| } |
| |
| public int read() throws IOException { |
| int ret = read(single); |
| if (ret == -1) |
| return -1; |
| return single[0] & 0xFF; |
| } |
| |
| public int available() { |
| return bbuffer.length - bbuffer_pos; |
| } |
| |
| public void close() { |
| SoftMainMixer.this.synth.close(); |
| } |
| }; |
| |
| ais = new AudioInputStream(in, synth.getFormat(), AudioSystem.NOT_SPECIFIED); |
| |
| } |
| |
| public AudioInputStream getInputStream() { |
| return ais; |
| } |
| |
| public void reset() { |
| |
| SoftChannel[] channels = synth.channels; |
| for (int i = 0; i < channels.length; i++) { |
| channels[i].allSoundOff(); |
| channels[i].resetAllControllers(true); |
| |
| if (synth.getGeneralMidiMode() == 2) { |
| if (i == 9) |
| channels[i].programChange(0, 0x78 * 128); |
| else |
| channels[i].programChange(0, 0x79 * 128); |
| } else |
| channels[i].programChange(0, 0); |
| } |
| setVolume(0x7F * 128 + 0x7F); |
| setBalance(0x40 * 128 + 0x00); |
| setCoarseTuning(0x40 * 128 + 0x00); |
| setFineTuning(0x40 * 128 + 0x00); |
| // Reset Reverb |
| globalParameterControlChange( |
| new int[]{0x01 * 128 + 0x01}, new long[]{0}, new long[]{4}); |
| // Reset Chorus |
| globalParameterControlChange( |
| new int[]{0x01 * 128 + 0x02}, new long[]{0}, new long[]{2}); |
| } |
| |
| public void setVolume(int value) { |
| synchronized (control_mutex) { |
| co_master_volume[0] = value / 16384.0; |
| } |
| } |
| |
| public void setBalance(int value) { |
| synchronized (control_mutex) { |
| co_master_balance[0] = value / 16384.0; |
| } |
| } |
| |
| public void setFineTuning(int value) { |
| synchronized (control_mutex) { |
| co_master_fine_tuning[0] = value / 16384.0; |
| } |
| } |
| |
| public void setCoarseTuning(int value) { |
| synchronized (control_mutex) { |
| co_master_coarse_tuning[0] = value / 16384.0; |
| } |
| } |
| |
| public int getVolume() { |
| synchronized (control_mutex) { |
| return (int) (co_master_volume[0] * 16384.0); |
| } |
| } |
| |
| public int getBalance() { |
| synchronized (control_mutex) { |
| return (int) (co_master_balance[0] * 16384.0); |
| } |
| } |
| |
| public int getFineTuning() { |
| synchronized (control_mutex) { |
| return (int) (co_master_fine_tuning[0] * 16384.0); |
| } |
| } |
| |
| public int getCoarseTuning() { |
| synchronized (control_mutex) { |
| return (int) (co_master_coarse_tuning[0] * 16384.0); |
| } |
| } |
| |
| public void globalParameterControlChange(int[] slothpath, long[] params, |
| long[] paramsvalue) { |
| if (slothpath.length == 0) |
| return; |
| |
| synchronized (control_mutex) { |
| |
| // slothpath: 01xx are reserved only for GM2 |
| |
| if (slothpath[0] == 0x01 * 128 + 0x01) { |
| for (int i = 0; i < paramsvalue.length; i++) { |
| reverb.globalParameterControlChange(slothpath, params[i], |
| paramsvalue[i]); |
| } |
| } |
| if (slothpath[0] == 0x01 * 128 + 0x02) { |
| for (int i = 0; i < paramsvalue.length; i++) { |
| chorus.globalParameterControlChange(slothpath, params[i], |
| paramsvalue[i]); |
| } |
| |
| } |
| |
| } |
| } |
| |
| public void processMessage(Object object) { |
| if (object instanceof byte[]) |
| processMessage((byte[]) object); |
| if (object instanceof MidiMessage) |
| processMessage((MidiMessage)object); |
| } |
| |
| public void processMessage(MidiMessage message) { |
| if (message instanceof ShortMessage) { |
| ShortMessage sms = (ShortMessage)message; |
| processMessage(sms.getChannel(), sms.getCommand(), |
| sms.getData1(), sms.getData2()); |
| return; |
| } |
| processMessage(message.getMessage()); |
| } |
| |
| public void processMessage(byte[] data) { |
| int status = 0; |
| if (data.length > 0) |
| status = data[0] & 0xFF; |
| |
| if (status == 0xF0) { |
| processSystemExclusiveMessage(data); |
| return; |
| } |
| |
| int cmd = (status & 0xF0); |
| int ch = (status & 0x0F); |
| |
| int data1; |
| int data2; |
| if (data.length > 1) |
| data1 = data[1] & 0xFF; |
| else |
| data1 = 0; |
| if (data.length > 2) |
| data2 = data[2] & 0xFF; |
| else |
| data2 = 0; |
| |
| processMessage(ch, cmd, data1, data2); |
| |
| } |
| |
| public void processMessage(int ch, int cmd, int data1, int data2) { |
| synchronized (synth.control_mutex) { |
| activity(); |
| } |
| |
| if (cmd == 0xF0) { |
| int status = cmd | ch; |
| switch (status) { |
| case ShortMessage.ACTIVE_SENSING: |
| synchronized (synth.control_mutex) { |
| active_sensing_on = true; |
| } |
| break; |
| default: |
| break; |
| } |
| return; |
| } |
| |
| SoftChannel[] channels = synth.channels; |
| if (ch >= channels.length) |
| return; |
| SoftChannel softchannel = channels[ch]; |
| |
| switch (cmd) { |
| case ShortMessage.NOTE_ON: |
| if(delay_midievent != 0) |
| softchannel.noteOn(data1, data2, delay_midievent); |
| else |
| softchannel.noteOn(data1, data2); |
| break; |
| case ShortMessage.NOTE_OFF: |
| softchannel.noteOff(data1, data2); |
| break; |
| case ShortMessage.POLY_PRESSURE: |
| softchannel.setPolyPressure(data1, data2); |
| break; |
| case ShortMessage.CONTROL_CHANGE: |
| softchannel.controlChange(data1, data2); |
| break; |
| case ShortMessage.PROGRAM_CHANGE: |
| softchannel.programChange(data1); |
| break; |
| case ShortMessage.CHANNEL_PRESSURE: |
| softchannel.setChannelPressure(data1); |
| break; |
| case ShortMessage.PITCH_BEND: |
| softchannel.setPitchBend(data1 + data2 * 128); |
| break; |
| default: |
| break; |
| } |
| |
| } |
| |
| public long getMicrosecondPosition() { |
| if(pusher_silent) |
| { |
| if(synth.weakstream != null) |
| { |
| return (long)((sample_pos + synth.weakstream.silent_samples) |
| * (1000000.0 / samplerate)); |
| } |
| } |
| return (long)(sample_pos * (1000000.0 / samplerate)); |
| } |
| |
| public void close() { |
| } |
| } |
