| /* | |
| * Copyright (C) 2010 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| package android.media.audiofx; | |
| import android.media.audiofx.AudioEffect; | |
| import java.util.StringTokenizer; | |
| /** | |
| * A sound generated within a room travels in many directions. The listener first hears the direct | |
| * sound from the source itself. Later, he or she hears discrete echoes caused by sound bouncing off | |
| * nearby walls, the ceiling and the floor. As sound waves arrive after undergoing more and more | |
| * reflections, individual reflections become indistinguishable and the listener hears continuous | |
| * reverberation that decays over time. | |
| * Reverb is vital for modeling a listener's environment. It can be used in music applications | |
| * to simulate music being played back in various environments, or in games to immerse the | |
| * listener within the game's environment. | |
| * The EnvironmentalReverb class allows an application to control each reverb engine property in a | |
| * global reverb environment and is more suitable for games. For basic control, more suitable for | |
| * music applications, it is recommended to use the | |
| * {@link android.media.audiofx.PresetReverb} class. | |
| * <p>An application creates a EnvironmentalReverb object to instantiate and control a reverb engine | |
| * in the audio framework. | |
| * <p>The methods, parameter types and units exposed by the EnvironmentalReverb implementation are | |
| * directly mapping those defined by the OpenSL ES 1.0.1 Specification | |
| * (http://www.khronos.org/opensles/) for the SLEnvironmentalReverbItf interface. | |
| * Please refer to this specification for more details. | |
| * <p>The EnvironmentalReverb is an output mix auxiliary effect and should be created on | |
| * Audio session 0. In order for a MediaPlayer or AudioTrack to be fed into this effect, | |
| * they must be explicitely attached to it and a send level must be specified. Use the effect ID | |
| * returned by getId() method to designate this particular effect when attaching it to the | |
| * MediaPlayer or AudioTrack. | |
| * <p>Creating a reverb on the output mix (audio session 0) requires permission | |
| * {@link android.Manifest.permission#MODIFY_AUDIO_SETTINGS} | |
| * <p>See {@link android.media.audiofx.AudioEffect} class for more details on controlling | |
| * audio effects. | |
| */ | |
| public class EnvironmentalReverb extends AudioEffect { | |
| private final static String TAG = "EnvironmentalReverb"; | |
| // These constants must be synchronized with those in | |
| // frameworks/base/include/media/EffectEnvironmentalReverbApi.h | |
| /** | |
| * Room level. Parameter ID for OnParameterChangeListener | |
| */ | |
| public static final int PARAM_ROOM_LEVEL = 0; | |
| /** | |
| * Room HF level. Parameter ID for OnParameterChangeListener | |
| */ | |
| public static final int PARAM_ROOM_HF_LEVEL = 1; | |
| /** | |
| * Decay time. Parameter ID for OnParameterChangeListener | |
| */ | |
| public static final int PARAM_DECAY_TIME = 2; | |
| /** | |
| * Decay HF ratio. Parameter ID for | |
| * {@link android.media.audiofx.EnvironmentalReverb.OnParameterChangeListener} | |
| */ | |
| public static final int PARAM_DECAY_HF_RATIO = 3; | |
| /** | |
| * Early reflections level. Parameter ID for OnParameterChangeListener | |
| */ | |
| public static final int PARAM_REFLECTIONS_LEVEL = 4; | |
| /** | |
| * Early reflections delay. Parameter ID for OnParameterChangeListener | |
| */ | |
| public static final int PARAM_REFLECTIONS_DELAY = 5; | |
| /** | |
| * Reverb level. Parameter ID for OnParameterChangeListener | |
| */ | |
| public static final int PARAM_REVERB_LEVEL = 6; | |
| /** | |
| * Reverb delay. Parameter ID for OnParameterChangeListener | |
| */ | |
| public static final int PARAM_REVERB_DELAY = 7; | |
| /** | |
| * Diffusion. Parameter ID for OnParameterChangeListener | |
| */ | |
| public static final int PARAM_DIFFUSION = 8; | |
| /** | |
| * Density. Parameter ID for OnParameterChangeListener | |
| */ | |
| public static final int PARAM_DENSITY = 9; | |
| // used by setProperties()/getProperties | |
| private static final int PARAM_PROPERTIES = 10; | |
| /** | |
| * Registered listener for parameter changes | |
| */ | |
| private OnParameterChangeListener mParamListener = null; | |
| /** | |
| * Listener used internally to to receive raw parameter change event from AudioEffect super | |
| * class | |
| */ | |
| private BaseParameterListener mBaseParamListener = null; | |
| /** | |
| * Lock for access to mParamListener | |
| */ | |
| private final Object mParamListenerLock = new Object(); | |
| /** | |
| * Class constructor. | |
| * @param priority the priority level requested by the application for controlling the | |
| * EnvironmentalReverb engine. As the same engine can be shared by several applications, this | |
| * parameter indicates how much the requesting application needs control of effect parameters. | |
| * The normal priority is 0, above normal is a positive number, below normal a negative number. | |
| * @param audioSession system wide unique audio session identifier. If audioSession | |
| * is not 0, the EnvironmentalReverb will be attached to the MediaPlayer or AudioTrack in the | |
| * same audio session. Otherwise, the EnvironmentalReverb will apply to the output mix. | |
| * As the EnvironmentalReverb is an auxiliary effect it is recommended to instantiate it on | |
| * audio session 0 and to attach it to the MediaPLayer auxiliary output. | |
| * | |
| * @throws java.lang.IllegalArgumentException | |
| * @throws java.lang.UnsupportedOperationException | |
| * @throws java.lang.RuntimeException | |
| */ | |
| public EnvironmentalReverb(int priority, int audioSession) | |
| throws IllegalArgumentException, UnsupportedOperationException, RuntimeException { | |
| super(EFFECT_TYPE_ENV_REVERB, EFFECT_TYPE_NULL, priority, audioSession); | |
| } | |
| /** | |
| * Sets the master volume level of the environmental reverb effect. | |
| * @param room room level in millibels. The valid range is [-9000, 0]. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public void setRoomLevel(short room) | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = shortToByteArray(room); | |
| checkStatus(setParameter(PARAM_ROOM_LEVEL, param)); | |
| } | |
| /** | |
| * Gets the master volume level of the environmental reverb effect. | |
| * @return the room level in millibels. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public short getRoomLevel() | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = new byte[2]; | |
| checkStatus(getParameter(PARAM_ROOM_LEVEL, param)); | |
| return byteArrayToShort(param); | |
| } | |
| /** | |
| * Sets the volume level at 5 kHz relative to the volume level at low frequencies of the | |
| * overall reverb effect. | |
| * <p>This controls a low-pass filter that will reduce the level of the high-frequency. | |
| * @param roomHF high frequency attenuation level in millibels. The valid range is [-9000, 0]. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public void setRoomHFLevel(short roomHF) | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = shortToByteArray(roomHF); | |
| checkStatus(setParameter(PARAM_ROOM_HF_LEVEL, param)); | |
| } | |
| /** | |
| * Gets the room HF level. | |
| * @return the room HF level in millibels. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public short getRoomHFLevel() | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = new byte[2]; | |
| checkStatus(getParameter(PARAM_ROOM_HF_LEVEL, param)); | |
| return byteArrayToShort(param); | |
| } | |
| /** | |
| * Sets the time taken for the level of reverberation to decay by 60 dB. | |
| * @param decayTime decay time in milliseconds. The valid range is [100, 20000]. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public void setDecayTime(int decayTime) | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = intToByteArray(decayTime); | |
| checkStatus(setParameter(PARAM_DECAY_TIME, param)); | |
| } | |
| /** | |
| * Gets the decay time. | |
| * @return the decay time in milliseconds. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public int getDecayTime() | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = new byte[4]; | |
| checkStatus(getParameter(PARAM_DECAY_TIME, param)); | |
| return byteArrayToInt(param); | |
| } | |
| /** | |
| * Sets the ratio of high frequency decay time (at 5 kHz) relative to the decay time at low | |
| * frequencies. | |
| * @param decayHFRatio high frequency decay ratio using a permille scale. The valid range is | |
| * [100, 2000]. A ratio of 1000 indicates that all frequencies decay at the same rate. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public void setDecayHFRatio(short decayHFRatio) | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = shortToByteArray(decayHFRatio); | |
| checkStatus(setParameter(PARAM_DECAY_HF_RATIO, param)); | |
| } | |
| /** | |
| * Gets the ratio of high frequency decay time (at 5 kHz) relative to low frequencies. | |
| * @return the decay HF ration. See {@link #setDecayHFRatio(short)} for units. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public short getDecayHFRatio() | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = new byte[2]; | |
| checkStatus(getParameter(PARAM_DECAY_HF_RATIO, param)); | |
| return byteArrayToShort(param); | |
| } | |
| /** | |
| * Sets the volume level of the early reflections. | |
| * <p>This level is combined with the overall room level | |
| * (set using {@link #setRoomLevel(short)}). | |
| * @param reflectionsLevel reflection level in millibels. The valid range is [-9000, 1000]. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public void setReflectionsLevel(short reflectionsLevel) | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = shortToByteArray(reflectionsLevel); | |
| checkStatus(setParameter(PARAM_REFLECTIONS_LEVEL, param)); | |
| } | |
| /** | |
| * Gets the volume level of the early reflections. | |
| * @return the early reflections level in millibels. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public short getReflectionsLevel() | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = new byte[2]; | |
| checkStatus(getParameter(PARAM_REFLECTIONS_LEVEL, param)); | |
| return byteArrayToShort(param); | |
| } | |
| /** | |
| * Sets the delay time for the early reflections. | |
| * <p>This method sets the time between when the direct path is heard and when the first | |
| * reflection is heard. | |
| * @param reflectionsDelay reflections delay in milliseconds. The valid range is [0, 300]. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public void setReflectionsDelay(int reflectionsDelay) | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = intToByteArray(reflectionsDelay); | |
| checkStatus(setParameter(PARAM_REFLECTIONS_DELAY, param)); | |
| } | |
| /** | |
| * Gets the reflections delay. | |
| * @return the early reflections delay in milliseconds. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public int getReflectionsDelay() | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = new byte[4]; | |
| checkStatus(getParameter(PARAM_REFLECTIONS_DELAY, param)); | |
| return byteArrayToInt(param); | |
| } | |
| /** | |
| * Sets the volume level of the late reverberation. | |
| * <p>This level is combined with the overall room level (set using {@link #setRoomLevel(short)}). | |
| * @param reverbLevel reverb level in millibels. The valid range is [-9000, 2000]. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public void setReverbLevel(short reverbLevel) | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = shortToByteArray(reverbLevel); | |
| checkStatus(setParameter(PARAM_REVERB_LEVEL, param)); | |
| } | |
| /** | |
| * Gets the reverb level. | |
| * @return the reverb level in millibels. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public short getReverbLevel() | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = new byte[2]; | |
| checkStatus(getParameter(PARAM_REVERB_LEVEL, param)); | |
| return byteArrayToShort(param); | |
| } | |
| /** | |
| * Sets the time between the first reflection and the reverberation. | |
| * @param reverbDelay reverb delay in milliseconds. The valid range is [0, 100]. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public void setReverbDelay(int reverbDelay) | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = intToByteArray(reverbDelay); | |
| checkStatus(setParameter(PARAM_REVERB_DELAY, param)); | |
| } | |
| /** | |
| * Gets the reverb delay. | |
| * @return the reverb delay in milliseconds. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public int getReverbDelay() | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = new byte[4]; | |
| checkStatus(getParameter(PARAM_REVERB_DELAY, param)); | |
| return byteArrayToInt(param); | |
| } | |
| /** | |
| * Sets the echo density in the late reverberation decay. | |
| * <p>The scale should approximately map linearly to the perceived change in reverberation. | |
| * @param diffusion diffusion specified using a permille scale. The diffusion valid range is | |
| * [0, 1000]. A value of 1000 o/oo indicates a smooth reverberation decay. | |
| * Values below this level give a more <i>grainy</i> character. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public void setDiffusion(short diffusion) | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = shortToByteArray(diffusion); | |
| checkStatus(setParameter(PARAM_DIFFUSION, param)); | |
| } | |
| /** | |
| * Gets diffusion level. | |
| * @return the diffusion level. See {@link #setDiffusion(short)} for units. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public short getDiffusion() | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = new byte[2]; | |
| checkStatus(getParameter(PARAM_DIFFUSION, param)); | |
| return byteArrayToShort(param); | |
| } | |
| /** | |
| * Controls the modal density of the late reverberation decay. | |
| * <p> The scale should approximately map linearly to the perceived change in reverberation. | |
| * A lower density creates a hollow sound that is useful for simulating small reverberation | |
| * spaces such as bathrooms. | |
| * @param density density specified using a permille scale. The valid range is [0, 1000]. | |
| * A value of 1000 o/oo indicates a natural sounding reverberation. Values below this level | |
| * produce a more colored effect. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public void setDensity(short density) | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = shortToByteArray(density); | |
| checkStatus(setParameter(PARAM_DENSITY, param)); | |
| } | |
| /** | |
| * Gets the density level. | |
| * @return the density level. See {@link #setDiffusion(short)} for units. | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public short getDensity() | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = new byte[2]; | |
| checkStatus(getParameter(PARAM_DENSITY, param)); | |
| return byteArrayToShort(param); | |
| } | |
| /** | |
| * The OnParameterChangeListener interface defines a method called by the EnvironmentalReverb | |
| * when a parameter value has changed. | |
| */ | |
| public interface OnParameterChangeListener { | |
| /** | |
| * Method called when a parameter value has changed. The method is called only if the | |
| * parameter was changed by another application having the control of the same | |
| * EnvironmentalReverb engine. | |
| * @param effect the EnvironmentalReverb on which the interface is registered. | |
| * @param status status of the set parameter operation. | |
| * @param param ID of the modified parameter. See {@link #PARAM_ROOM_LEVEL} ... | |
| * @param value the new parameter value. | |
| */ | |
| void onParameterChange(EnvironmentalReverb effect, int status, int param, int value); | |
| } | |
| /** | |
| * Listener used internally to receive unformatted parameter change events from AudioEffect | |
| * super class. | |
| */ | |
| private class BaseParameterListener implements AudioEffect.OnParameterChangeListener { | |
| private BaseParameterListener() { | |
| } | |
| public void onParameterChange(AudioEffect effect, int status, byte[] param, byte[] value) { | |
| OnParameterChangeListener l = null; | |
| synchronized (mParamListenerLock) { | |
| if (mParamListener != null) { | |
| l = mParamListener; | |
| } | |
| } | |
| if (l != null) { | |
| int p = -1; | |
| int v = -1; | |
| if (param.length == 4) { | |
| p = byteArrayToInt(param, 0); | |
| } | |
| if (value.length == 2) { | |
| v = (int)byteArrayToShort(value, 0); | |
| } else if (value.length == 4) { | |
| v = byteArrayToInt(value, 0); | |
| } | |
| if (p != -1 && v != -1) { | |
| l.onParameterChange(EnvironmentalReverb.this, status, p, v); | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * Registers an OnParameterChangeListener interface. | |
| * @param listener OnParameterChangeListener interface registered | |
| */ | |
| public void setParameterListener(OnParameterChangeListener listener) { | |
| synchronized (mParamListenerLock) { | |
| if (mParamListener == null) { | |
| mParamListener = listener; | |
| mBaseParamListener = new BaseParameterListener(); | |
| super.setParameterListener(mBaseParamListener); | |
| } | |
| } | |
| } | |
| /** | |
| * The Settings class regroups all environmental reverb parameters. It is used in | |
| * conjuntion with getProperties() and setProperties() methods to backup and restore | |
| * all parameters in a single call. | |
| */ | |
| public static class Settings { | |
| public short roomLevel; | |
| public short roomHFLevel; | |
| public int decayTime; | |
| public short decayHFRatio; | |
| public short reflectionsLevel; | |
| public int reflectionsDelay; | |
| public short reverbLevel; | |
| public int reverbDelay; | |
| public short diffusion; | |
| public short density; | |
| public Settings() { | |
| } | |
| /** | |
| * Settings class constructor from a key=value; pairs formatted string. The string is | |
| * typically returned by Settings.toString() method. | |
| * @throws IllegalArgumentException if the string is not correctly formatted. | |
| */ | |
| public Settings(String settings) { | |
| StringTokenizer st = new StringTokenizer(settings, "=;"); | |
| int tokens = st.countTokens(); | |
| if (st.countTokens() != 21) { | |
| throw new IllegalArgumentException("settings: " + settings); | |
| } | |
| String key = st.nextToken(); | |
| if (!key.equals("EnvironmentalReverb")) { | |
| throw new IllegalArgumentException( | |
| "invalid settings for EnvironmentalReverb: " + key); | |
| } | |
| try { | |
| key = st.nextToken(); | |
| if (!key.equals("roomLevel")) { | |
| throw new IllegalArgumentException("invalid key name: " + key); | |
| } | |
| roomLevel = Short.parseShort(st.nextToken()); | |
| key = st.nextToken(); | |
| if (!key.equals("roomHFLevel")) { | |
| throw new IllegalArgumentException("invalid key name: " + key); | |
| } | |
| roomHFLevel = Short.parseShort(st.nextToken()); | |
| key = st.nextToken(); | |
| if (!key.equals("decayTime")) { | |
| throw new IllegalArgumentException("invalid key name: " + key); | |
| } | |
| decayTime = Integer.parseInt(st.nextToken()); | |
| key = st.nextToken(); | |
| if (!key.equals("decayHFRatio")) { | |
| throw new IllegalArgumentException("invalid key name: " + key); | |
| } | |
| decayHFRatio = Short.parseShort(st.nextToken()); | |
| key = st.nextToken(); | |
| if (!key.equals("reflectionsLevel")) { | |
| throw new IllegalArgumentException("invalid key name: " + key); | |
| } | |
| reflectionsLevel = Short.parseShort(st.nextToken()); | |
| key = st.nextToken(); | |
| if (!key.equals("reflectionsDelay")) { | |
| throw new IllegalArgumentException("invalid key name: " + key); | |
| } | |
| reflectionsDelay = Integer.parseInt(st.nextToken()); | |
| key = st.nextToken(); | |
| if (!key.equals("reverbLevel")) { | |
| throw new IllegalArgumentException("invalid key name: " + key); | |
| } | |
| reverbLevel = Short.parseShort(st.nextToken()); | |
| key = st.nextToken(); | |
| if (!key.equals("reverbDelay")) { | |
| throw new IllegalArgumentException("invalid key name: " + key); | |
| } | |
| reverbDelay = Integer.parseInt(st.nextToken()); | |
| key = st.nextToken(); | |
| if (!key.equals("diffusion")) { | |
| throw new IllegalArgumentException("invalid key name: " + key); | |
| } | |
| diffusion = Short.parseShort(st.nextToken()); | |
| key = st.nextToken(); | |
| if (!key.equals("density")) { | |
| throw new IllegalArgumentException("invalid key name: " + key); | |
| } | |
| density = Short.parseShort(st.nextToken()); | |
| } catch (NumberFormatException nfe) { | |
| throw new IllegalArgumentException("invalid value for key: " + key); | |
| } | |
| } | |
| @Override | |
| public String toString() { | |
| return new String ( | |
| "EnvironmentalReverb"+ | |
| ";roomLevel="+Short.toString(roomLevel)+ | |
| ";roomHFLevel="+Short.toString(roomHFLevel)+ | |
| ";decayTime="+Integer.toString(decayTime)+ | |
| ";decayHFRatio="+Short.toString(decayHFRatio)+ | |
| ";reflectionsLevel="+Short.toString(reflectionsLevel)+ | |
| ";reflectionsDelay="+Integer.toString(reflectionsDelay)+ | |
| ";reverbLevel="+Short.toString(reverbLevel)+ | |
| ";reverbDelay="+Integer.toString(reverbDelay)+ | |
| ";diffusion="+Short.toString(diffusion)+ | |
| ";density="+Short.toString(density) | |
| ); | |
| } | |
| }; | |
| // Keep this in sync with sizeof(s_reverb_settings) defined in | |
| // frameworks/base/include/media/EffectEnvironmentalReverbApi.h | |
| static private int PROPERTY_SIZE = 26; | |
| /** | |
| * Gets the environmental reverb properties. This method is useful when a snapshot of current | |
| * reverb settings must be saved by the application. | |
| * @return an EnvironmentalReverb.Settings object containing all current parameters values | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public EnvironmentalReverb.Settings getProperties() | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = new byte[PROPERTY_SIZE]; | |
| checkStatus(getParameter(PARAM_PROPERTIES, param)); | |
| Settings settings = new Settings(); | |
| settings.roomLevel = byteArrayToShort(param, 0); | |
| settings.roomHFLevel = byteArrayToShort(param, 2); | |
| settings.decayTime = byteArrayToInt(param, 4); | |
| settings.decayHFRatio = byteArrayToShort(param, 8); | |
| settings.reflectionsLevel = byteArrayToShort(param, 10); | |
| settings.reflectionsDelay = byteArrayToInt(param, 12); | |
| settings.reverbLevel = byteArrayToShort(param, 16); | |
| settings.reverbDelay = byteArrayToInt(param, 18); | |
| settings.diffusion = byteArrayToShort(param, 22); | |
| settings.density = byteArrayToShort(param, 24); | |
| return settings; | |
| } | |
| /** | |
| * Sets the environmental reverb properties. This method is useful when reverb settings have to | |
| * be applied from a previous backup. | |
| * @param settings a EnvironmentalReverb.Settings object containing the properties to apply | |
| * @throws IllegalStateException | |
| * @throws IllegalArgumentException | |
| * @throws UnsupportedOperationException | |
| */ | |
| public void setProperties(EnvironmentalReverb.Settings settings) | |
| throws IllegalStateException, IllegalArgumentException, UnsupportedOperationException { | |
| byte[] param = concatArrays(shortToByteArray(settings.roomLevel), | |
| shortToByteArray(settings.roomHFLevel), | |
| intToByteArray(settings.decayTime), | |
| shortToByteArray(settings.decayHFRatio), | |
| shortToByteArray(settings.reflectionsLevel), | |
| intToByteArray(settings.reflectionsDelay), | |
| shortToByteArray(settings.reverbLevel), | |
| intToByteArray(settings.reverbDelay), | |
| shortToByteArray(settings.diffusion), | |
| shortToByteArray(settings.density)); | |
| checkStatus(setParameter(PARAM_PROPERTIES, param)); | |
| } | |
| } |