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.Arrays;

	/**
	* Reverb effect based on allpass/comb filters. First audio is send to 8
	* parelled comb filters and then mixed together and then finally send thru 3
	* different allpass filters.
	*
	* @author Karl Helgason
	*/
	public final class SoftReverb implements SoftAudioProcessor {

	private final static class Delay {

	private float[] delaybuffer;
	private int rovepos = 0;

	Delay() {
	delaybuffer = null;
	}

	public void setDelay(int delay) {
	if (delay == 0)
	delaybuffer = null;
	else
	delaybuffer = new float[delay];
	rovepos = 0;
	}

	public void processReplace(float[] inout) {
	if (delaybuffer == null)
	return;
	int len = inout.length;
	int rnlen = delaybuffer.length;
	int rovepos = this.rovepos;

	for (int i = 0; i < len; i++) {
	float x = inout[i];
	inout[i] = delaybuffer[rovepos];
	delaybuffer[rovepos] = x;
	if (++rovepos == rnlen)
	rovepos = 0;
	}
	this.rovepos = rovepos;
	}
	}

	private final static class AllPass {

	private final float[] delaybuffer;
	private final int delaybuffersize;
	private int rovepos = 0;
	private float feedback;

	AllPass(int size) {
	delaybuffer = new float[size];
	delaybuffersize = size;
	}

	public void setFeedBack(float feedback) {
	this.feedback = feedback;
	}

	public void processReplace(float inout[]) {
	int len = inout.length;
	int delaybuffersize = this.delaybuffersize;
	int rovepos = this.rovepos;
	for (int i = 0; i < len; i++) {
	float delayout = delaybuffer[rovepos];
	float input = inout[i];
	inout[i] = delayout - input;
	delaybuffer[rovepos] = input + delayout * feedback;
	if (++rovepos == delaybuffersize)
	rovepos = 0;
	}
	this.rovepos = rovepos;
	}

	public void processReplace(float in[], float out[]) {
	int len = in.length;
	int delaybuffersize = this.delaybuffersize;
	int rovepos = this.rovepos;
	for (int i = 0; i < len; i++) {
	float delayout = delaybuffer[rovepos];
	float input = in[i];
	out[i] = delayout - input;
	delaybuffer[rovepos] = input + delayout * feedback;
	if (++rovepos == delaybuffersize)
	rovepos = 0;
	}
	this.rovepos = rovepos;
	}
	}

	private final static class Comb {

	private final float[] delaybuffer;
	private final int delaybuffersize;
	private int rovepos = 0;
	private float feedback;
	private float filtertemp = 0;
	private float filtercoeff1 = 0;
	private float filtercoeff2 = 1;

	Comb(int size) {
	delaybuffer = new float[size];
	delaybuffersize = size;
	}

	public void setFeedBack(float feedback) {
	this.feedback = feedback;
	filtercoeff2 = (1 - filtercoeff1)* feedback;
	}

	public void processMix(float in[], float out[]) {
	int len = in.length;
	int delaybuffersize = this.delaybuffersize;
	int rovepos = this.rovepos;
	float filtertemp = this.filtertemp;
	float filtercoeff1 = this.filtercoeff1;
	float filtercoeff2 = this.filtercoeff2;
	for (int i = 0; i < len; i++) {
	float delayout = delaybuffer[rovepos];
	// One Pole Lowpass Filter
	filtertemp = (delayout * filtercoeff2)
	+ (filtertemp * filtercoeff1);
	out[i] += delayout;
	delaybuffer[rovepos] = in[i] + filtertemp;
	if (++rovepos == delaybuffersize)
	rovepos = 0;
	}
	this.filtertemp = filtertemp;
	this.rovepos = rovepos;
	}

	public void processReplace(float in[], float out[]) {
	int len = in.length;
	int delaybuffersize = this.delaybuffersize;
	int rovepos = this.rovepos;
	float filtertemp = this.filtertemp;
	float filtercoeff1 = this.filtercoeff1;
	float filtercoeff2 = this.filtercoeff2;
	for (int i = 0; i < len; i++) {
	float delayout = delaybuffer[rovepos];
	// One Pole Lowpass Filter
	filtertemp = (delayout * filtercoeff2)
	+ (filtertemp * filtercoeff1);
	out[i] = delayout;
	delaybuffer[rovepos] = in[i] + filtertemp;
	if (++rovepos == delaybuffersize)
	rovepos = 0;
	}
	this.filtertemp = filtertemp;
	this.rovepos = rovepos;
	}

	public void setDamp(float val) {
	filtercoeff1 = val;
	filtercoeff2 = (1 - filtercoeff1)* feedback;
	}
	}
	private float roomsize;
	private float damp;
	private float gain = 1;
	private Delay delay;
	private Comb[] combL;
	private Comb[] combR;
	private AllPass[] allpassL;
	private AllPass[] allpassR;
	private float[] input;
	private float[] out;
	private float[] pre1;
	private float[] pre2;
	private float[] pre3;
	private boolean denormal_flip = false;
	private boolean mix = true;
	private SoftAudioBuffer inputA;
	private SoftAudioBuffer left;
	private SoftAudioBuffer right;
	private boolean dirty = true;
	private float dirty_roomsize;
	private float dirty_damp;
	private float dirty_predelay;
	private float dirty_gain;
	private float samplerate;
	private boolean light = true;

	public void init(float samplerate, float controlrate) {
	this.samplerate = samplerate;

	double freqscale = ((double) samplerate) / 44100.0;
	// freqscale = 1.0/ freqscale;

	int stereospread = 23;

	delay = new Delay();

	combL = new Comb[8];
	combR = new Comb[8];
	combL[0] = new Comb((int) (freqscale * (1116)));
	combR[0] = new Comb((int) (freqscale * (1116 + stereospread)));
	combL[1] = new Comb((int) (freqscale * (1188)));
	combR[1] = new Comb((int) (freqscale * (1188 + stereospread)));
	combL[2] = new Comb((int) (freqscale * (1277)));
	combR[2] = new Comb((int) (freqscale * (1277 + stereospread)));
	combL[3] = new Comb((int) (freqscale * (1356)));
	combR[3] = new Comb((int) (freqscale * (1356 + stereospread)));
	combL[4] = new Comb((int) (freqscale * (1422)));
	combR[4] = new Comb((int) (freqscale * (1422 + stereospread)));
	combL[5] = new Comb((int) (freqscale * (1491)));
	combR[5] = new Comb((int) (freqscale * (1491 + stereospread)));
	combL[6] = new Comb((int) (freqscale * (1557)));
	combR[6] = new Comb((int) (freqscale * (1557 + stereospread)));
	combL[7] = new Comb((int) (freqscale * (1617)));
	combR[7] = new Comb((int) (freqscale * (1617 + stereospread)));

	allpassL = new AllPass[4];
	allpassR = new AllPass[4];
	allpassL[0] = new AllPass((int) (freqscale * (556)));
	allpassR[0] = new AllPass((int) (freqscale * (556 + stereospread)));
	allpassL[1] = new AllPass((int) (freqscale * (441)));
	allpassR[1] = new AllPass((int) (freqscale * (441 + stereospread)));
	allpassL[2] = new AllPass((int) (freqscale * (341)));
	allpassR[2] = new AllPass((int) (freqscale * (341 + stereospread)));
	allpassL[3] = new AllPass((int) (freqscale * (225)));
	allpassR[3] = new AllPass((int) (freqscale * (225 + stereospread)));

	for (int i = 0; i < allpassL.length; i++) {
	allpassL[i].setFeedBack(0.5f);
	allpassR[i].setFeedBack(0.5f);
	}

	/* Init other settings */
	globalParameterControlChange(new int[]{0x01 * 128 + 0x01}, 0, 4);

	}

	public void setInput(int pin, SoftAudioBuffer input) {
	if (pin == 0)
	inputA = input;
	}

	public void setOutput(int pin, SoftAudioBuffer output) {
	if (pin == 0)
	left = output;
	if (pin == 1)
	right = output;
	}

	public void setMixMode(boolean mix) {
	this.mix = mix;
	}

	private boolean silent = true;

	public void processAudio() {
	boolean silent_input = this.inputA.isSilent();
	if(!silent_input)
	silent = false;
	if(silent)
	{
	if (!mix) {
	left.clear();
	right.clear();
	}
	return;
	}

	float[] inputA = this.inputA.array();
	float[] left = this.left.array();
	float[] right = this.right == null ? null : this.right.array();

	int numsamples = inputA.length;
	if (input == null \|\| input.length < numsamples)
	input = new float[numsamples];

	float again = gain * 0.018f / 2;

	denormal_flip = !denormal_flip;
	if(denormal_flip)
	for (int i = 0; i < numsamples; i++)
	input[i] = inputA[i] * again + 1E-20f;
	else
	for (int i = 0; i < numsamples; i++)
	input[i] = inputA[i] * again - 1E-20f;

	delay.processReplace(input);

	if(light && (right != null))
	{
	if (pre1 == null \|\| pre1.length < numsamples)
	{
	pre1 = new float[numsamples];
	pre2 = new float[numsamples];
	pre3 = new float[numsamples];
	}

	for (int i = 0; i < allpassL.length; i++)
	allpassL[i].processReplace(input);

	combL[0].processReplace(input, pre3);
	combL[1].processReplace(input, pre3);

	combL[2].processReplace(input, pre1);
	for (int i = 4; i < combL.length-2; i+=2)
	combL[i].processMix(input, pre1);

	combL[3].processReplace(input, pre2);;
	for (int i = 5; i < combL.length-2; i+=2)
	combL[i].processMix(input, pre2);

	if (!mix)
	{
	Arrays.fill(right, 0);
	Arrays.fill(left, 0);
	}
	for (int i = combR.length-2; i < combR.length; i++)
	combR[i].processMix(input, right);
	for (int i = combL.length-2; i < combL.length; i++)
	combL[i].processMix(input, left);

	for (int i = 0; i < numsamples; i++)
	{
	float p = pre1[i] - pre2[i];
	float m = pre3[i];
	left[i] += m + p;
	right[i] += m - p;
	}
	}
	else
	{
	if (out == null \|\| out.length < numsamples)
	out = new float[numsamples];

	if (right != null) {
	if (!mix)
	Arrays.fill(right, 0);
	allpassR[0].processReplace(input, out);
	for (int i = 1; i < allpassR.length; i++)
	allpassR[i].processReplace(out);
	for (int i = 0; i < combR.length; i++)
	combR[i].processMix(out, right);
	}

	if (!mix)
	Arrays.fill(left, 0);
	allpassL[0].processReplace(input, out);
	for (int i = 1; i < allpassL.length; i++)
	allpassL[i].processReplace(out);
	for (int i = 0; i < combL.length; i++)
	combL[i].processMix(out, left);
	}






	if (silent_input) {
	silent = true;
	for (int i = 0; i < numsamples; i++)
	{
	float v = left[i];
	if(v > 1E-10 \|\| v < -1E-10)
	{
	silent = false;
	break;
	}
	}
	}

	}

	public void globalParameterControlChange(int[] slothpath, long param,
	long value) {
	if (slothpath.length == 1) {
	if (slothpath[0] == 0x01 * 128 + 0x01) {

	if (param == 0) {
	if (value == 0) {
	// Small Room A small size room with a length
	// of 5m or so.
	dirty_roomsize = (1.1f);
	dirty_damp = (5000);
	dirty_predelay = (0);
	dirty_gain = (4);
	dirty = true;
	}
	if (value == 1) {
	// Medium Room A medium size room with a length
	// of 10m or so.
	dirty_roomsize = (1.3f);
	dirty_damp = (5000);
	dirty_predelay = (0);
	dirty_gain = (3);
	dirty = true;
	}
	if (value == 2) {
	// Large Room A large size room suitable for
	// live performances.
	dirty_roomsize = (1.5f);
	dirty_damp = (5000);
	dirty_predelay = (0);
	dirty_gain = (2);
	dirty = true;
	}
	if (value == 3) {
	// Medium Hall A medium size concert hall.
	dirty_roomsize = (1.8f);
	dirty_damp = (24000);
	dirty_predelay = (0.02f);
	dirty_gain = (1.5f);
	dirty = true;
	}
	if (value == 4) {
	// Large Hall A large size concert hall
	// suitable for a full orchestra.
	dirty_roomsize = (1.8f);
	dirty_damp = (24000);
	dirty_predelay = (0.03f);
	dirty_gain = (1.5f);
	dirty = true;
	}
	if (value == 8) {
	// Plate A plate reverb simulation.
	dirty_roomsize = (1.3f);
	dirty_damp = (2500);
	dirty_predelay = (0);
	dirty_gain = (6);
	dirty = true;
	}
	} else if (param == 1) {
	dirty_roomsize = ((float) (Math.exp((value - 40) * 0.025)));
	dirty = true;
	}

	}
	}
	}

	public void processControlLogic() {
	if (dirty) {
	dirty = false;
	setRoomSize(dirty_roomsize);
	setDamp(dirty_damp);
	setPreDelay(dirty_predelay);
	setGain(dirty_gain);
	}
	}

	public void setRoomSize(float value) {
	roomsize = 1 - (0.17f / value);

	for (int i = 0; i < combL.length; i++) {
	combL[i].feedback = roomsize;
	combR[i].feedback = roomsize;
	}
	}

	public void setPreDelay(float value) {
	delay.setDelay((int)(value * samplerate));
	}

	public void setGain(float gain) {
	this.gain = gain;
	}

	public void setDamp(float value) {
	double x = (value / samplerate) * (2 * Math.PI);
	double cx = 2 - Math.cos(x);
	damp = (float)(cx - Math.sqrt(cx * cx - 1));
	if (damp > 1)
	damp = 1;
	if (damp < 0)
	damp = 0;

	// damp = value * 0.4f;
	for (int i = 0; i < combL.length; i++) {
	combL[i].setDamp(damp);
	combR[i].setDamp(damp);
	}

	}

	public void setLightMode(boolean light)
	{
	this.light = light;
	}
	}

Back to index...