| /* |
| * 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.util.Arrays; |
| import java.util.HashMap; |
| import java.util.Map; |
| |
| import javax.sound.midi.VoiceStatus; |
| |
| /** |
| * Software synthesizer voice class. |
| * |
| * @author Karl Helgason |
| */ |
| public final class SoftVoice extends VoiceStatus { |
| |
| public int exclusiveClass = 0; |
| public boolean releaseTriggered = false; |
| private int noteOn_noteNumber = 0; |
| private int noteOn_velocity = 0; |
| private int noteOff_velocity = 0; |
| private int delay = 0; |
| ModelChannelMixer channelmixer = null; |
| double tunedKey = 0; |
| SoftTuning tuning = null; |
| SoftChannel stealer_channel = null; |
| ModelConnectionBlock[] stealer_extendedConnectionBlocks = null; |
| SoftPerformer stealer_performer = null; |
| ModelChannelMixer stealer_channelmixer = null; |
| int stealer_voiceID = -1; |
| int stealer_noteNumber = 0; |
| int stealer_velocity = 0; |
| boolean stealer_releaseTriggered = false; |
| int voiceID = -1; |
| boolean sustain = false; |
| boolean sostenuto = false; |
| boolean portamento = false; |
| private final SoftFilter filter_left; |
| private final SoftFilter filter_right; |
| private final SoftProcess eg = new SoftEnvelopeGenerator(); |
| private final SoftProcess lfo = new SoftLowFrequencyOscillator(); |
| Map<String, SoftControl> objects = |
| new HashMap<String, SoftControl>(); |
| SoftSynthesizer synthesizer; |
| SoftInstrument instrument; |
| SoftPerformer performer; |
| SoftChannel softchannel = null; |
| boolean on = false; |
| private boolean audiostarted = false; |
| private boolean started = false; |
| private boolean stopping = false; |
| private float osc_attenuation = 0.0f; |
| private ModelOscillatorStream osc_stream; |
| private int osc_stream_nrofchannels; |
| private float[][] osc_buff = new float[2][]; |
| private boolean osc_stream_off_transmitted = false; |
| private boolean out_mixer_end = false; |
| private float out_mixer_left = 0; |
| private float out_mixer_right = 0; |
| private float out_mixer_effect1 = 0; |
| private float out_mixer_effect2 = 0; |
| private float last_out_mixer_left = 0; |
| private float last_out_mixer_right = 0; |
| private float last_out_mixer_effect1 = 0; |
| private float last_out_mixer_effect2 = 0; |
| ModelConnectionBlock[] extendedConnectionBlocks = null; |
| private ModelConnectionBlock[] connections; |
| // Last value added to destination |
| private double[] connections_last = new double[50]; |
| // Pointer to source value |
| private double[][][] connections_src = new double[50][3][]; |
| // Key-based override (if any) |
| private int[][] connections_src_kc = new int[50][3]; |
| // Pointer to destination value |
| private double[][] connections_dst = new double[50][]; |
| private boolean soundoff = false; |
| private float lastMuteValue = 0; |
| private float lastSoloMuteValue = 0; |
| double[] co_noteon_keynumber = new double[1]; |
| double[] co_noteon_velocity = new double[1]; |
| double[] co_noteon_on = new double[1]; |
| private final SoftControl co_noteon = new SoftControl() { |
| double[] keynumber = co_noteon_keynumber; |
| double[] velocity = co_noteon_velocity; |
| double[] on = co_noteon_on; |
| public double[] get(int instance, String name) { |
| if (name == null) |
| return null; |
| if (name.equals("keynumber")) |
| return keynumber; |
| if (name.equals("velocity")) |
| return velocity; |
| if (name.equals("on")) |
| return on; |
| return null; |
| } |
| }; |
| private final double[] co_mixer_active = new double[1]; |
| private final double[] co_mixer_gain = new double[1]; |
| private final double[] co_mixer_pan = new double[1]; |
| private final double[] co_mixer_balance = new double[1]; |
| private final double[] co_mixer_reverb = new double[1]; |
| private final double[] co_mixer_chorus = new double[1]; |
| private final SoftControl co_mixer = new SoftControl() { |
| double[] active = co_mixer_active; |
| double[] gain = co_mixer_gain; |
| double[] pan = co_mixer_pan; |
| double[] balance = co_mixer_balance; |
| double[] reverb = co_mixer_reverb; |
| double[] chorus = co_mixer_chorus; |
| public double[] get(int instance, String name) { |
| if (name == null) |
| return null; |
| if (name.equals("active")) |
| return active; |
| if (name.equals("gain")) |
| return gain; |
| if (name.equals("pan")) |
| return pan; |
| if (name.equals("balance")) |
| return balance; |
| if (name.equals("reverb")) |
| return reverb; |
| if (name.equals("chorus")) |
| return chorus; |
| return null; |
| } |
| }; |
| private final double[] co_osc_pitch = new double[1]; |
| private final SoftControl co_osc = new SoftControl() { |
| double[] pitch = co_osc_pitch; |
| public double[] get(int instance, String name) { |
| if (name == null) |
| return null; |
| if (name.equals("pitch")) |
| return pitch; |
| return null; |
| } |
| }; |
| private final double[] co_filter_freq = new double[1]; |
| private final double[] co_filter_type = new double[1]; |
| private final double[] co_filter_q = new double[1]; |
| private final SoftControl co_filter = new SoftControl() { |
| double[] freq = co_filter_freq; |
| double[] ftype = co_filter_type; |
| double[] q = co_filter_q; |
| public double[] get(int instance, String name) { |
| if (name == null) |
| return null; |
| if (name.equals("freq")) |
| return freq; |
| if (name.equals("type")) |
| return ftype; |
| if (name.equals("q")) |
| return q; |
| return null; |
| } |
| }; |
| SoftResamplerStreamer resampler; |
| private final int nrofchannels; |
| |
| public SoftVoice(SoftSynthesizer synth) { |
| synthesizer = synth; |
| filter_left = new SoftFilter(synth.getFormat().getSampleRate()); |
| filter_right = new SoftFilter(synth.getFormat().getSampleRate()); |
| nrofchannels = synth.getFormat().getChannels(); |
| } |
| |
| private int getValueKC(ModelIdentifier id) { |
| if (id.getObject().equals("midi_cc")) { |
| int ic = Integer.parseInt(id.getVariable()); |
| if (ic != 0 && ic != 32) { |
| if (ic < 120) |
| return ic; |
| } |
| } else if (id.getObject().equals("midi_rpn")) { |
| if (id.getVariable().equals("1")) |
| return 120; // Fine tuning |
| if (id.getVariable().equals("2")) |
| return 121; // Coarse tuning |
| } |
| return -1; |
| } |
| |
| private double[] getValue(ModelIdentifier id) { |
| SoftControl o = objects.get(id.getObject()); |
| if (o == null) |
| return null; |
| return o.get(id.getInstance(), id.getVariable()); |
| } |
| |
| private double transformValue(double value, ModelSource src) { |
| if (src.getTransform() != null) |
| return src.getTransform().transform(value); |
| else |
| return value; |
| } |
| |
| private double transformValue(double value, ModelDestination dst) { |
| if (dst.getTransform() != null) |
| return dst.getTransform().transform(value); |
| else |
| return value; |
| } |
| |
| private double processKeyBasedController(double value, int keycontrol) { |
| if (keycontrol == -1) |
| return value; |
| if (softchannel.keybasedcontroller_active != null) |
| if (softchannel.keybasedcontroller_active[note] != null) |
| if (softchannel.keybasedcontroller_active[note][keycontrol]) { |
| double key_controlvalue = |
| softchannel.keybasedcontroller_value[note][keycontrol]; |
| if (keycontrol == 10 || keycontrol == 91 || keycontrol == 93) |
| return key_controlvalue; |
| value += key_controlvalue * 2.0 - 1.0; |
| if (value > 1) |
| value = 1; |
| else if (value < 0) |
| value = 0; |
| } |
| return value; |
| } |
| |
| private void processConnection(int ix) { |
| ModelConnectionBlock conn = connections[ix]; |
| double[][] src = connections_src[ix]; |
| double[] dst = connections_dst[ix]; |
| if (dst == null || Double.isInfinite(dst[0])) |
| return; |
| |
| double value = conn.getScale(); |
| if (softchannel.keybasedcontroller_active == null) { |
| ModelSource[] srcs = conn.getSources(); |
| for (int i = 0; i < srcs.length; i++) { |
| value *= transformValue(src[i][0], srcs[i]); |
| if (value == 0) |
| break; |
| } |
| } else { |
| ModelSource[] srcs = conn.getSources(); |
| int[] src_kc = connections_src_kc[ix]; |
| for (int i = 0; i < srcs.length; i++) { |
| value *= transformValue(processKeyBasedController(src[i][0], |
| src_kc[i]), srcs[i]); |
| if (value == 0) |
| break; |
| } |
| } |
| |
| value = transformValue(value, conn.getDestination()); |
| dst[0] = dst[0] - connections_last[ix] + value; |
| connections_last[ix] = value; |
| // co_mixer_gain[0] = 0; |
| } |
| |
| void updateTuning(SoftTuning newtuning) { |
| tuning = newtuning; |
| tunedKey = tuning.getTuning(note) / 100.0; |
| if (!portamento) { |
| co_noteon_keynumber[0] = tunedKey * (1.0 / 128.0); |
| if(performer == null) |
| return; |
| int[] c = performer.midi_connections[4]; |
| if (c == null) |
| return; |
| for (int i = 0; i < c.length; i++) |
| processConnection(c[i]); |
| } |
| } |
| |
| void setNote(int noteNumber) { |
| note = noteNumber; |
| tunedKey = tuning.getTuning(noteNumber) / 100.0; |
| } |
| |
| void noteOn(int noteNumber, int velocity, int delay) { |
| |
| sustain = false; |
| sostenuto = false; |
| portamento = false; |
| |
| soundoff = false; |
| on = true; |
| active = true; |
| started = true; |
| // volume = velocity; |
| |
| noteOn_noteNumber = noteNumber; |
| noteOn_velocity = velocity; |
| this.delay = delay; |
| |
| lastMuteValue = 0; |
| lastSoloMuteValue = 0; |
| |
| setNote(noteNumber); |
| |
| if (performer.forcedKeynumber) |
| co_noteon_keynumber[0] = 0; |
| else |
| co_noteon_keynumber[0] = tunedKey * (1f / 128f); |
| if (performer.forcedVelocity) |
| co_noteon_velocity[0] = 0; |
| else |
| co_noteon_velocity[0] = velocity * (1f / 128f); |
| co_mixer_active[0] = 0; |
| co_mixer_gain[0] = 0; |
| co_mixer_pan[0] = 0; |
| co_mixer_balance[0] = 0; |
| co_mixer_reverb[0] = 0; |
| co_mixer_chorus[0] = 0; |
| co_osc_pitch[0] = 0; |
| co_filter_freq[0] = 0; |
| co_filter_q[0] = 0; |
| co_filter_type[0] = 0; |
| co_noteon_on[0] = 1; |
| |
| eg.reset(); |
| lfo.reset(); |
| filter_left.reset(); |
| filter_right.reset(); |
| |
| objects.put("master", synthesizer.getMainMixer().co_master); |
| objects.put("eg", eg); |
| objects.put("lfo", lfo); |
| objects.put("noteon", co_noteon); |
| objects.put("osc", co_osc); |
| objects.put("mixer", co_mixer); |
| objects.put("filter", co_filter); |
| |
| connections = performer.connections; |
| |
| if (connections_last == null |
| || connections_last.length < connections.length) { |
| connections_last = new double[connections.length]; |
| } |
| if (connections_src == null |
| || connections_src.length < connections.length) { |
| connections_src = new double[connections.length][][]; |
| connections_src_kc = new int[connections.length][]; |
| } |
| if (connections_dst == null |
| || connections_dst.length < connections.length) { |
| connections_dst = new double[connections.length][]; |
| } |
| for (int i = 0; i < connections.length; i++) { |
| ModelConnectionBlock conn = connections[i]; |
| connections_last[i] = 0; |
| if (conn.getSources() != null) { |
| ModelSource[] srcs = conn.getSources(); |
| if (connections_src[i] == null |
| || connections_src[i].length < srcs.length) { |
| connections_src[i] = new double[srcs.length][]; |
| connections_src_kc[i] = new int[srcs.length]; |
| } |
| double[][] src = connections_src[i]; |
| int[] src_kc = connections_src_kc[i]; |
| connections_src[i] = src; |
| for (int j = 0; j < srcs.length; j++) { |
| src_kc[j] = getValueKC(srcs[j].getIdentifier()); |
| src[j] = getValue(srcs[j].getIdentifier()); |
| } |
| } |
| |
| if (conn.getDestination() != null) |
| connections_dst[i] = getValue(conn.getDestination() |
| .getIdentifier()); |
| else |
| connections_dst[i] = null; |
| } |
| |
| for (int i = 0; i < connections.length; i++) |
| processConnection(i); |
| |
| if (extendedConnectionBlocks != null) { |
| for (ModelConnectionBlock connection: extendedConnectionBlocks) { |
| double value = 0; |
| |
| if (softchannel.keybasedcontroller_active == null) { |
| for (ModelSource src: connection.getSources()) { |
| double x = getValue(src.getIdentifier())[0]; |
| ModelTransform t = src.getTransform(); |
| if (t == null) |
| value += x; |
| else |
| value += t.transform(x); |
| } |
| } else { |
| for (ModelSource src: connection.getSources()) { |
| double x = getValue(src.getIdentifier())[0]; |
| x = processKeyBasedController(x, |
| getValueKC(src.getIdentifier())); |
| ModelTransform t = src.getTransform(); |
| if (t == null) |
| value += x; |
| else |
| value += t.transform(x); |
| } |
| } |
| |
| ModelDestination dest = connection.getDestination(); |
| ModelTransform t = dest.getTransform(); |
| if (t != null) |
| value = t.transform(value); |
| getValue(dest.getIdentifier())[0] += value; |
| } |
| } |
| |
| eg.init(synthesizer); |
| lfo.init(synthesizer); |
| |
| } |
| |
| void setPolyPressure(int pressure) { |
| if(performer == null) |
| return; |
| int[] c = performer.midi_connections[2]; |
| if (c == null) |
| return; |
| for (int i = 0; i < c.length; i++) |
| processConnection(c[i]); |
| } |
| |
| void setChannelPressure(int pressure) { |
| if(performer == null) |
| return; |
| int[] c = performer.midi_connections[1]; |
| if (c == null) |
| return; |
| for (int i = 0; i < c.length; i++) |
| processConnection(c[i]); |
| } |
| |
| void controlChange(int controller, int value) { |
| if(performer == null) |
| return; |
| int[] c = performer.midi_ctrl_connections[controller]; |
| if (c == null) |
| return; |
| for (int i = 0; i < c.length; i++) |
| processConnection(c[i]); |
| } |
| |
| void nrpnChange(int controller, int value) { |
| if(performer == null) |
| return; |
| int[] c = performer.midi_nrpn_connections.get(controller); |
| if (c == null) |
| return; |
| for (int i = 0; i < c.length; i++) |
| processConnection(c[i]); |
| } |
| |
| void rpnChange(int controller, int value) { |
| if(performer == null) |
| return; |
| int[] c = performer.midi_rpn_connections.get(controller); |
| if (c == null) |
| return; |
| for (int i = 0; i < c.length; i++) |
| processConnection(c[i]); |
| } |
| |
| void setPitchBend(int bend) { |
| if(performer == null) |
| return; |
| int[] c = performer.midi_connections[0]; |
| if (c == null) |
| return; |
| for (int i = 0; i < c.length; i++) |
| processConnection(c[i]); |
| } |
| |
| void setMute(boolean mute) { |
| co_mixer_gain[0] -= lastMuteValue; |
| lastMuteValue = mute ? -960 : 0; |
| co_mixer_gain[0] += lastMuteValue; |
| } |
| |
| void setSoloMute(boolean mute) { |
| co_mixer_gain[0] -= lastSoloMuteValue; |
| lastSoloMuteValue = mute ? -960 : 0; |
| co_mixer_gain[0] += lastSoloMuteValue; |
| } |
| |
| void shutdown() { |
| if (co_noteon_on[0] < -0.5) |
| return; |
| on = false; |
| |
| co_noteon_on[0] = -1; |
| |
| if(performer == null) |
| return; |
| int[] c = performer.midi_connections[3]; |
| if (c == null) |
| return; |
| for (int i = 0; i < c.length; i++) |
| processConnection(c[i]); |
| } |
| |
| void soundOff() { |
| on = false; |
| soundoff = true; |
| } |
| |
| void noteOff(int velocity) { |
| if (!on) |
| return; |
| on = false; |
| |
| noteOff_velocity = velocity; |
| |
| if (softchannel.sustain) { |
| sustain = true; |
| return; |
| } |
| if (sostenuto) |
| return; |
| |
| co_noteon_on[0] = 0; |
| |
| if(performer == null) |
| return; |
| int[] c = performer.midi_connections[3]; |
| if (c == null) |
| return; |
| for (int i = 0; i < c.length; i++) |
| processConnection(c[i]); |
| } |
| |
| void redamp() { |
| if (co_noteon_on[0] > 0.5) |
| return; |
| if (co_noteon_on[0] < -0.5) |
| return; // don't redamp notes in shutdown stage |
| |
| sustain = true; |
| co_noteon_on[0] = 1; |
| |
| if(performer == null) |
| return; |
| int[] c = performer.midi_connections[3]; |
| if (c == null) |
| return; |
| for (int i = 0; i < c.length; i++) |
| processConnection(c[i]); |
| } |
| |
| void processControlLogic() { |
| if (stopping) { |
| active = false; |
| stopping = false; |
| audiostarted = false; |
| instrument = null; |
| performer = null; |
| connections = null; |
| extendedConnectionBlocks = null; |
| channelmixer = null; |
| if (osc_stream != null) |
| try { |
| osc_stream.close(); |
| } catch (IOException e) { |
| //e.printStackTrace(); |
| } |
| |
| if (stealer_channel != null) { |
| stealer_channel.initVoice(this, stealer_performer, |
| stealer_voiceID, stealer_noteNumber, stealer_velocity, 0, |
| stealer_extendedConnectionBlocks, stealer_channelmixer, |
| stealer_releaseTriggered); |
| stealer_releaseTriggered = false; |
| stealer_channel = null; |
| stealer_performer = null; |
| stealer_voiceID = -1; |
| stealer_noteNumber = 0; |
| stealer_velocity = 0; |
| stealer_extendedConnectionBlocks = null; |
| stealer_channelmixer = null; |
| } |
| } |
| if (started) { |
| audiostarted = true; |
| |
| ModelOscillator osc = performer.oscillators[0]; |
| |
| osc_stream_off_transmitted = false; |
| if (osc instanceof ModelWavetable) { |
| try { |
| resampler.open((ModelWavetable)osc, |
| synthesizer.getFormat().getSampleRate()); |
| osc_stream = resampler; |
| } catch (IOException e) { |
| //e.printStackTrace(); |
| } |
| } else { |
| osc_stream = osc.open(synthesizer.getFormat().getSampleRate()); |
| } |
| osc_attenuation = osc.getAttenuation(); |
| osc_stream_nrofchannels = osc.getChannels(); |
| if (osc_buff == null || osc_buff.length < osc_stream_nrofchannels) |
| osc_buff = new float[osc_stream_nrofchannels][]; |
| |
| if (osc_stream != null) |
| osc_stream.noteOn(softchannel, this, noteOn_noteNumber, |
| noteOn_velocity); |
| |
| |
| } |
| if (audiostarted) { |
| if (portamento) { |
| double note_delta = tunedKey - (co_noteon_keynumber[0] * 128); |
| double note_delta_a = Math.abs(note_delta); |
| if (note_delta_a < 0.0000000001) { |
| co_noteon_keynumber[0] = tunedKey * (1.0 / 128.0); |
| portamento = false; |
| } else { |
| if (note_delta_a > softchannel.portamento_time) |
| note_delta = Math.signum(note_delta) |
| * softchannel.portamento_time; |
| co_noteon_keynumber[0] += note_delta * (1.0 / 128.0); |
| } |
| |
| int[] c = performer.midi_connections[4]; |
| if (c == null) |
| return; |
| for (int i = 0; i < c.length; i++) |
| processConnection(c[i]); |
| } |
| |
| eg.processControlLogic(); |
| lfo.processControlLogic(); |
| |
| for (int i = 0; i < performer.ctrl_connections.length; i++) |
| processConnection(performer.ctrl_connections[i]); |
| |
| osc_stream.setPitch((float)co_osc_pitch[0]); |
| |
| int filter_type = (int)co_filter_type[0]; |
| double filter_freq; |
| |
| if (co_filter_freq[0] == 13500.0) |
| filter_freq = 19912.126958213175; |
| else |
| filter_freq = 440.0 * Math.exp( |
| ((co_filter_freq[0]) - 6900.0) * |
| (Math.log(2.0) / 1200.0)); |
| /* |
| filter_freq = 440.0 * Math.pow(2.0, |
| ((co_filter_freq[0]) - 6900.0) / 1200.0);*/ |
| /* |
| * double velocity = co_noteon_velocity[0]; if(velocity < 0.5) |
| * filter_freq *= ((velocity * 2)*0.75 + 0.25); |
| */ |
| |
| double q = co_filter_q[0] / 10.0; |
| filter_left.setFilterType(filter_type); |
| filter_left.setFrequency(filter_freq); |
| filter_left.setResonance(q); |
| filter_right.setFilterType(filter_type); |
| filter_right.setFrequency(filter_freq); |
| filter_right.setResonance(q); |
| /* |
| float gain = (float) Math.pow(10, |
| (-osc_attenuation + co_mixer_gain[0]) / 200.0); |
| */ |
| float gain = (float)Math.exp( |
| (-osc_attenuation + co_mixer_gain[0])*(Math.log(10) / 200.0)); |
| |
| if (co_mixer_gain[0] <= -960) |
| gain = 0; |
| |
| if (soundoff) { |
| stopping = true; |
| gain = 0; |
| /* |
| * if(co_mixer_gain[0] > -960) |
| * co_mixer_gain[0] -= 960; |
| */ |
| } |
| |
| volume = (int)(Math.sqrt(gain) * 128); |
| |
| // gain *= 0.2; |
| |
| double pan = co_mixer_pan[0] * (1.0 / 1000.0); |
| // System.out.println("pan = " + pan); |
| if (pan < 0) |
| pan = 0; |
| else if (pan > 1) |
| pan = 1; |
| |
| if (pan == 0.5) { |
| out_mixer_left = gain * 0.7071067811865476f; |
| out_mixer_right = out_mixer_left; |
| } else { |
| out_mixer_left = gain * (float)Math.cos(pan * Math.PI * 0.5); |
| out_mixer_right = gain * (float)Math.sin(pan * Math.PI * 0.5); |
| } |
| |
| double balance = co_mixer_balance[0] * (1.0 / 1000.0); |
| if (balance != 0.5) { |
| if (balance > 0.5) |
| out_mixer_left *= (1 - balance) * 2; |
| else |
| out_mixer_right *= balance * 2; |
| } |
| |
| if (synthesizer.reverb_on) { |
| out_mixer_effect1 = (float)(co_mixer_reverb[0] * (1.0 / 1000.0)); |
| out_mixer_effect1 *= gain; |
| } else |
| out_mixer_effect1 = 0; |
| if (synthesizer.chorus_on) { |
| out_mixer_effect2 = (float)(co_mixer_chorus[0] * (1.0 / 1000.0)); |
| out_mixer_effect2 *= gain; |
| } else |
| out_mixer_effect2 = 0; |
| out_mixer_end = co_mixer_active[0] < 0.5; |
| |
| if (!on) |
| if (!osc_stream_off_transmitted) { |
| osc_stream_off_transmitted = true; |
| if (osc_stream != null) |
| osc_stream.noteOff(noteOff_velocity); |
| } |
| |
| } |
| if (started) { |
| last_out_mixer_left = out_mixer_left; |
| last_out_mixer_right = out_mixer_right; |
| last_out_mixer_effect1 = out_mixer_effect1; |
| last_out_mixer_effect2 = out_mixer_effect2; |
| started = false; |
| } |
| |
| } |
| |
| void mixAudioStream(SoftAudioBuffer in, SoftAudioBuffer out, |
| SoftAudioBuffer dout, float amp_from, |
| float amp_to) { |
| int bufferlen = in.getSize(); |
| if (amp_from < 0.000000001 && amp_to < 0.000000001) |
| return; |
| if(dout != null && delay != 0) |
| { |
| if (amp_from == amp_to) { |
| float[] fout = out.array(); |
| float[] fin = in.array(); |
| int j = 0; |
| for (int i = delay; i < bufferlen; i++) |
| fout[i] += fin[j++] * amp_to; |
| fout = dout.array(); |
| for (int i = 0; i < delay; i++) |
| fout[i] += fin[j++] * amp_to; |
| } else { |
| float amp = amp_from; |
| float amp_delta = (amp_to - amp_from) / bufferlen; |
| float[] fout = out.array(); |
| float[] fin = in.array(); |
| int j = 0; |
| for (int i = delay; i < bufferlen; i++) { |
| amp += amp_delta; |
| fout[i] += fin[j++] * amp; |
| } |
| fout = dout.array(); |
| for (int i = 0; i < delay; i++) { |
| amp += amp_delta; |
| fout[i] += fin[j++] * amp; |
| } |
| } |
| } |
| else |
| { |
| if (amp_from == amp_to) { |
| float[] fout = out.array(); |
| float[] fin = in.array(); |
| for (int i = 0; i < bufferlen; i++) |
| fout[i] += fin[i] * amp_to; |
| } else { |
| float amp = amp_from; |
| float amp_delta = (amp_to - amp_from) / bufferlen; |
| float[] fout = out.array(); |
| float[] fin = in.array(); |
| for (int i = 0; i < bufferlen; i++) { |
| amp += amp_delta; |
| fout[i] += fin[i] * amp; |
| } |
| } |
| } |
| |
| } |
| |
| void processAudioLogic(SoftAudioBuffer[] buffer) { |
| if (!audiostarted) |
| return; |
| |
| int bufferlen = buffer[0].getSize(); |
| |
| try { |
| osc_buff[0] = buffer[SoftMainMixer.CHANNEL_LEFT_DRY].array(); |
| if (nrofchannels != 1) |
| osc_buff[1] = buffer[SoftMainMixer.CHANNEL_RIGHT_DRY].array(); |
| int ret = osc_stream.read(osc_buff, 0, bufferlen); |
| if (ret == -1) { |
| stopping = true; |
| return; |
| } |
| if (ret != bufferlen) { |
| Arrays.fill(osc_buff[0], ret, bufferlen, 0f); |
| if (nrofchannels != 1) |
| Arrays.fill(osc_buff[1], ret, bufferlen, 0f); |
| } |
| |
| } catch (IOException e) { |
| //e.printStackTrace(); |
| } |
| |
| SoftAudioBuffer left = buffer[SoftMainMixer.CHANNEL_LEFT]; |
| SoftAudioBuffer right = buffer[SoftMainMixer.CHANNEL_RIGHT]; |
| SoftAudioBuffer mono = buffer[SoftMainMixer.CHANNEL_MONO]; |
| SoftAudioBuffer eff1 = buffer[SoftMainMixer.CHANNEL_EFFECT1]; |
| SoftAudioBuffer eff2 = buffer[SoftMainMixer.CHANNEL_EFFECT2]; |
| |
| SoftAudioBuffer dleft = buffer[SoftMainMixer.CHANNEL_DELAY_LEFT]; |
| SoftAudioBuffer dright = buffer[SoftMainMixer.CHANNEL_DELAY_RIGHT]; |
| SoftAudioBuffer dmono = buffer[SoftMainMixer.CHANNEL_DELAY_MONO]; |
| SoftAudioBuffer deff1 = buffer[SoftMainMixer.CHANNEL_DELAY_EFFECT1]; |
| SoftAudioBuffer deff2 = buffer[SoftMainMixer.CHANNEL_DELAY_EFFECT2]; |
| |
| SoftAudioBuffer leftdry = buffer[SoftMainMixer.CHANNEL_LEFT_DRY]; |
| SoftAudioBuffer rightdry = buffer[SoftMainMixer.CHANNEL_RIGHT_DRY]; |
| |
| if (osc_stream_nrofchannels == 1) |
| rightdry = null; |
| |
| if (!Double.isInfinite(co_filter_freq[0])) { |
| filter_left.processAudio(leftdry); |
| if (rightdry != null) |
| filter_right.processAudio(rightdry); |
| } |
| |
| if (nrofchannels == 1) { |
| out_mixer_left = (out_mixer_left + out_mixer_right) / 2; |
| mixAudioStream(leftdry, left, dleft, last_out_mixer_left, out_mixer_left); |
| if (rightdry != null) |
| mixAudioStream(rightdry, left, dleft, last_out_mixer_left, |
| out_mixer_left); |
| } else { |
| if(rightdry == null && |
| last_out_mixer_left == last_out_mixer_right && |
| out_mixer_left == out_mixer_right) |
| { |
| mixAudioStream(leftdry, mono, dmono, last_out_mixer_left, out_mixer_left); |
| } |
| else |
| { |
| mixAudioStream(leftdry, left, dleft, last_out_mixer_left, out_mixer_left); |
| if (rightdry != null) |
| mixAudioStream(rightdry, right, dright, last_out_mixer_right, |
| out_mixer_right); |
| else |
| mixAudioStream(leftdry, right, dright, last_out_mixer_right, |
| out_mixer_right); |
| } |
| } |
| |
| if (rightdry == null) { |
| mixAudioStream(leftdry, eff1, deff1, last_out_mixer_effect1, |
| out_mixer_effect1); |
| mixAudioStream(leftdry, eff2, deff2, last_out_mixer_effect2, |
| out_mixer_effect2); |
| } else { |
| mixAudioStream(leftdry, eff1, deff1, last_out_mixer_effect1 * 0.5f, |
| out_mixer_effect1 * 0.5f); |
| mixAudioStream(leftdry, eff2, deff2, last_out_mixer_effect2 * 0.5f, |
| out_mixer_effect2 * 0.5f); |
| mixAudioStream(rightdry, eff1, deff1, last_out_mixer_effect1 * 0.5f, |
| out_mixer_effect1 * 0.5f); |
| mixAudioStream(rightdry, eff2, deff2, last_out_mixer_effect2 * 0.5f, |
| out_mixer_effect2 * 0.5f); |
| } |
| |
| last_out_mixer_left = out_mixer_left; |
| last_out_mixer_right = out_mixer_right; |
| last_out_mixer_effect1 = out_mixer_effect1; |
| last_out_mixer_effect2 = out_mixer_effect2; |
| |
| if (out_mixer_end) { |
| stopping = true; |
| } |
| |
| } |
| } |
