jogl.git - JOGL repository on http://jogamp.org/ ;

diff options

Diffstat (limited to 'src/jogl/classes/jogamp/opengl/egl/EGLContext.java')

-rw-r--r--

src/jogl/classes/jogamp/opengl/egl/EGLContext.java

1 files changed, 51 insertions, 25 deletions

/** * Reverb for the OpenAL cross platform audio library * Copyright (C) 2008-2009 by Christopher Fitzgerald. * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library 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 * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * Or go to http://www.gnu.org/copyleft/lgpl.html */ #include "config.h" #include <stdio.h> #include <stdlib.h> #include <math.h> #include "AL/al.h" #include "AL/alc.h" #include "alMain.h" #include "alAuxEffectSlot.h" #include "alEffect.h" #include "alError.h" #include "alu.h" typedef struct DelayLine { // The delay lines use sample lengths that are powers of 2 to allow the // use of bit-masking instead of a modulus for wrapping. ALuint Mask; ALfloat *Line; } DelayLine; typedef struct ALverbState { // Must be first in all effects! ALeffectState state; // All delay lines are allocated as a single buffer to reduce memory // fragmentation and management code. ALfloat *SampleBuffer; ALuint TotalSamples; // Master effect low-pass filter (2 chained 1-pole filters). FILTER LpFilter; ALfloat LpHistory[2]; struct { // Modulator delay line. DelayLine Delay; // The vibrato time is tracked with an index over a modulus-wrapped // range (in samples). ALuint Index; ALuint Range; // The depth of frequency change (also in samples) and its filter. ALfloat Depth; ALfloat Coeff; ALfloat Filter; } Mod; // Initial effect delay. DelayLine Delay; // The tap points for the initial delay. First tap goes to early // reflections, the last to late reverb. ALuint DelayTap[2]; struct { // Output gain for early reflections. ALfloat Gain; // Early reflections are done with 4 delay lines. ALfloat Coeff[4]; DelayLine Delay[4]; ALuint Offset[4]; // The gain for each output channel based on 3D panning (only for the // EAX path). ALfloat PanGain[MaxChannels]; } Early; // Decorrelator delay line. DelayLine Decorrelator; // There are actually 4 decorrelator taps, but the first occurs at the // initial sample. ALuint DecoTap[3]; struct { // Output gain for late reverb. ALfloat Gain; // Attenuation to compensate for the modal density and decay rate of // the late lines. ALfloat DensityGain; // The feed-back and feed-forward all-pass coefficient. ALfloat ApFeedCoeff; // Mixing matrix coefficient. ALfloat MixCoeff; // Late reverb has 4 parallel all-pass filters. ALfloat ApCoeff[4]; DelayLine ApDelay[4]; ALuint ApOffset[4]; // In addition to 4 cyclical delay lines. ALfloat Coeff[4]; DelayLine Delay[4]; ALuint Offset[4]; // The cyclical delay lines are 1-pole low-pass filtered. ALfloat LpCoeff[4]; ALfloat LpSample[4]; // The gain for each output channel based on 3D panning (only for the // EAX path). ALfloat PanGain[MaxChannels]; } Late; struct { // Attenuation to compensate for the modal density and decay rate of // the echo line. ALfloat DensityGain; // Echo delay and all-pass lines. DelayLine Delay; DelayLine ApDelay; ALfloat Coeff; ALfloat ApFeedCoeff; ALfloat ApCoeff; ALuint Offset; ALuint ApOffset; // The echo line is 1-pole low-pass filtered. ALfloat LpCoeff; ALfloat LpSample; // Echo mixing coefficients. ALfloat MixCoeff[2]; } Echo; // The current read offset for all delay lines. ALuint Offset; // The gain for each output channel (non-EAX path only; aliased from // Late.PanGain) ALfloat *Gain; } ALverbState; /* This is a user config option for modifying the overall output of the reverb * effect. */ ALfloat ReverbBoost = 1.0f; /* Specifies whether to use a standard reverb effect in place of EAX reverb */ ALboolean EmulateEAXReverb = AL_FALSE; /* This coefficient is used to define the maximum frequency range controlled * by the modulation depth. The current value of 0.1 will allow it to swing * from 0.9x to 1.1x. This value must be below 1. At 1 it will cause the * sampler to stall on the downswing, and above 1 it will cause it to sample * backwards. */ static const ALfloat MODULATION_DEPTH_COEFF = 0.1f; /* A filter is used to avoid the terrible distortion caused by changing * modulation time and/or depth. To be consistent across different sample * rates, the coefficient must be raised to a constant divided by the sample * rate: coeff^(constant / rate). */ static const ALfloat MODULATION_FILTER_COEFF = 0.048f; static const ALfloat MODULATION_FILTER_CONST = 100000.0f; // When diffusion is above 0, an all-pass filter is used to take the edge off // the echo effect. It uses the following line length (in seconds). static const ALfloat ECHO_ALLPASS_LENGTH = 0.0133f; // Input into the late reverb is decorrelated between four channels. Their // timings are dependent on a fraction and multiplier. See the // UpdateDecorrelator() routine for the calculations involved. static const ALfloat DECO_FRACTION = 0.15f; static const ALfloat DECO_MULTIPLIER = 2.0f; // All delay line lengths are specified in seconds. // The lengths of the early delay lines. static const ALfloat EARLY_LINE_LENGTH[4] = { 0.0015f, 0.0045f, 0.0135f, 0.0405f }; // The lengths of the late all-pass delay lines. static const ALfloat ALLPASS_LINE_LENGTH[4] = { 0.0151f, 0.0167f, 0.0183f, 0.0200f, }; // The lengths of the late cyclical delay lines. static const ALfloat LATE_LINE_LENGTH[4] = { 0.0211f, 0.0311f, 0.0461f, 0.0680f }; // The late cyclical delay lines have a variable length dependent on the // effect's density parameter (inverted for some reason) and this multiplier. static const ALfloat LATE_LINE_MULTIPLIER = 4.0f; // Basic delay line input/output routines. static __inline ALfloat DelayLineOut(DelayLine *Delay, ALuint offset) { return Delay->Line[offset&Delay->Mask]; } static __inline ALvoid DelayLineIn(DelayLine *Delay, ALuint offset, ALfloat in) { Delay->Line[offset&Delay->Mask] = in; } // Attenuated delay line output routine. static __inline ALfloat AttenuatedDelayLineOut(DelayLine *Delay, ALuint offset, ALfloat coeff) { return coeff * Delay->Line[offset&Delay->Mask]; } // Basic attenuated all-pass input/output routine. static __inline ALfloat AllpassInOut(DelayLine *Delay, ALuint outOffset, ALuint inOffset, ALfloat in, ALfloat feedCoeff, ALfloat coeff) { ALfloat out, feed; out = DelayLineOut(Delay, outOffset); feed = feedCoeff * in; DelayLineIn(Delay, inOffset, (feedCoeff * (out - feed)) + in); // The time-based attenuation is only applied to the delay output to // keep it from affecting the feed-back path (which is already controlled // by the all-pass feed coefficient). return (coeff * out) - feed; } // Given an input sample, this function produces modulation for the late // reverb. static __inline ALfloat EAXModulation(ALverbState *State, ALfloat in) { ALfloat sinus, frac; ALuint offset; ALfloat out0, out1; // Calculate the sinus rythm (dependent on modulation time and the // sampling rate). The center of the sinus is moved to reduce the delay // of the effect when the time or depth are low. sinus = 1.0f - cosf(F_PI*2.0f * State->Mod.Index / State->Mod.Range); // The depth determines the range over which to read the input samples // from, so it must be filtered to reduce the distortion caused by even // small parameter changes. State->Mod.Filter = lerp(State->Mod.Filter, State->Mod.Depth, State->Mod.Coeff); // Calculate the read offset and fraction between it and the next sample. frac = (1.0f + (State->Mod.Filter * sinus)); offset = fastf2u(frac); frac -= offset; // Get the two samples crossed by the offset, and feed the delay line // with the next input sample. out0 = DelayLineOut(&State->Mod.Delay, State->Offset - offset); out1 = DelayLineOut(&State->Mod.Delay, State->Offset - offset - 1); DelayLineIn(&State->Mod.Delay, State->Offset, in); // Step the modulation index forward, keeping it bound to its range. State->Mod.Index = (State->Mod.Index + 1) % State->Mod.Range; // The output is obtained by linearly interpolating the two samples that // were acquired above. return lerp(out0, out1, frac); } // Delay line output routine for early reflections. static __inline ALfloat EarlyDelayLineOut(ALverbState *State, ALuint index) { return AttenuatedDelayLineOut(&State->Early.Delay[index], State->Offset - State->Early.Offset[index], State->Early.Coeff[index]); } // Given an input sample, this function produces four-channel output for the // early reflections. static __inline ALvoid EarlyReflection(ALverbState *State, ALfloat in, ALfloat *out) { ALfloat d[4], v, f[4]; // Obtain the decayed results of each early delay line. d[0] = EarlyDelayLineOut(State, 0); d[1] = EarlyDelayLineOut(State, 1); d[2] = EarlyDelayLineOut(State, 2); d[3] = EarlyDelayLineOut(State, 3); /* The following uses a lossless scattering junction from waveguide * theory. It actually amounts to a householder mixing matrix, which * will produce a maximally diffuse response, and means this can probably * be considered a simple feed-back delay network (FDN). * N * --- * \ * v = 2/N / d_i * --- * i=1 */ v = (d[0] + d[1] + d[2] + d[3]) * 0.5f; // The junction is loaded with the input here. v += in; // Calculate the feed values for the delay lines. f[0] = v - d[0]; f[1] = v - d[1]; f[2] = v - d[2]; f[3] = v - d[3]; // Re-feed the delay lines. DelayLineIn(&State->Early.Delay[0], State->Offset, f[0]); DelayLineIn(&State->Early.Delay[1], State->Offset, f[1]); DelayLineIn(&State->Early.Delay[2], State->Offset, f[2]); DelayLineIn(&State->Early.Delay[3], State->Offset, f[3]); // Output the results of the junction for all four channels. out[0] = State->Early.Gain * f[0]; out[1] = State->Early.Gain * f[1]; out[2] = State->Early.Gain * f[2]; out[3] = State->Early.Gain * f[3]; } // All-pass input/output routine for late reverb. static __inline ALfloat LateAllPassInOut(ALverbState *State, ALuint index, ALfloat in) { return AllpassInOut(&State->Late.ApDelay[index], State->Offset - State->Late.ApOffset[index], State->Offset, in, State->Late.ApFeedCoeff, State->Late.ApCoeff[index]); } // Delay line output routine for late reverb. static __inline ALfloat LateDelayLineOut(ALverbState *State, ALuint index) { return AttenuatedDelayLineOut(&State->Late.Delay[index], State->Offset - State->Late.Offset[index], State->Late.Coeff[index]); } // Low-pass filter input/output routine for late reverb. static __inline ALfloat LateLowPassInOut(ALverbState *State, ALuint index, ALfloat in) { in = lerp(in, State->Late.LpSample[index], State->Late.LpCoeff[index]); State->Late.LpSample[index] = in; return in; } // Given four decorrelated input samples, this function produces four-channel // output for the late reverb. static __inline ALvoid LateReverb(ALverbState *State, ALfloat *in, ALfloat *out) { ALfloat d[4], f[4]; // Obtain the decayed results of the cyclical delay lines, and add the // corresponding input channels. Then pass the results through the // low-pass filters. // This is where the feed-back cycles from line 0 to 1 to 3 to 2 and back // to 0. d[0] = LateLowPassInOut(State, 2, in[2] + LateDelayLineOut(State, 2)); d[1] = LateLowPassInOut(State, 0, in[0] + LateDelayLineOut(State, 0)); d[2] = LateLowPassInOut(State, 3, in[3] + LateDelayLineOut(State, 3)); d[3] = LateLowPassInOut(State, 1, in[1] + LateDelayLineOut(State, 1)); // To help increase diffusion, run each line through an all-pass filter. // When there is no diffusion, the shortest all-pass filter will feed the // shortest delay line. d[0] = LateAllPassInOut(State, 0, d[0]); d[1] = LateAllPassInOut(State, 1, d[1]); d[2] = LateAllPassInOut(State, 2, d[2]); d[3] = LateAllPassInOut(State, 3, d[3]); /* Late reverb is done with a modified feed-back delay network (FDN) * topology. Four input lines are each fed through their own all-pass * filter and then into the mixing matrix. The four outputs of the * mixing matrix are then cycled back to the inputs. Each output feeds * a different input to form a circlular feed cycle. * * The mixing matrix used is a 4D skew-symmetric rotation matrix derived * using a single unitary rotational parameter: * * [ d, a, b, c ] 1 = a^2 + b^2 + c^2 + d^2 * [ -a, d, c, -b ] * [ -b, -c, d, a ] * [ -c, b, -a, d ] * * The rotation is constructed from the effect's diffusion parameter, * yielding: 1 = x^2 + 3 y^2; where a, b, and c are the coefficient y * with differing signs, and d is the coefficient x. The matrix is thus: * * [ x, y, -y, y ] n = sqrt(matrix_order - 1) * [ -y, x, y, y ] t = diffusion_parameter * atan(n) * [ y, -y, x, y ] x = cos(t) * [ -y, -y, -y, x ] y = sin(t) / n * * To reduce the number of multiplies, the x coefficient is applied with * the cyclical delay line coefficients. Thus only the y coefficient is * applied when mixing, and is modified to be: y / x. */ f[0] = d[0] + (State->Late.MixCoeff * ( d[1] + -d[2] + d[3])); f[1] = d[1] + (State->Late.MixCoeff * (-d[0] + d[2] + d[3])); f[2] = d[2] + (State->Late.MixCoeff * ( d[0] + -d[1] + d[3])); f[3] = d[3] + (State->Late.MixCoeff * (-d[0] + -d[1] + -d[2] )); // Output the results of the matrix for all four channels, attenuated by // the late reverb gain (which is attenuated by the 'x' mix coefficient). out[0] = State->Late.Gain * f[0]; out[1] = State->Late.Gain * f[1]; out[2] = State->Late.Gain * f[2]; out[3] = State->Late.Gain * f[3]; // Re-feed the cyclical delay lines. DelayLineIn(&State->Late.Delay[0], State->Offset, f[0]); DelayLineIn(&State->Late.Delay[1], State->Offset, f[1]); DelayLineIn(&State->Late.Delay[2], State->Offset, f[2]); DelayLineIn(&State->Late.Delay[3], State->Offset, f[3]); } // Given an input sample, this function mixes echo into the four-channel late // reverb. static __inline ALvoid EAXEcho(ALverbState *State, ALfloat in, ALfloat *late) { ALfloat out, feed; // Get the latest attenuated echo sample for output. feed = AttenuatedDelayLineOut(&State->Echo.Delay, State->Offset - State->Echo.Offset, State->Echo.Coeff); // Mix the output into the late reverb channels. out = State->Echo.MixCoeff[0] * feed; late[0] = (State->Echo.MixCoeff[1] * late[0]) + out; late[1] = (State->Echo.MixCoeff[1] * late[1]) + out; late[2] = (State->Echo.MixCoeff[1] * late[2]) + out; late[3] = (State->Echo.MixCoeff[1] * late[3]) + out; // Mix the energy-attenuated input with the output and pass it through // the echo low-pass filter. feed += State->Echo.DensityGain * in; feed = lerp(feed, State->Echo.LpSample, State->Echo.LpCoeff); State->Echo.LpSample = feed; // Then the echo all-pass filter. feed = AllpassInOut(&State->Echo.ApDelay, State->Offset - State->Echo.ApOffset, State->Offset, feed, State->Echo.ApFeedCoeff, State->Echo.ApCoeff); // Feed the delay with the mixed and filtered sample. DelayLineIn(&State->Echo.Delay, State->Offset, feed); } // Perform the non-EAX reverb pass on a given input sample, resulting in // four-channel output. static __inline ALvoid VerbPass(ALverbState *State, ALfloat in, ALfloat *early, ALfloat *late) { ALfloat feed, taps[4]; // Low-pass filter the incoming sample. in = lpFilter2P(&State->LpFilter, 0, in); // Feed the initial delay line. DelayLineIn(&State->Delay, State->Offset, in); // Calculate the early reflection from the first delay tap. in = DelayLineOut(&State->Delay, State->Offset - State->DelayTap[0]); EarlyReflection(State, in, early); // Feed the decorrelator from the energy-attenuated output of the second // delay tap. in = DelayLineOut(&State->Delay, State->Offset - State->DelayTap[1]); feed = in * State->Late.DensityGain; DelayLineIn(&State->Decorrelator, State->Offset, feed); // Calculate the late reverb from the decorrelator taps. taps[0] = feed; taps[1] = DelayLineOut(&State->Decorrelator, State->Offset - State->DecoTap[0]); taps[2] = DelayLineOut(&State->Decorrelator, State->Offset - State->DecoTap[1]); taps[3] = DelayLineOut(&State->Decorrelator, State->Offset - State->DecoTap[2]); LateReverb(State, taps, late); // Step all delays forward one sample. State->Offset++; } // Perform the EAX reverb pass on a given input sample, resulting in four- // channel output. static __inline ALvoid EAXVerbPass(ALverbState *State, ALfloat in, ALfloat *early, ALfloat *late) { ALfloat feed, taps[4]; // Low-pass filter the incoming sample. in = lpFilter2P(&State->LpFilter, 0, in); // Perform any modulation on the input. in = EAXModulation(State, in); // Feed the initial delay line. DelayLineIn(&State->Delay, State->Offset, in); // Calculate the early reflection from the first delay tap. in = DelayLineOut(&State->Delay, State->Offset - State->DelayTap[0]); EarlyReflection(State, in, early); // Feed the decorrelator from the energy-attenuated output of the second // delay tap. in = DelayLineOut(&State->Delay, State->Offset - State->DelayTap[1]); feed = in * State->Late.DensityGain; DelayLineIn(&State->Decorrelator, State->Offset, feed); // Calculate the late reverb from the decorrelator taps. taps[0] = feed; taps[1] = DelayLineOut(&State->Decorrelator, State->Offset - State->DecoTap[0]); taps[2] = DelayLineOut(&State->Decorrelator, State->Offset - State->DecoTap[1]); taps[3] = DelayLineOut(&State->Decorrelator, State->Offset - State->DecoTap[2]); LateReverb(State, taps, late); // Calculate and mix in any echo. EAXEcho(State, in, late); // Step all delays forward one sample. State->Offset++; } // This processes the reverb state, given the input samples and an output // buffer. static ALvoid VerbProcess(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[MaxChannels]) { ALverbState *State = (ALverbState*)effect; ALuint index, c; ALfloat early[4], late[4], out[4]; const ALfloat *panGain = State->Gain; for(index = 0;index < SamplesToDo;index++) { // Process reverb for this sample. VerbPass(State, SamplesIn[index], early, late); // Mix early reflections and late reverb. out[0] = (early[0] + late[0]); out[1] = (early[1] + late[1]); out[2] = (early[2] + late[2]); out[3] = (early[3] + late[3]); // Output the results. for(c = 0;c < MaxChannels;c++) SamplesOut[index][c] += panGain[c] * out[c&3]; } } // This processes the EAX reverb state, given the input samples and an output // buffer. static ALvoid EAXVerbProcess(ALeffectState *effect, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[MaxChannels]) { ALverbState *State = (ALverbState*)effect; ALuint index, c; ALfloat early[4], late[4]; for(index = 0;index < SamplesToDo;index++) { // Process reverb for this sample. EAXVerbPass(State, SamplesIn[index], early, late); for(c = 0;c < MaxChannels;c++) SamplesOut[index][c] += State->Early.PanGain[c]*early[c&3] + State->Late.PanGain[c]*late[c&3]; } } // Given the allocated sample buffer, this function updates each delay line // offset. static __inline ALvoid RealizeLineOffset(ALfloat * sampleBuffer, DelayLine *Delay) { Delay->Line = &sampleBuffer[(ALintptrEXT)Delay->Line]; } // Calculate the length of a delay line and store its mask and offset. static ALuint CalcLineLength(ALfloat length, ALintptrEXT offset, ALuint frequency, DelayLine *Delay) { ALuint samples; // All line lengths are powers of 2, calculated from their lengths, with // an additional sample in case of rounding errors. samples = NextPowerOf2(fastf2u(length * frequency) + 1); // All lines share a single sample buffer. Delay->Mask = samples - 1; Delay->Line = (ALfloat*)offset; // Return the sample count for accumulation. return samples; } /* Calculates the delay line metrics and allocates the shared sample buffer * for all lines given the sample rate (frequency). If an allocation failure * occurs, it returns AL_FALSE. */ static ALboolean AllocLines(ALuint frequency, ALverbState *State) { ALuint totalSamples, index; ALfloat length; ALfloat *newBuffer = NULL; // All delay line lengths are calculated to accomodate the full range of // lengths given their respective paramters. totalSamples = 0; /* The modulator's line length is calculated from the maximum modulation * time and depth coefficient, and halfed for the low-to-high frequency * swing. An additional sample is added to keep it stable when there is no * modulation. */ length = (AL_EAXREVERB_MAX_MODULATION_TIME*MODULATION_DEPTH_COEFF/2.0f) + (1.0f / frequency); totalSamples += CalcLineLength(length, totalSamples, frequency, &State->Mod.Delay); // The initial delay is the sum of the reflections and late reverb // delays. length = AL_EAXREVERB_MAX_REFLECTIONS_DELAY + AL_EAXREVERB_MAX_LATE_REVERB_DELAY; totalSamples += CalcLineLength(length, totalSamples, frequency, &State->Delay); // The early reflection lines.


context:
space:
mode: