b3db213eb5
We no longer put the filename at start of file. Change-Id: Ic435b159a23105681e3d4a6cb1ac097bc853302e
262 lines
11 KiB
C++
262 lines
11 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,
|
|
audio_io_handle_t output);
|
|
static status_t getStreamVolume(audio_stream_type_t stream, float* volume,
|
|
audio_io_handle_t 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 descriptor 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, audio_io_handle_t 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<audio_stream_type_t, 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_*/
|