/*
 * Copyright 2007 Sun Microsystems, Inc.  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.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.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.
 * 
 * @version %I%, %E%
 * @author Karl Helgason
 */

public class SoftReverb implements SoftAudioProcessor {

	private class Delay {
		private float[] delaybuffer;

		private int rovepos = 0;

		public Delay() {
			delaybuffer = null;
		}

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

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

			for (int i = 0; i < len; i++) {
				float x = in[i];
				out[i] = delaybuffer[rovepos];
				delaybuffer[rovepos] = x;
				rovepos = rovepos + 1;
				if(rovepos == rnlen) rovepos = 0;  
				//rovepos = (rovepos + 1) % rnlen;
			}
			this.rovepos = rovepos;
		}

	}

	private class AllPass {

		private float[] delaybuffer;

		private int delaybuffersize;

		private int rovepos = 0;

		private float feedback;

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

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

		public void processReplace(float in[], float out[]) {
			int len = in.length;
			for (int i = 0; i < len; i++) {

				float delayout = delaybuffer[rovepos];

				// undenormalise(delayout)
				/*
				if (((delayout > 0.0) && (delayout < 1.0E-10))
						|| ((delayout < 0.0) && (delayout > -1.0E-10)))
					delayout = 0;*/

				float input = in[i];
				out[i] = -input + delayout;
				delaybuffer[rovepos] = input + delayout * feedback;
				if (++rovepos == delaybuffersize)
					rovepos = 0;
			}
			
			ucount++;
			if(ucount == 10)
			{
				ucount = 0;
				for (int i = 0; i < delaybuffer.length; i++) {
					double v = delaybuffer[i];
					if (((v > 0.0) && (v < 1.0E-10))
							|| ((v < 0.0) && (v > -1.0E-10)))
						delaybuffer[i] = 0;					
				}
			}
			
		}

	}

	private class Comb {

		private float[] delaybuffer;

		private int delaybuffersize;

		private int rovepos = 0;

		private float feedback;

		private float filtertemp = 0;

		private float filtercoeff1 = 0;

		private float filtercoeff2 = 1;

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

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

		int ucount = 0; 
		public void processMix(float in[], float out[]) {
			int len = in.length;
			
			float filtercoeff2 = this.filtercoeff2*feedback;
			
			for (int i = 0; i < len; i++) {
				float delayout = delaybuffer[rovepos];

				// One Pole Lowpass Filter
				filtertemp = (delayout * filtercoeff2)
						+ (filtertemp * filtercoeff1);

				// undenormalise(filtertemp)
				/*
				if (((filtertemp > 0.0) && (filtertemp < 1.0E-10))
						|| ((filtertemp < 0.0) && (filtertemp > -1.0E-10)))
					filtertemp = 0;
				*/
				out[i] += delayout;
				delaybuffer[rovepos] = in[i] + (filtertemp);// * feedback);
				
				if (++rovepos == delaybuffersize)
					rovepos = 0;

			}
			ucount++;
			if(ucount == 10)
			{
				ucount = 0;
				if (((filtertemp > 0.0) && (filtertemp < 1.0E-10))
						|| ((filtertemp < 0.0) && (filtertemp > -1.0E-10)))
					filtertemp = 0;				
				for (int i = 0; i < delaybuffer.length; i++) {
					double v = delaybuffer[i];
					if (((v > 0.0) && (v < 1.0E-10))
							|| ((v < 0.0) && (v > -1.0E-10)))
						delaybuffer[i] = 0;					
				}
			}
			

		}

		public void setDamp(float val) {
			filtercoeff1 = val;
			filtercoeff2 = 1 - filtercoeff1;
		}
	}

	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[] outR;

	private float[] outL;

	private boolean mix = true;

	private SoftAudioBuffer inputA;

	private SoftAudioBuffer left;

	private SoftAudioBuffer right;

	private SoftSynthesizer synth;

	private boolean dirty = true;

	private float dirty_roomsize;

	private float dirty_damp;

	private float dirty_predelay;

	private float dirty_gain;
	
	public void init(SoftSynthesizer synth) {
		this.synth = synth;
		double samplerate = synth.getFormat().getSampleRate();

		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 double silentcounter = 1000;
	
	public void processAudio() {
		if (this.inputA.isSilent()) {
			silentcounter += 1 / synth.getControlRate();

			if (silentcounter > 60) {
				if (!mix) {
					left.clear();
					right.clear();
				}
				return;
			}
		} else
			silentcounter = 0;
		
		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;

		for (int i = 0; i < numsamples; i++) 
			input[i] = inputA[i] * again;
		
		delay.processReplace(input, input);
		

		
		if (right != null)
		{			
			if (outR == null || outR.length < numsamples)
				outR = new float[numsamples];
			Arrays.fill(outR, 0);			
			for (int i = 0; i < combR.length; i++) 
				combR[i].processMix(input, outR);
			for (int i = 0; i < allpassL.length; i++) 
				allpassR[i].processReplace(outR, outR);
			
			if (mix) 
				for (int i = 0; i < numsamples; i++) 
					right[i] += outR[i];										
			else
				for (int i = 0; i < numsamples; i++) 
					right[i] = outR[i];							
		}
		

		if (outL == null || outL.length < numsamples)
			outL = new float[numsamples];
		Arrays.fill(outL, 0);
		for (int i = 0; i < combL.length; i++)
			combL[i].processMix(input, outL);
		for (int i = 0; i < allpassL.length; i++) 
			allpassL[i].processReplace(outL, outL);

		if (mix) 
			for (int i = 0; i < numsamples; i++) 
				left[i] += outL[i];			
		else 
			for (int i = 0; i < numsamples; i++) 
				left[i] = outL[i];

		
	}

	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 < 8; i++) {
			combL[i].feedback = roomsize;
			combR[i].feedback = roomsize;
		}
	}

	public void setPreDelay(float value) {
		delay.setDelay((int) (value * synth.getFormat().getSampleRate()));
	}

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

	public void setDamp(float value) {
		double x = (value / synth.getFormat().getSampleRate()) * (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 < 8; i++) {
			combL[i].setDamp(damp);
			combR[i].setDamp(damp);
		}

	}

}