0f0fbd9441
Was a mix of audio_source_t, uint8_t, and int. Related fixes: - fix comments in MediaRecorder.java - AudioPolicyService server side was not checking source parameter at all, so if the client wrapper was bypassed, invalid values could be passed into audio HAL - JNI android_media_AudioRecord_setup was checking source for positive values, but not negative values. This test is redundant, since already checked at Java and now checked by AudioPolicyService also, but might as well make it correct. Change-Id: Ie5e25d646dcd59a86d7985aa46cfcb4a1ba64a4a
260 lines
10 KiB
C++
260 lines
10 KiB
C++
/*
|
|
* Copyright (C) 2008 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.
|
|
*/
|
|
|
|
#ifndef ANDROID_AUDIOSYSTEM_H_
|
|
#define ANDROID_AUDIOSYSTEM_H_
|
|
|
|
#include <utils/RefBase.h>
|
|
#include <utils/threads.h>
|
|
#include <media/IAudioFlinger.h>
|
|
|
|
#include <system/audio.h>
|
|
#include <system/audio_policy.h>
|
|
|
|
/* XXX: Should be include by all the users instead */
|
|
#include <media/AudioParameter.h>
|
|
|
|
namespace android {
|
|
|
|
typedef void (*audio_error_callback)(status_t err);
|
|
|
|
class IAudioPolicyService;
|
|
class String8;
|
|
|
|
class AudioSystem
|
|
{
|
|
public:
|
|
|
|
/* These are static methods to control the system-wide AudioFlinger
|
|
* only privileged processes can have access to them
|
|
*/
|
|
|
|
// mute/unmute microphone
|
|
static status_t muteMicrophone(bool state);
|
|
static status_t isMicrophoneMuted(bool *state);
|
|
|
|
// set/get master volume
|
|
static status_t setMasterVolume(float value);
|
|
static status_t getMasterVolume(float* volume);
|
|
|
|
// mute/unmute audio outputs
|
|
static status_t setMasterMute(bool mute);
|
|
static status_t getMasterMute(bool* mute);
|
|
|
|
// set/get stream volume on specified output
|
|
static status_t setStreamVolume(audio_stream_type_t stream, float value, int output);
|
|
static status_t getStreamVolume(audio_stream_type_t stream, float* volume, int output);
|
|
|
|
// mute/unmute stream
|
|
static status_t setStreamMute(audio_stream_type_t stream, bool mute);
|
|
static status_t getStreamMute(audio_stream_type_t stream, bool* mute);
|
|
|
|
// set audio mode in audio hardware
|
|
static status_t setMode(audio_mode_t mode);
|
|
|
|
// returns true in *state if tracks are active on the specified stream or has been active
|
|
// in the past inPastMs milliseconds
|
|
static status_t isStreamActive(audio_stream_type_t stream, bool *state, uint32_t inPastMs = 0);
|
|
|
|
// set/get audio hardware parameters. The function accepts a list of parameters
|
|
// key value pairs in the form: key1=value1;key2=value2;...
|
|
// Some keys are reserved for standard parameters (See AudioParameter class).
|
|
static status_t setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs);
|
|
static String8 getParameters(audio_io_handle_t ioHandle, const String8& keys);
|
|
|
|
static void setErrorCallback(audio_error_callback cb);
|
|
|
|
// helper function to obtain AudioFlinger service handle
|
|
static const sp<IAudioFlinger>& get_audio_flinger();
|
|
|
|
static float linearToLog(int volume);
|
|
static int logToLinear(float volume);
|
|
|
|
static status_t getOutputSamplingRate(int* samplingRate, audio_stream_type_t stream = AUDIO_STREAM_DEFAULT);
|
|
static status_t getOutputFrameCount(int* frameCount, audio_stream_type_t stream = AUDIO_STREAM_DEFAULT);
|
|
static status_t getOutputLatency(uint32_t* latency, audio_stream_type_t stream = AUDIO_STREAM_DEFAULT);
|
|
|
|
// DEPRECATED
|
|
static status_t getOutputSamplingRate(int* samplingRate, int stream = AUDIO_STREAM_DEFAULT);
|
|
|
|
// DEPRECATED
|
|
static status_t getOutputFrameCount(int* frameCount, int stream = AUDIO_STREAM_DEFAULT);
|
|
|
|
static bool routedToA2dpOutput(audio_stream_type_t streamType);
|
|
|
|
static status_t getInputBufferSize(uint32_t sampleRate, audio_format_t format, int channelCount,
|
|
size_t* buffSize);
|
|
|
|
static status_t setVoiceVolume(float volume);
|
|
|
|
// return the number of audio frames written by AudioFlinger to audio HAL and
|
|
// audio dsp to DAC since the output on which the specified stream is playing
|
|
// has exited standby.
|
|
// returned status (from utils/Errors.h) can be:
|
|
// - NO_ERROR: successful operation, halFrames and dspFrames point to valid data
|
|
// - INVALID_OPERATION: Not supported on current hardware platform
|
|
// - BAD_VALUE: invalid parameter
|
|
// NOTE: this feature is not supported on all hardware platforms and it is
|
|
// necessary to check returned status before using the returned values.
|
|
static status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, audio_stream_type_t stream = AUDIO_STREAM_DEFAULT);
|
|
|
|
static unsigned int getInputFramesLost(audio_io_handle_t ioHandle);
|
|
|
|
static int newAudioSessionId();
|
|
static void acquireAudioSessionId(int audioSession);
|
|
static void releaseAudioSessionId(int audioSession);
|
|
|
|
// types of io configuration change events received with ioConfigChanged()
|
|
enum io_config_event {
|
|
OUTPUT_OPENED,
|
|
OUTPUT_CLOSED,
|
|
OUTPUT_CONFIG_CHANGED,
|
|
INPUT_OPENED,
|
|
INPUT_CLOSED,
|
|
INPUT_CONFIG_CHANGED,
|
|
STREAM_CONFIG_CHANGED,
|
|
NUM_CONFIG_EVENTS
|
|
};
|
|
|
|
// audio output descritor used to cache output configurations in client process to avoid frequent calls
|
|
// through IAudioFlinger
|
|
class OutputDescriptor {
|
|
public:
|
|
OutputDescriptor()
|
|
: samplingRate(0), format(AUDIO_FORMAT_DEFAULT), channels(0), frameCount(0), latency(0) {}
|
|
|
|
uint32_t samplingRate;
|
|
int32_t format;
|
|
int32_t channels;
|
|
size_t frameCount;
|
|
uint32_t latency;
|
|
};
|
|
|
|
//
|
|
// IAudioPolicyService interface (see AudioPolicyInterface for method descriptions)
|
|
//
|
|
static status_t setDeviceConnectionState(audio_devices_t device, audio_policy_dev_state_t state, const char *device_address);
|
|
static audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, const char *device_address);
|
|
static status_t setPhoneState(audio_mode_t state);
|
|
static status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config);
|
|
static audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage);
|
|
static audio_io_handle_t getOutput(audio_stream_type_t stream,
|
|
uint32_t samplingRate = 0,
|
|
audio_format_t format = AUDIO_FORMAT_DEFAULT,
|
|
uint32_t channels = AUDIO_CHANNEL_OUT_STEREO,
|
|
audio_policy_output_flags_t flags = AUDIO_POLICY_OUTPUT_FLAG_INDIRECT);
|
|
static status_t startOutput(audio_io_handle_t output,
|
|
audio_stream_type_t stream,
|
|
int session = 0);
|
|
static status_t stopOutput(audio_io_handle_t output,
|
|
audio_stream_type_t stream,
|
|
int session = 0);
|
|
static void releaseOutput(audio_io_handle_t output);
|
|
static audio_io_handle_t getInput(audio_source_t inputSource,
|
|
uint32_t samplingRate = 0,
|
|
audio_format_t format = AUDIO_FORMAT_DEFAULT,
|
|
uint32_t channels = AUDIO_CHANNEL_IN_MONO,
|
|
audio_in_acoustics_t acoustics = (audio_in_acoustics_t)0,
|
|
int sessionId = 0);
|
|
static status_t startInput(audio_io_handle_t input);
|
|
static status_t stopInput(audio_io_handle_t input);
|
|
static void releaseInput(audio_io_handle_t input);
|
|
static status_t initStreamVolume(audio_stream_type_t stream,
|
|
int indexMin,
|
|
int indexMax);
|
|
static status_t setStreamVolumeIndex(audio_stream_type_t stream,
|
|
int index,
|
|
audio_devices_t device);
|
|
static status_t getStreamVolumeIndex(audio_stream_type_t stream,
|
|
int *index,
|
|
audio_devices_t device);
|
|
|
|
static uint32_t getStrategyForStream(audio_stream_type_t stream);
|
|
static uint32_t getDevicesForStream(audio_stream_type_t stream);
|
|
|
|
static audio_io_handle_t getOutputForEffect(effect_descriptor_t *desc);
|
|
static status_t registerEffect(effect_descriptor_t *desc,
|
|
audio_io_handle_t io,
|
|
uint32_t strategy,
|
|
int session,
|
|
int id);
|
|
static status_t unregisterEffect(int id);
|
|
static status_t setEffectEnabled(int id, bool enabled);
|
|
|
|
// clear stream to output mapping cache (gStreamOutputMap)
|
|
// and output configuration cache (gOutputs)
|
|
static void clearAudioConfigCache();
|
|
|
|
static const sp<IAudioPolicyService>& get_audio_policy_service();
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
private:
|
|
|
|
class AudioFlingerClient: public IBinder::DeathRecipient, public BnAudioFlingerClient
|
|
{
|
|
public:
|
|
AudioFlingerClient() {
|
|
}
|
|
|
|
// DeathRecipient
|
|
virtual void binderDied(const wp<IBinder>& who);
|
|
|
|
// IAudioFlingerClient
|
|
|
|
// indicate a change in the configuration of an output or input: keeps the cached
|
|
// values for output/input parameters upto date in client process
|
|
virtual void ioConfigChanged(int event, int ioHandle, void *param2);
|
|
};
|
|
|
|
class AudioPolicyServiceClient: public IBinder::DeathRecipient
|
|
{
|
|
public:
|
|
AudioPolicyServiceClient() {
|
|
}
|
|
|
|
// DeathRecipient
|
|
virtual void binderDied(const wp<IBinder>& who);
|
|
};
|
|
|
|
static sp<AudioFlingerClient> gAudioFlingerClient;
|
|
static sp<AudioPolicyServiceClient> gAudioPolicyServiceClient;
|
|
friend class AudioFlingerClient;
|
|
friend class AudioPolicyServiceClient;
|
|
|
|
static Mutex gLock;
|
|
static sp<IAudioFlinger> gAudioFlinger;
|
|
static audio_error_callback gAudioErrorCallback;
|
|
|
|
static size_t gInBuffSize;
|
|
// previous parameters for recording buffer size queries
|
|
static uint32_t gPrevInSamplingRate;
|
|
static audio_format_t gPrevInFormat;
|
|
static int gPrevInChannelCount;
|
|
|
|
static sp<IAudioPolicyService> gAudioPolicyService;
|
|
|
|
// mapping between stream types and outputs
|
|
static DefaultKeyedVector<int, audio_io_handle_t> gStreamOutputMap;
|
|
// list of output descriptors containing cached parameters
|
|
// (sampling rate, framecount, channel count...)
|
|
static DefaultKeyedVector<audio_io_handle_t, OutputDescriptor *> gOutputs;
|
|
};
|
|
|
|
}; // namespace android
|
|
|
|
#endif /*ANDROID_AUDIOSYSTEM_H_*/
|