Back to index...

	/*
	* Copyright (c) 1999, 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 javax.sound.sampled;


	/**
	* The <code>ReverbType</code> class provides methods for
	* accessing various reverberation settings to be applied to
	* an audio signal.
	* <p>
	* Reverberation simulates the reflection of sound off of
	* the walls, ceiling, and floor of a room. Depending on
	* the size of the room, and how absorbent or reflective the materials in the
	* room's surfaces are, the sound might bounce around for a
	* long time before dying away.
	* <p>
	* The reverberation parameters provided by <code>ReverbType</code> consist
	* of the delay time and intensity of early reflections, the delay time and
	* intensity of late reflections, and an overall decay time.
	* Early reflections are the initial individual low-order reflections of the
	* direct signal off the surfaces in the room.
	* The late Reflections are the dense, high-order reflections that characterize
	* the room's reverberation.
	* The delay times for the start of these two reflection types give the listener
	* a sense of the overall size and complexity of the room's shape and contents.
	* The larger the room, the longer the reflection delay times.
	* The early and late reflections' intensities define the gain (in decibels) of the reflected
	* signals as compared to the direct signal. These intensities give the
	* listener an impression of the absorptive nature of the surfaces and objects
	* in the room.
	* The decay time defines how long the reverberation takes to exponentially
	* decay until it is no longer perceptible ("effective zero").
	* The larger and less absorbent the surfaces, the longer the decay time.
	* <p>
	* The set of parameters defined here may not include all aspects of reverberation
	* as specified by some systems. For example, the Midi Manufacturer's Association
	* (MMA) has an Interactive Audio Special Interest Group (IASIG), which has a
	* 3-D Working Group that has defined a Level 2 Spec (I3DL2). I3DL2
	* supports filtering of reverberation and
	* control of reverb density. These properties are not included in the JavaSound 1.0
	* definition of a reverb control. In such a case, the implementing system
	* should either extend the defined reverb control to include additional
	* parameters, or else interpret the system's additional capabilities in a way that fits
	* the model described here.
	* <p>
	* If implementing JavaSound on a I3DL2-compliant device:
	* <ul>
	* <li>Filtering is disabled (high-frequency attenuations are set to 0.0 dB)
	* <li>Density parameters are set to midway between minimum and maximum
	* </ul>
	* <p>
	* The following table shows what parameter values an implementation might use for a
	* representative set of reverberation settings.
	* <p>
	*
	* <b>Reverberation Types and Parameters</b>
	* <p>
	* <table border=1 cellpadding=5 summary="reverb types and params: decay time, late intensity, late delay, early intensity, and early delay">
	*
	* <tr>
	* <th>Type</th>
	* <th>Decay Time (ms)</th>
	* <th>Late Intensity (dB)</th>
	* <th>Late Delay (ms)</th>
	* <th>Early Intensity (dB)</th>
	* <th>Early Delay(ms)</th>
	* </tr>
	*
	* <tr>
	* <td>Cavern</td>
	* <td>2250</td>
	* <td>-2.0</td>
	* <td>41.3</td>
	* <td>-1.4</td>
	* <td>10.3</td>
	* </tr>
	*
	* <tr>
	* <td>Dungeon</td>
	* <td>1600</td>
	* <td>-1.0</td>
	* <td>10.3</td>
	* <td>-0.7</td>
	* <td>2.6</td>
	* </tr>
	*
	* <tr>
	* <td>Garage</td>
	* <td>900</td>
	* <td>-6.0</td>
	* <td>14.7</td>
	* <td>-4.0</td>
	* <td>3.9</td>
	* </tr>
	*
	* <tr>
	* <td>Acoustic Lab</td>
	* <td>280</td>
	* <td>-3.0</td>
	* <td>8.0</td>
	* <td>-2.0</td>
	* <td>2.0</td>
	* </tr>
	*
	* <tr>
	* <td>Closet</td>
	* <td>150</td>
	* <td>-10.0</td>
	* <td>2.5</td>
	* <td>-7.0</td>
	* <td>0.6</td>
	* </tr>
	*
	* </table>
	*
	* @author Kara Kytle
	* @since 1.3
	*/
	public class ReverbType {

	/**
	* Descriptive name of the reverb type..
	*/
	private String name;

	/**
	* Early reflection delay in microseconds.
	*/
	private int earlyReflectionDelay;

	/**
	* Early reflection intensity.
	*/
	private float earlyReflectionIntensity;

	/**
	* Late reflection delay in microseconds.
	*/
	private int lateReflectionDelay;

	/**
	* Late reflection intensity.
	*/
	private float lateReflectionIntensity;

	/**
	* Total decay time
	*/
	private int decayTime;


	/**
	* Constructs a new reverb type that has the specified reverberation
	* parameter values.
	* @param name the name of the new reverb type, or a zero-length <code>String</code>
	* @param earlyReflectionDelay the new type's early reflection delay time in microseconds
	* @param earlyReflectionIntensity the new type's early reflection intensity in dB
	* @param lateReflectionDelay the new type's late reflection delay time in microseconds
	* @param lateReflectionIntensity the new type's late reflection intensity in dB
	* @param decayTime the new type's decay time in microseconds
	*/
	protected ReverbType(String name, int earlyReflectionDelay, float earlyReflectionIntensity, int lateReflectionDelay, float lateReflectionIntensity, int decayTime) {

	this.name = name;
	this.earlyReflectionDelay = earlyReflectionDelay;
	this.earlyReflectionIntensity = earlyReflectionIntensity;
	this.lateReflectionDelay = lateReflectionDelay;
	this.lateReflectionIntensity = lateReflectionIntensity;
	this.decayTime = decayTime;
	}


	/**
	* Obtains the name of this reverb type.
	* @return the name of this reverb type
	* @since 1.5
	*/
	public String getName() {
	return name;
	}


	/**
	* Returns the early reflection delay time in microseconds.
	* This is the amount of time between when the direct signal is
	* heard and when the first early reflections are heard.
	* @return early reflection delay time for this reverb type, in microseconds
	*/
	public final int getEarlyReflectionDelay() {
	return earlyReflectionDelay;
	}


	/**
	* Returns the early reflection intensity in decibels.
	* This is the amplitude attenuation of the first early reflections
	* relative to the direct signal.
	* @return early reflection intensity for this reverb type, in dB
	*/
	public final float getEarlyReflectionIntensity() {
	return earlyReflectionIntensity;
	}


	/**
	* Returns the late reflection delay time in microseconds.
	* This is the amount of time between when the first early reflections
	* are heard and when the first late reflections are heard.
	* @return late reflection delay time for this reverb type, in microseconds
	*/
	public final int getLateReflectionDelay() {
	return lateReflectionDelay;
	}


	/**
	* Returns the late reflection intensity in decibels.
	* This is the amplitude attenuation of the first late reflections
	* relative to the direct signal.
	* @return late reflection intensity for this reverb type, in dB
	*/
	public final float getLateReflectionIntensity() {
	return lateReflectionIntensity;
	}


	/**
	* Obtains the decay time, which is the amount of time over which the
	* late reflections attenuate to effective zero. The effective zero
	* value is implementation-dependent.
	* @return the decay time of the late reflections, in microseconds
	*/
	public final int getDecayTime() {
	return decayTime;
	}


	/**
	* Indicates whether the specified object is equal to this reverb type,
	* returning <code>true</code> if the objects are identical.
	* @param obj the reference object with which to compare
	* @return <code>true</code> if this reverb type is the same as
	* <code>obj</code>; <code>false</code> otherwise
	*/
	public final boolean equals(Object obj) {
	return super.equals(obj);
	}


	/**
	* Finalizes the hashcode method.
	*/
	public final int hashCode() {
	return super.hashCode();
	}


	/**
	* Provides a <code>String</code> representation of the reverb type,
	* including its name and its parameter settings.
	* The exact contents of the string may vary between implementations of
	* Java Sound.
	* @return reverberation type name and description
	*/
	public final String toString() {

	//$$fb2001-07-20: fix for bug 4385060: The "name" attribute of class "ReverbType" is not accessible.
	//return (super.toString() + ", early reflection delay " + earlyReflectionDelay +
	return (name + ", early reflection delay " + earlyReflectionDelay +
	" ns, early reflection intensity " + earlyReflectionIntensity +
	" dB, late deflection delay " + lateReflectionDelay +
	" ns, late reflection intensity " + lateReflectionIntensity +
	" dB, decay time " + decayTime);
	}

	} // class ReverbType

Back to index...