diff options
33 files changed, 888 insertions, 1108 deletions
diff --git a/cmds/stagefright/audioloop.cpp b/cmds/stagefright/audioloop.cpp index 8733662..ceb254f 100644 --- a/cmds/stagefright/audioloop.cpp +++ b/cmds/stagefright/audioloop.cpp @@ -11,6 +11,8 @@ #include <media/stagefright/OMXClient.h> #include <media/stagefright/OMXCodec.h> +#include <hardware/audio.h> + using namespace android; int main() { @@ -31,8 +33,8 @@ int main() { AUDIO_SOURCE_DEFAULT, kSampleRate, kNumChannels == 1 - ? AudioSystem::CHANNEL_IN_MONO - : AudioSystem::CHANNEL_IN_STEREO); + ? AUDIO_CHANNEL_IN_MONO + : AUDIO_CHANNEL_IN_STEREO); #endif sp<MetaData> meta = new MetaData; diff --git a/include/media/AudioParameter.h b/include/media/AudioParameter.h index dc0bd2e..79d5d82 100644 --- a/include/media/AudioParameter.h +++ b/include/media/AudioParameter.h @@ -33,12 +33,12 @@ public: // reserved parameter keys for changing standard parameters with setParameters() function. // Using these keys is mandatory for AudioFlinger to properly monitor audio output/input // configuration changes and act accordingly. - // keyRouting: to change audio routing, value is an int in AudioSystem::audio_devices + // keyRouting: to change audio routing, value is an int in audio_devices_t // keySamplingRate: to change sampling rate routing, value is an int - // keyFormat: to change audio format, value is an int in AudioSystem::audio_format - // keyChannels: to change audio channel configuration, value is an int in AudioSystem::audio_channels + // keyFormat: to change audio format, value is an int in audio_format_t + // keyChannels: to change audio channel configuration, value is an int in audio_channels_t // keyFrameCount: to change audio output frame count, value is an int - // keyInputSource: to change audio input source, value is an int in audio_source + // keyInputSource: to change audio input source, value is an int in audio_source_t // (defined in media/mediarecorder.h) static const char *keyRouting; static const char *keySamplingRate; diff --git a/include/media/AudioRecord.h b/include/media/AudioRecord.h index 293764d..def3612 100644 --- a/include/media/AudioRecord.h +++ b/include/media/AudioRecord.h @@ -30,6 +30,7 @@ #include <binder/IMemory.h> #include <utils/threads.h> +#include <hardware/audio.h> namespace android { @@ -127,9 +128,9 @@ public: * * inputSource: Select the audio input to record to (e.g. AUDIO_SOURCE_DEFAULT). * sampleRate: Track sampling rate in Hz. - * format: Audio format (e.g AudioSystem::PCM_16_BIT for signed + * format: Audio format (e.g AUDIO_FORMAT_PCM_16_BIT for signed * 16 bits per sample). - * channels: Channel mask: see AudioSystem::audio_channels. + * channels: Channel mask: see audio_channels_t. * frameCount: Total size of track PCM buffer in frames. This defines the * latency of the track. * flags: A bitmask of acoustic values from enum record_flags. It enables @@ -142,15 +143,15 @@ public: */ enum record_flags { - RECORD_AGC_ENABLE = AudioSystem::AGC_ENABLE, - RECORD_NS_ENABLE = AudioSystem::NS_ENABLE, - RECORD_IIR_ENABLE = AudioSystem::TX_IIR_ENABLE + RECORD_AGC_ENABLE = AUDIO_IN_ACOUSTICS_AGC_ENABLE, + RECORD_NS_ENABLE = AUDIO_IN_ACOUSTICS_NS_ENABLE, + RECORD_IIR_ENABLE = AUDIO_IN_ACOUSTICS_TX_IIR_ENABLE, }; AudioRecord(int inputSource, uint32_t sampleRate = 0, int format = 0, - uint32_t channels = AudioSystem::CHANNEL_IN_MONO, + uint32_t channels = AUDIO_CHANNEL_IN_MONO, int frameCount = 0, uint32_t flags = 0, callback_t cbf = 0, @@ -176,7 +177,7 @@ public: status_t set(int inputSource = 0, uint32_t sampleRate = 0, int format = 0, - uint32_t channels = AudioSystem::CHANNEL_IN_MONO, + uint32_t channels = AUDIO_CHANNEL_IN_MONO, int frameCount = 0, uint32_t flags = 0, callback_t cbf = 0, diff --git a/include/media/AudioSystem.h b/include/media/AudioSystem.h index b0c82d8..eb61a87 100644 --- a/include/media/AudioSystem.h +++ b/include/media/AudioSystem.h @@ -21,13 +21,15 @@ #include <utils/threads.h> #include <media/IAudioFlinger.h> +#include <hardware/audio.h> +#include <hardware/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); -typedef int audio_io_handle_t; class IAudioPolicyService; class String8; @@ -36,155 +38,6 @@ class AudioSystem { public: - // must match android/media/AudioSystem.java STREAM_* constants - enum stream_type { - DEFAULT =-1, - VOICE_CALL = 0, - SYSTEM = 1, - RING = 2, - MUSIC = 3, - ALARM = 4, - NOTIFICATION = 5, - BLUETOOTH_SCO = 6, - ENFORCED_AUDIBLE = 7, // Sounds that cannot be muted by user and must be routed to speaker - DTMF = 8, - TTS = 9, - NUM_STREAM_TYPES - }; - - // Audio sub formats (see AudioSystem::audio_format). - enum pcm_sub_format { - PCM_SUB_16_BIT = 0x1, // must be 1 for backward compatibility - PCM_SUB_8_BIT = 0x2, // must be 2 for backward compatibility - }; - - // FIXME These sub_format enums are currently unused - - // MP3 sub format field definition : can use 11 LSBs in the same way as MP3 frame header to specify - // bit rate, stereo mode, version... - enum mp3_sub_format { - //TODO - }; - - // AMR NB/WB sub format field definition: specify frame block interleaving, bandwidth efficient or octet aligned, - // encoding mode for recording... - enum amr_sub_format { - //TODO - }; - - // AAC sub format field definition: specify profile or bitrate for recording... - enum aac_sub_format { - //TODO - }; - - // VORBIS sub format field definition: specify quality for recording... - enum vorbis_sub_format { - //TODO - }; - - // Audio format consists in a main format field (upper 8 bits) and a sub format field (lower 24 bits). - // The main format indicates the main codec type. The sub format field indicates options and parameters - // for each format. The sub format is mainly used for record to indicate for instance the requested bitrate - // or profile. It can also be used for certain formats to give informations not present in the encoded - // audio stream (e.g. octet alignement for AMR). - enum audio_format { - INVALID_FORMAT = -1, - FORMAT_DEFAULT = 0, - PCM = 0x00000000, // must be 0 for backward compatibility - MP3 = 0x01000000, - AMR_NB = 0x02000000, - AMR_WB = 0x03000000, - AAC = 0x04000000, - HE_AAC_V1 = 0x05000000, - HE_AAC_V2 = 0x06000000, - VORBIS = 0x07000000, - MAIN_FORMAT_MASK = 0xFF000000, - SUB_FORMAT_MASK = 0x00FFFFFF, - // Aliases - PCM_16_BIT = (PCM|PCM_SUB_16_BIT), - PCM_8_BIT = (PCM|PCM_SUB_8_BIT) - }; - - - // Channel mask definitions must be kept in sync with values in /media/java/android/media/AudioFormat.java - enum audio_channels { - // output channels - CHANNEL_OUT_FRONT_LEFT = 0x4, - CHANNEL_OUT_FRONT_RIGHT = 0x8, - CHANNEL_OUT_FRONT_CENTER = 0x10, - CHANNEL_OUT_LOW_FREQUENCY = 0x20, - CHANNEL_OUT_BACK_LEFT = 0x40, - CHANNEL_OUT_BACK_RIGHT = 0x80, - CHANNEL_OUT_FRONT_LEFT_OF_CENTER = 0x100, - CHANNEL_OUT_FRONT_RIGHT_OF_CENTER = 0x200, - CHANNEL_OUT_BACK_CENTER = 0x400, - CHANNEL_OUT_MONO = CHANNEL_OUT_FRONT_LEFT, - CHANNEL_OUT_STEREO = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT), - CHANNEL_OUT_QUAD = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT | - CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT), - CHANNEL_OUT_SURROUND = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT | - CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_BACK_CENTER), - CHANNEL_OUT_5POINT1 = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT | - CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT), - CHANNEL_OUT_7POINT1 = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT | - CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT | - CHANNEL_OUT_FRONT_LEFT_OF_CENTER | CHANNEL_OUT_FRONT_RIGHT_OF_CENTER), - CHANNEL_OUT_ALL = (CHANNEL_OUT_FRONT_LEFT | CHANNEL_OUT_FRONT_RIGHT | - CHANNEL_OUT_FRONT_CENTER | CHANNEL_OUT_LOW_FREQUENCY | CHANNEL_OUT_BACK_LEFT | CHANNEL_OUT_BACK_RIGHT | - CHANNEL_OUT_FRONT_LEFT_OF_CENTER | CHANNEL_OUT_FRONT_RIGHT_OF_CENTER | CHANNEL_OUT_BACK_CENTER), - - // input channels - CHANNEL_IN_LEFT = 0x4, - CHANNEL_IN_RIGHT = 0x8, - CHANNEL_IN_FRONT = 0x10, - CHANNEL_IN_BACK = 0x20, - CHANNEL_IN_LEFT_PROCESSED = 0x40, - CHANNEL_IN_RIGHT_PROCESSED = 0x80, - CHANNEL_IN_FRONT_PROCESSED = 0x100, - CHANNEL_IN_BACK_PROCESSED = 0x200, - CHANNEL_IN_PRESSURE = 0x400, - CHANNEL_IN_X_AXIS = 0x800, - CHANNEL_IN_Y_AXIS = 0x1000, - CHANNEL_IN_Z_AXIS = 0x2000, - CHANNEL_IN_VOICE_UPLINK = 0x4000, - CHANNEL_IN_VOICE_DNLINK = 0x8000, - CHANNEL_IN_MONO = CHANNEL_IN_FRONT, - CHANNEL_IN_STEREO = (CHANNEL_IN_LEFT | CHANNEL_IN_RIGHT), - CHANNEL_IN_ALL = (CHANNEL_IN_LEFT | CHANNEL_IN_RIGHT | CHANNEL_IN_FRONT | CHANNEL_IN_BACK| - CHANNEL_IN_LEFT_PROCESSED | CHANNEL_IN_RIGHT_PROCESSED | CHANNEL_IN_FRONT_PROCESSED | CHANNEL_IN_BACK_PROCESSED| - CHANNEL_IN_PRESSURE | CHANNEL_IN_X_AXIS | CHANNEL_IN_Y_AXIS | CHANNEL_IN_Z_AXIS | - CHANNEL_IN_VOICE_UPLINK | CHANNEL_IN_VOICE_DNLINK) - }; - - // must match android/media/AudioSystem.java MODE_* values - enum audio_mode { - MODE_INVALID = -2, - MODE_CURRENT = -1, - MODE_NORMAL = 0, - MODE_RINGTONE, - MODE_IN_CALL, - MODE_IN_COMMUNICATION, - NUM_MODES // not a valid entry, denotes end-of-list - }; - - enum audio_in_acoustics { - AGC_ENABLE = 0x0001, - AGC_DISABLE = 0, - NS_ENABLE = 0x0002, - NS_DISABLE = 0, - TX_IIR_ENABLE = 0x0004, - TX_DISABLE = 0 - }; - - // special audio session values - enum audio_sessions { - SESSION_OUTPUT_STAGE = -1, // session for effects attached to a particular output stream - // (value must be less than 0) - SESSION_OUTPUT_MIX = 0, // session for effects applied to output mix. These effects can - // be moved by audio policy manager to another output stream - // (value must be 0) - }; - /* These are static methods to control the system-wide AudioFlinger * only privileged processes can have access to them */ @@ -209,7 +62,7 @@ public: static status_t setStreamMute(int stream, bool mute); static status_t getStreamMute(int stream, bool* mute); - // set audio mode in audio hardware (see AudioSystem::audio_mode) + // set audio mode in audio hardware (see audio_mode_t) static status_t setMode(int mode); // returns true in *state if tracks are active on the specified stream or has been active @@ -230,9 +83,9 @@ public: static float linearToLog(int volume); static int logToLinear(float volume); - static status_t getOutputSamplingRate(int* samplingRate, int stream = DEFAULT); - static status_t getOutputFrameCount(int* frameCount, int stream = DEFAULT); - static status_t getOutputLatency(uint32_t* latency, int stream = DEFAULT); + static status_t getOutputSamplingRate(int* samplingRate, int stream = AUDIO_STREAM_DEFAULT); + static status_t getOutputFrameCount(int* frameCount, int stream = AUDIO_STREAM_DEFAULT); + static status_t getOutputLatency(uint32_t* latency, int stream = AUDIO_STREAM_DEFAULT); static bool routedToA2dpOutput(int streamType); @@ -250,93 +103,11 @@ public: // - 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, int stream = DEFAULT); + static status_t getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, int stream = AUDIO_STREAM_DEFAULT); static unsigned int getInputFramesLost(audio_io_handle_t ioHandle); static int newAudioSessionId(); - // - // AudioPolicyService interface - // - - enum audio_devices { - // output devices - DEVICE_OUT_EARPIECE = 0x1, - DEVICE_OUT_SPEAKER = 0x2, - DEVICE_OUT_WIRED_HEADSET = 0x4, - DEVICE_OUT_WIRED_HEADPHONE = 0x8, - DEVICE_OUT_BLUETOOTH_SCO = 0x10, - DEVICE_OUT_BLUETOOTH_SCO_HEADSET = 0x20, - DEVICE_OUT_BLUETOOTH_SCO_CARKIT = 0x40, - DEVICE_OUT_BLUETOOTH_A2DP = 0x80, - DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100, - DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200, - DEVICE_OUT_AUX_DIGITAL = 0x400, - DEVICE_OUT_ANLG_DOCK_HEADSET = 0x800, - DEVICE_OUT_DGTL_DOCK_HEADSET = 0x1000, - DEVICE_OUT_DEFAULT = 0x8000, - DEVICE_OUT_ALL = (DEVICE_OUT_EARPIECE | DEVICE_OUT_SPEAKER | DEVICE_OUT_WIRED_HEADSET | - DEVICE_OUT_WIRED_HEADPHONE | DEVICE_OUT_BLUETOOTH_SCO | DEVICE_OUT_BLUETOOTH_SCO_HEADSET | - DEVICE_OUT_BLUETOOTH_SCO_CARKIT | DEVICE_OUT_BLUETOOTH_A2DP | DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES | - DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER | DEVICE_OUT_AUX_DIGITAL | - DEVICE_OUT_ANLG_DOCK_HEADSET | DEVICE_OUT_DGTL_DOCK_HEADSET | - DEVICE_OUT_DEFAULT), - DEVICE_OUT_ALL_A2DP = (DEVICE_OUT_BLUETOOTH_A2DP | DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES | - DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER), - - // input devices - DEVICE_IN_COMMUNICATION = 0x10000, - DEVICE_IN_AMBIENT = 0x20000, - DEVICE_IN_BUILTIN_MIC = 0x40000, - DEVICE_IN_BLUETOOTH_SCO_HEADSET = 0x80000, - DEVICE_IN_WIRED_HEADSET = 0x100000, - DEVICE_IN_AUX_DIGITAL = 0x200000, - DEVICE_IN_VOICE_CALL = 0x400000, - DEVICE_IN_BACK_MIC = 0x800000, - DEVICE_IN_DEFAULT = 0x80000000, - - DEVICE_IN_ALL = (DEVICE_IN_COMMUNICATION | DEVICE_IN_AMBIENT | DEVICE_IN_BUILTIN_MIC | - DEVICE_IN_BLUETOOTH_SCO_HEADSET | DEVICE_IN_WIRED_HEADSET | DEVICE_IN_AUX_DIGITAL | - DEVICE_IN_VOICE_CALL | DEVICE_IN_BACK_MIC | DEVICE_IN_DEFAULT) - }; - - // device connection states used for setDeviceConnectionState() - enum device_connection_state { - DEVICE_STATE_UNAVAILABLE, - DEVICE_STATE_AVAILABLE, - NUM_DEVICE_STATES - }; - - // request to open a direct output with getOutput() (by opposition to sharing an output with other AudioTracks) - enum output_flags { - OUTPUT_FLAG_INDIRECT = 0x0, - OUTPUT_FLAG_DIRECT = 0x1 - }; - - // device categories used for setForceUse() - enum forced_config { - FORCE_NONE, - FORCE_SPEAKER, - FORCE_HEADPHONES, - FORCE_BT_SCO, - FORCE_BT_A2DP, - FORCE_WIRED_ACCESSORY, - FORCE_BT_CAR_DOCK, - FORCE_BT_DESK_DOCK, - FORCE_ANALOG_DOCK, - FORCE_DIGITAL_DOCK, - NUM_FORCE_CONFIG, - FORCE_DEFAULT = FORCE_NONE - }; - - // usages used for setForceUse(), must match AudioSystem.java - enum force_use { - FOR_COMMUNICATION, - FOR_MEDIA, - FOR_RECORD, - FOR_DOCK, - NUM_FORCE_USE - }; // types of io configuration change events received with ioConfigChanged() enum io_config_event { @@ -367,40 +138,40 @@ public: // // IAudioPolicyService interface (see AudioPolicyInterface for method descriptions) // - static status_t setDeviceConnectionState(audio_devices device, device_connection_state state, const char *device_address); - static device_connection_state getDeviceConnectionState(audio_devices device, const char *device_address); + 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(int state); static status_t setRingerMode(uint32_t mode, uint32_t mask); - static status_t setForceUse(force_use usage, forced_config config); - static forced_config getForceUse(force_use usage); - static audio_io_handle_t getOutput(stream_type stream, + 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, - uint32_t format = FORMAT_DEFAULT, - uint32_t channels = CHANNEL_OUT_STEREO, - output_flags flags = OUTPUT_FLAG_INDIRECT); + uint32_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, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session = 0); static status_t stopOutput(audio_io_handle_t output, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session = 0); static void releaseOutput(audio_io_handle_t output); static audio_io_handle_t getInput(int inputSource, uint32_t samplingRate = 0, - uint32_t format = FORMAT_DEFAULT, - uint32_t channels = CHANNEL_IN_MONO, - audio_in_acoustics acoustics = (audio_in_acoustics)0); + uint32_t format = AUDIO_FORMAT_DEFAULT, + uint32_t channels = AUDIO_CHANNEL_IN_MONO, + audio_in_acoustics_t acoustics = (audio_in_acoustics_t)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(stream_type stream, + static status_t initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax); - static status_t setStreamVolumeIndex(stream_type stream, int index); - static status_t getStreamVolumeIndex(stream_type stream, int *index); + static status_t setStreamVolumeIndex(audio_stream_type_t stream, int index); + static status_t getStreamVolumeIndex(audio_stream_type_t stream, int *index); - static uint32_t getStrategyForStream(stream_type stream); - static uint32_t getDevicesForStream(stream_type stream); + 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, @@ -414,17 +185,6 @@ public: // ---------------------------------------------------------------------------- - static uint32_t popCount(uint32_t u); - static bool isOutputDevice(audio_devices device); - static bool isInputDevice(audio_devices device); - static bool isA2dpDevice(audio_devices device); - static bool isBluetoothScoDevice(audio_devices device); - static bool isLowVisibility(stream_type stream); - static bool isOutputChannel(uint32_t channel); - static bool isInputChannel(uint32_t channel); - static bool isValidFormat(uint32_t format); - static bool isLinearPCM(uint32_t format); - private: class AudioFlingerClient: public IBinder::DeathRecipient, public BnAudioFlingerClient diff --git a/include/media/AudioTrack.h b/include/media/AudioTrack.h index 3e346db..de928da 100644 --- a/include/media/AudioTrack.h +++ b/include/media/AudioTrack.h @@ -30,7 +30,6 @@ #include <binder/IMemory.h> #include <utils/threads.h> - namespace android { // ---------------------------------------------------------------------------- @@ -126,11 +125,11 @@ public: * Parameters: * * streamType: Select the type of audio stream this track is attached to - * (e.g. AudioSystem::MUSIC). + * (e.g. AUDIO_STREAM_MUSIC). * sampleRate: Track sampling rate in Hz. - * format: Audio format (e.g AudioSystem::PCM_16_BIT for signed + * format: Audio format (e.g AUDIO_FORMAT_PCM_16_BIT for signed * 16 bits per sample). - * channels: Channel mask: see AudioSystem::audio_channels. + * channels: Channel mask: see audio_channels_t. * frameCount: Total size of track PCM buffer in frames. This defines the * latency of the track. * flags: Reserved for future use. diff --git a/include/media/EffectApi.h b/include/media/EffectApi.h index b97c22e..a5ad846 100644 --- a/include/media/EffectApi.h +++ b/include/media/EffectApi.h @@ -602,9 +602,9 @@ enum audio_device_e { // Audio mode enum audio_mode_e { - AUDIO_MODE_NORMAL, // device idle - AUDIO_MODE_RINGTONE, // device ringing - AUDIO_MODE_IN_CALL // audio call connected (VoIP or telephony) + AUDIO_EFFECT_MODE_NORMAL, // device idle + AUDIO_EFFECT_MODE_RINGTONE, // device ringing + AUDIO_EFFECT_MODE_IN_CALL, // audio call connected (VoIP or telephony) }; // Values for "accessMode" field of buffer_config_t: diff --git a/include/media/IAudioPolicyService.h b/include/media/IAudioPolicyService.h index 720a562..09b2bfe 100644 --- a/include/media/IAudioPolicyService.h +++ b/include/media/IAudioPolicyService.h @@ -26,6 +26,7 @@ #include <binder/IInterface.h> #include <media/AudioSystem.h> +#include <hardware/audio_policy.h> namespace android { @@ -39,42 +40,42 @@ public: // // IAudioPolicyService interface (see AudioPolicyInterface for method descriptions) // - virtual status_t setDeviceConnectionState(AudioSystem::audio_devices device, - AudioSystem::device_connection_state state, + virtual status_t setDeviceConnectionState(audio_devices_t device, + audio_policy_dev_state_t state, const char *device_address) = 0; - virtual AudioSystem::device_connection_state getDeviceConnectionState(AudioSystem::audio_devices device, + virtual audio_policy_dev_state_t getDeviceConnectionState(audio_devices_t device, const char *device_address) = 0; virtual status_t setPhoneState(int state) = 0; virtual status_t setRingerMode(uint32_t mode, uint32_t mask) = 0; - virtual status_t setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config) = 0; - virtual AudioSystem::forced_config getForceUse(AudioSystem::force_use usage) = 0; - virtual audio_io_handle_t getOutput(AudioSystem::stream_type stream, + virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) = 0; + virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) = 0; + virtual audio_io_handle_t getOutput(audio_stream_type_t stream, uint32_t samplingRate = 0, - uint32_t format = AudioSystem::FORMAT_DEFAULT, + uint32_t format = AUDIO_FORMAT_DEFAULT, uint32_t channels = 0, - AudioSystem::output_flags flags = AudioSystem::OUTPUT_FLAG_INDIRECT) = 0; + audio_policy_output_flags_t flags = AUDIO_POLICY_OUTPUT_FLAG_INDIRECT) = 0; virtual status_t startOutput(audio_io_handle_t output, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session = 0) = 0; virtual status_t stopOutput(audio_io_handle_t output, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session = 0) = 0; virtual void releaseOutput(audio_io_handle_t output) = 0; virtual audio_io_handle_t getInput(int inputSource, uint32_t samplingRate = 0, - uint32_t format = AudioSystem::FORMAT_DEFAULT, + uint32_t format = AUDIO_FORMAT_DEFAULT, uint32_t channels = 0, - AudioSystem::audio_in_acoustics acoustics = (AudioSystem::audio_in_acoustics)0) = 0; + audio_in_acoustics_t acoustics = (audio_in_acoustics_t)0) = 0; virtual status_t startInput(audio_io_handle_t input) = 0; virtual status_t stopInput(audio_io_handle_t input) = 0; virtual void releaseInput(audio_io_handle_t input) = 0; - virtual status_t initStreamVolume(AudioSystem::stream_type stream, + virtual status_t initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax) = 0; - virtual status_t setStreamVolumeIndex(AudioSystem::stream_type stream, int index) = 0; - virtual status_t getStreamVolumeIndex(AudioSystem::stream_type stream, int *index) = 0; - virtual uint32_t getStrategyForStream(AudioSystem::stream_type stream) = 0; - virtual uint32_t getDevicesForStream(AudioSystem::stream_type stream) = 0; + virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, int index) = 0; + virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, int *index) = 0; + virtual uint32_t getStrategyForStream(audio_stream_type_t stream) = 0; + virtual uint32_t getDevicesForStream(audio_stream_type_t stream) = 0; virtual audio_io_handle_t getOutputForEffect(effect_descriptor_t *desc) = 0; virtual status_t registerEffect(effect_descriptor_t *desc, audio_io_handle_t output, diff --git a/include/media/MediaPlayerInterface.h b/include/media/MediaPlayerInterface.h index e1b6dd6..bebecc0 100644 --- a/include/media/MediaPlayerInterface.h +++ b/include/media/MediaPlayerInterface.h @@ -85,7 +85,7 @@ public: // audio data. virtual status_t open( uint32_t sampleRate, int channelCount, - int format=AudioSystem::PCM_16_BIT, + int format=AUDIO_FORMAT_PCM_16_BIT, int bufferCount=DEFAULT_AUDIOSINK_BUFFERCOUNT, AudioCallback cb = NULL, void *cookie = NULL) = 0; diff --git a/include/media/MediaRecorderBase.h b/include/media/MediaRecorderBase.h index c42346e..5fe7722 100644 --- a/include/media/MediaRecorderBase.h +++ b/include/media/MediaRecorderBase.h @@ -20,6 +20,8 @@ #include <media/mediarecorder.h> +#include <hardware/audio.h> + namespace android { class Surface; @@ -29,7 +31,7 @@ struct MediaRecorderBase { virtual ~MediaRecorderBase() {} virtual status_t init() = 0; - virtual status_t setAudioSource(audio_source as) = 0; + virtual status_t setAudioSource(audio_source_t as) = 0; virtual status_t setVideoSource(video_source vs) = 0; virtual status_t setOutputFormat(output_format of) = 0; virtual status_t setAudioEncoder(audio_encoder ae) = 0; diff --git a/include/media/mediarecorder.h b/include/media/mediarecorder.h index 67d940b..18a3c6a 100644 --- a/include/media/mediarecorder.h +++ b/include/media/mediarecorder.h @@ -33,23 +33,6 @@ class ICamera; typedef void (*media_completion_f)(status_t status, void *cookie); -/* Do not change these values without updating their counterparts - * in media/java/android/media/MediaRecorder.java! - */ -enum audio_source { - AUDIO_SOURCE_DEFAULT = 0, - AUDIO_SOURCE_MIC = 1, - AUDIO_SOURCE_VOICE_UPLINK = 2, - AUDIO_SOURCE_VOICE_DOWNLINK = 3, - AUDIO_SOURCE_VOICE_CALL = 4, - AUDIO_SOURCE_CAMCORDER = 5, - AUDIO_SOURCE_VOICE_RECOGNITION = 6, - AUDIO_SOURCE_VOICE_COMMUNICATION = 7, - AUDIO_SOURCE_MAX = AUDIO_SOURCE_VOICE_COMMUNICATION, - - AUDIO_SOURCE_LIST_END // must be last - used to validate audio source type -}; - enum video_source { VIDEO_SOURCE_DEFAULT = 0, VIDEO_SOURCE_CAMERA = 1, diff --git a/include/media/stagefright/AudioSource.h b/include/media/stagefright/AudioSource.h index 9e6f0e2..20a9e16 100644 --- a/include/media/stagefright/AudioSource.h +++ b/include/media/stagefright/AudioSource.h @@ -24,16 +24,18 @@ #include <media/stagefright/MediaBuffer.h> #include <utils/List.h> +#include <hardware/audio.h> + namespace android { class AudioRecord; struct AudioSource : public MediaSource, public MediaBufferObserver { // Note that the "channels" parameter is _not_ the number of channels, - // but a bitmask of AudioSystem::audio_channels constants. + // but a bitmask of audio_channels_t constants. AudioSource( int inputSource, uint32_t sampleRate, - uint32_t channels = AudioSystem::CHANNEL_IN_MONO); + uint32_t channels = AUDIO_CHANNEL_IN_MONO); status_t initCheck() const; diff --git a/media/libmedia/AudioRecord.cpp b/media/libmedia/AudioRecord.cpp index 5d74a0a..8438714 100644 --- a/media/libmedia/AudioRecord.cpp +++ b/media/libmedia/AudioRecord.cpp @@ -37,6 +37,9 @@ #include <utils/Timers.h> #include <utils/Atomic.h> +#include <hardware/audio.h> +#include <cutils/bitops.h> + #define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) #define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) @@ -66,8 +69,8 @@ status_t AudioRecord::getMinFrameCount( // We double the size of input buffer for ping pong use of record buffer. size <<= 1; - if (AudioSystem::isLinearPCM(format)) { - size /= channelCount * (format == AudioSystem::PCM_16_BIT ? 2 : 1); + if (audio_is_linear_pcm(format)) { + size /= channelCount * (format == AUDIO_FORMAT_PCM_16_BIT ? 2 : 1); } *frameCount = size; @@ -145,22 +148,22 @@ status_t AudioRecord::set( } // these below should probably come from the audioFlinger too... if (format == 0) { - format = AudioSystem::PCM_16_BIT; + format = AUDIO_FORMAT_PCM_16_BIT; } // validate parameters - if (!AudioSystem::isValidFormat(format)) { + if (!audio_is_valid_format(format)) { LOGE("Invalid format"); return BAD_VALUE; } - if (!AudioSystem::isInputChannel(channels)) { + if (!audio_is_input_channel(channels)) { return BAD_VALUE; } - int channelCount = AudioSystem::popCount(channels); + int channelCount = popcount(channels); audio_io_handle_t input = AudioSystem::getInput(inputSource, - sampleRate, format, channels, (AudioSystem::audio_in_acoustics)flags); + sampleRate, format, channels, (audio_in_acoustics_t)flags); if (input == 0) { LOGE("Could not get audio input for record source %d", inputSource); return BAD_VALUE; @@ -254,8 +257,8 @@ uint32_t AudioRecord::frameCount() const int AudioRecord::frameSize() const { - if (AudioSystem::isLinearPCM(mFormat)) { - return channelCount()*((format() == AudioSystem::PCM_8_BIT) ? sizeof(uint8_t) : sizeof(int16_t)); + if (audio_is_linear_pcm(mFormat)) { + return channelCount()*((format() == AUDIO_FORMAT_PCM_8_BIT) ? sizeof(uint8_t) : sizeof(int16_t)); } else { return sizeof(uint8_t); } @@ -587,7 +590,7 @@ audio_io_handle_t AudioRecord::getInput_l() mInput = AudioSystem::getInput(mInputSource, mCblk->sampleRate, mFormat, mChannels, - (AudioSystem::audio_in_acoustics)mFlags); + (audio_in_acoustics_t)mFlags); return mInput; } diff --git a/media/libmedia/AudioSystem.cpp b/media/libmedia/AudioSystem.cpp index 5c6f344..e08a55b 100644 --- a/media/libmedia/AudioSystem.cpp +++ b/media/libmedia/AudioSystem.cpp @@ -23,6 +23,8 @@ #include <media/IAudioPolicyService.h> #include <math.h> +#include <hardware/audio.h> + // ---------------------------------------------------------------------------- // the sim build doesn't have gettid @@ -45,7 +47,7 @@ DefaultKeyedVector<audio_io_handle_t, AudioSystem::OutputDescriptor *> AudioSyst // Cached values for recording queries uint32_t AudioSystem::gPrevInSamplingRate = 16000; -int AudioSystem::gPrevInFormat = AudioSystem::PCM_16_BIT; +int AudioSystem::gPrevInFormat = AUDIO_FORMAT_PCM_16_BIT; int AudioSystem::gPrevInChannelCount = 1; size_t AudioSystem::gInBuffSize = 0; @@ -127,7 +129,7 @@ status_t AudioSystem::getMasterMute(bool* mute) status_t AudioSystem::setStreamVolume(int stream, float value, int output) { - if (uint32_t(stream) >= NUM_STREAM_TYPES) return BAD_VALUE; + if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE; const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); if (af == 0) return PERMISSION_DENIED; af->setStreamVolume(stream, value, output); @@ -136,7 +138,7 @@ status_t AudioSystem::setStreamVolume(int stream, float value, int output) status_t AudioSystem::setStreamMute(int stream, bool mute) { - if (uint32_t(stream) >= NUM_STREAM_TYPES) return BAD_VALUE; + if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE; const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); if (af == 0) return PERMISSION_DENIED; af->setStreamMute(stream, mute); @@ -145,7 +147,7 @@ status_t AudioSystem::setStreamMute(int stream, bool mute) status_t AudioSystem::getStreamVolume(int stream, float* volume, int output) { - if (uint32_t(stream) >= NUM_STREAM_TYPES) return BAD_VALUE; + if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE; const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); if (af == 0) return PERMISSION_DENIED; *volume = af->streamVolume(stream, output); @@ -154,7 +156,7 @@ status_t AudioSystem::getStreamVolume(int stream, float* volume, int output) status_t AudioSystem::getStreamMute(int stream, bool* mute) { - if (uint32_t(stream) >= NUM_STREAM_TYPES) return BAD_VALUE; + if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE; const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); if (af == 0) return PERMISSION_DENIED; *mute = af->streamMute(stream); @@ -163,7 +165,7 @@ status_t AudioSystem::getStreamMute(int stream, bool* mute) status_t AudioSystem::setMode(int mode) { - if (mode >= NUM_MODES) return BAD_VALUE; + if (mode >= AUDIO_MODE_CNT) return BAD_VALUE; const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); if (af == 0) return PERMISSION_DENIED; return af->setMode(mode); @@ -213,11 +215,11 @@ status_t AudioSystem::getOutputSamplingRate(int* samplingRate, int streamType) OutputDescriptor *outputDesc; audio_io_handle_t output; - if (streamType == DEFAULT) { - streamType = MUSIC; + if (streamType == AUDIO_STREAM_DEFAULT) { + streamType = AUDIO_STREAM_MUSIC; } - output = getOutput((stream_type)streamType); + output = getOutput((audio_stream_type_t)streamType); if (output == 0) { return PERMISSION_DENIED; } @@ -246,11 +248,11 @@ status_t AudioSystem::getOutputFrameCount(int* frameCount, int streamType) OutputDescriptor *outputDesc; audio_io_handle_t output; - if (streamType == DEFAULT) { - streamType = MUSIC; + if (streamType == AUDIO_STREAM_DEFAULT) { + streamType = AUDIO_STREAM_MUSIC; } - output = getOutput((stream_type)streamType); + output = getOutput((audio_stream_type_t)streamType); if (output == 0) { return PERMISSION_DENIED; } @@ -277,11 +279,11 @@ status_t AudioSystem::getOutputLatency(uint32_t* latency, int streamType) OutputDescriptor *outputDesc; audio_io_handle_t output; - if (streamType == DEFAULT) { - streamType = MUSIC; + if (streamType == AUDIO_STREAM_DEFAULT) { + streamType = AUDIO_STREAM_MUSIC; } - output = getOutput((stream_type)streamType); + output = getOutput((audio_stream_type_t)streamType); if (output == 0) { return PERMISSION_DENIED; } @@ -338,11 +340,11 @@ status_t AudioSystem::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames const sp<IAudioFlinger>& af = AudioSystem::get_audio_flinger(); if (af == 0) return PERMISSION_DENIED; - if (stream == DEFAULT) { - stream = MUSIC; + if (stream == AUDIO_STREAM_DEFAULT) { + stream = AUDIO_STREAM_MUSIC; } - return af->getRenderPosition(halFrames, dspFrames, getOutput((stream_type)stream)); + return af->getRenderPosition(halFrames, dspFrames, getOutput((audio_stream_type_t)stream)); } unsigned int AudioSystem::getInputFramesLost(audio_io_handle_t ioHandle) { @@ -455,10 +457,10 @@ void AudioSystem::setErrorCallback(audio_error_callback cb) { bool AudioSystem::routedToA2dpOutput(int streamType) { switch(streamType) { - case MUSIC: - case VOICE_CALL: - case BLUETOOTH_SCO: - case SYSTEM: + case AUDIO_STREAM_MUSIC: + case AUDIO_STREAM_VOICE_CALL: + case AUDIO_STREAM_BLUETOOTH_SCO: + case AUDIO_STREAM_SYSTEM: return true; default: return false; @@ -497,9 +499,9 @@ const sp<IAudioPolicyService>& AudioSystem::get_audio_policy_service() return gAudioPolicyService; } -status_t AudioSystem::setDeviceConnectionState(audio_devices device, - device_connection_state state, - const char *device_address) +status_t AudioSystem::setDeviceConnectionState(audio_devices_t device, + audio_policy_dev_state_t state, + const char *device_address) { const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); if (aps == 0) return PERMISSION_DENIED; @@ -507,11 +509,11 @@ status_t AudioSystem::setDeviceConnectionState(audio_devices device, return aps->setDeviceConnectionState(device, state, device_address); } -AudioSystem::device_connection_state AudioSystem::getDeviceConnectionState(audio_devices device, +audio_policy_dev_state_t AudioSystem::getDeviceConnectionState(audio_devices_t device, const char *device_address) { const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); - if (aps == 0) return DEVICE_STATE_UNAVAILABLE; + if (aps == 0) return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE; return aps->getDeviceConnectionState(device, device_address); } @@ -531,26 +533,26 @@ status_t AudioSystem::setRingerMode(uint32_t mode, uint32_t mask) return aps->setRingerMode(mode, mask); } -status_t AudioSystem::setForceUse(force_use usage, forced_config config) +status_t AudioSystem::setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) { const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); if (aps == 0) return PERMISSION_DENIED; return aps->setForceUse(usage, config); } -AudioSystem::forced_config AudioSystem::getForceUse(force_use usage) +audio_policy_forced_cfg_t AudioSystem::getForceUse(audio_policy_force_use_t usage) { const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); - if (aps == 0) return FORCE_NONE; + if (aps == 0) return AUDIO_POLICY_FORCE_NONE; return aps->getForceUse(usage); } -audio_io_handle_t AudioSystem::getOutput(stream_type stream, +audio_io_handle_t AudioSystem::getOutput(audio_stream_type_t stream, uint32_t samplingRate, uint32_t format, uint32_t channels, - output_flags flags) + audio_policy_output_flags_t flags) { audio_io_handle_t output = 0; // Do not use stream to output map cache if the direct output @@ -561,9 +563,9 @@ audio_io_handle_t AudioSystem::getOutput(stream_type stream, // be reworked for proper operation with direct outputs. This code is too specific // to the first use case we want to cover (Voice Recognition and Voice Dialer over // Bluetooth SCO - if ((flags & AudioSystem::OUTPUT_FLAG_DIRECT) == 0 && - ((stream != AudioSystem::VOICE_CALL && stream != AudioSystem::BLUETOOTH_SCO) || - channels != AudioSystem::CHANNEL_OUT_MONO || + if ((flags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT) == 0 && + ((stream != AUDIO_STREAM_VOICE_CALL && stream != AUDIO_STREAM_BLUETOOTH_SCO) || + channels != AUDIO_CHANNEL_OUT_MONO || (samplingRate != 8000 && samplingRate != 16000))) { Mutex::Autolock _l(gLock); output = AudioSystem::gStreamOutputMap.valueFor(stream); @@ -573,7 +575,7 @@ audio_io_handle_t AudioSystem::getOutput(stream_type stream, const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); if (aps == 0) return 0; output = aps->getOutput(stream, samplingRate, format, channels, flags); - if ((flags & AudioSystem::OUTPUT_FLAG_DIRECT) == 0) { + if ((flags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT) == 0) { Mutex::Autolock _l(gLock); AudioSystem::gStreamOutputMap.add(stream, output); } @@ -582,7 +584,7 @@ audio_io_handle_t AudioSystem::getOutput(stream_type stream, } status_t AudioSystem::startOutput(audio_io_handle_t output, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session) { const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); @@ -591,7 +593,7 @@ status_t AudioSystem::startOutput(audio_io_handle_t output, } status_t AudioSystem::stopOutput(audio_io_handle_t output, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session) { const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); @@ -610,7 +612,7 @@ audio_io_handle_t AudioSystem::getInput(int inputSource, uint32_t samplingRate, uint32_t format, uint32_t channels, - audio_in_acoustics acoustics) + audio_in_acoustics_t acoustics) { const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); if (aps == 0) return 0; @@ -638,7 +640,7 @@ void AudioSystem::releaseInput(audio_io_handle_t input) aps->releaseInput(input); } -status_t AudioSystem::initStreamVolume(stream_type stream, +status_t AudioSystem::initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax) { @@ -647,28 +649,28 @@ status_t AudioSystem::initStreamVolume(stream_type stream, return aps->initStreamVolume(stream, indexMin, indexMax); } -status_t AudioSystem::setStreamVolumeIndex(stream_type stream, int index) +status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream, int index) { const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); if (aps == 0) return PERMISSION_DENIED; return aps->setStreamVolumeIndex(stream, index); } -status_t AudioSystem::getStreamVolumeIndex(stream_type stream, int *index) +status_t AudioSystem::getStreamVolumeIndex(audio_stream_type_t stream, int *index) { const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); if (aps == 0) return PERMISSION_DENIED; return aps->getStreamVolumeIndex(stream, index); } -uint32_t AudioSystem::getStrategyForStream(AudioSystem::stream_type stream) +uint32_t AudioSystem::getStrategyForStream(audio_stream_type_t stream) { const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); if (aps == 0) return 0; return aps->getStrategyForStream(stream); } -uint32_t AudioSystem::getDevicesForStream(AudioSystem::stream_type stream) +uint32_t AudioSystem::getDevicesForStream(audio_stream_type_t stream) { const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service(); if (aps == 0) return 0; @@ -717,122 +719,5 @@ void AudioSystem::AudioPolicyServiceClient::binderDied(const wp<IBinder>& who) { LOGW("AudioPolicyService server died!"); } -// --------------------------------------------------------------------------- - - -// use emulated popcount optimization -// http://www.df.lth.se/~john_e/gems/gem002d.html -uint32_t AudioSystem::popCount(uint32_t u) -{ - u = ((u&0x55555555) + ((u>>1)&0x55555555)); - u = ((u&0x33333333) + ((u>>2)&0x33333333)); - u = ((u&0x0f0f0f0f) + ((u>>4)&0x0f0f0f0f)); - u = ((u&0x00ff00ff) + ((u>>8)&0x00ff00ff)); - u = ( u&0x0000ffff) + (u>>16); - return u; -} - -bool AudioSystem::isOutputDevice(audio_devices device) -{ - if ((popCount(device) == 1 ) && - ((device & ~AudioSystem::DEVICE_OUT_ALL) == 0)) { - return true; - } else { - return false; - } -} - -bool AudioSystem::isInputDevice(audio_devices device) -{ - if ((popCount(device) == 1 ) && - ((device & ~AudioSystem::DEVICE_IN_ALL) == 0)) { - return true; - } else { - return false; - } -} - -bool AudioSystem::isA2dpDevice(audio_devices device) -{ - if ((popCount(device) == 1 ) && - (device & (AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP | - AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES | - AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER))) { - return true; - } else { - return false; - } -} - -bool AudioSystem::isBluetoothScoDevice(audio_devices device) -{ - if ((popCount(device) == 1 ) && - (device & (AudioSystem::DEVICE_OUT_BLUETOOTH_SCO | - AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET | - AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT | - AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET))) { - return true; - } else { - return false; - } -} - -bool AudioSystem::isLowVisibility(stream_type stream) -{ - if (stream == AudioSystem::SYSTEM || - stream == AudioSystem::NOTIFICATION || - stream == AudioSystem::RING) { - return true; - } else { - return false; - } -} - -bool AudioSystem::isInputChannel(uint32_t channel) -{ - if ((channel & ~AudioSystem::CHANNEL_IN_ALL) == 0) { - return true; - } else { - return false; - } -} - -bool AudioSystem::isOutputChannel(uint32_t channel) -{ - if ((channel & ~AudioSystem::CHANNEL_OUT_ALL) == 0) { - return true; - } else { - return false; - } -} - -bool AudioSystem::isValidFormat(uint32_t format) -{ - switch (format & MAIN_FORMAT_MASK) { - case PCM: - case MP3: - case AMR_NB: - case AMR_WB: - case AAC: - case HE_AAC_V1: - case HE_AAC_V2: - case VORBIS: - return true; - default: - return false; - } -} - -bool AudioSystem::isLinearPCM(uint32_t format) -{ - switch (format) { - case PCM_16_BIT: - case PCM_8_BIT: - return true; - default: - return false; - } -} - }; // namespace android diff --git a/media/libmedia/AudioTrack.cpp b/media/libmedia/AudioTrack.cpp index 66e11d2..2673df9 100644 --- a/media/libmedia/AudioTrack.cpp +++ b/media/libmedia/AudioTrack.cpp @@ -37,6 +37,11 @@ #include <utils/Timers.h> #include <utils/Atomic.h> +#include <cutils/bitops.h> + +#include <hardware/audio.h> +#include <hardware/audio_policy.h> + #define LIKELY( exp ) (__builtin_expect( (exp) != 0, true )) #define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false )) @@ -165,39 +170,41 @@ status_t AudioTrack::set( } // handle default values first. - if (streamType == AudioSystem::DEFAULT) { - streamType = AudioSystem::MUSIC; + if (streamType == AUDIO_STREAM_DEFAULT) { + streamType = AUDIO_STREAM_MUSIC; } if (sampleRate == 0) { sampleRate = afSampleRate; } // these below should probably come from the audioFlinger too... if (format == 0) { - format = AudioSystem::PCM_16_BIT; + format = AUDIO_FORMAT_PCM_16_BIT; } if (channels == 0) { - channels = AudioSystem::CHANNEL_OUT_STEREO; + channels = AUDIO_CHANNEL_OUT_STEREO; } // validate parameters - if (!AudioSystem::isValidFormat(format)) { + if (!audio_is_valid_format(format)) { LOGE("Invalid format"); return BAD_VALUE; } // force direct flag if format is not linear PCM - if (!AudioSystem::isLinearPCM(format)) { - flags |= AudioSystem::OUTPUT_FLAG_DIRECT; + if (!audio_is_linear_pcm(format)) { + flags |= AUDIO_POLICY_OUTPUT_FLAG_DIRECT; } - if (!AudioSystem::isOutputChannel(channels)) { + if (!audio_is_output_channel(channels)) { LOGE("Invalid channel mask"); return BAD_VALUE; } - uint32_t channelCount = AudioSystem::popCount(channels); + uint32_t channelCount = popcount(channels); - audio_io_handle_t output = AudioSystem::getOutput((AudioSystem::stream_type)streamType, - sampleRate, format, channels, (AudioSystem::output_flags)flags); + audio_io_handle_t output = AudioSystem::getOutput( + (audio_stream_type_t)streamType, + sampleRate,format, channels, + (audio_policy_output_flags_t)flags); if (output == 0) { LOGE("Could not get audio output for stream type %d", streamType); @@ -290,8 +297,8 @@ uint32_t AudioTrack::frameCount() const int AudioTrack::frameSize() const { - if (AudioSystem::isLinearPCM(mFormat)) { - return channelCount()*((format() == AudioSystem::PCM_8_BIT) ? sizeof(uint8_t) : sizeof(int16_t)); + if (audio_is_linear_pcm(mFormat)) { + return channelCount()*((format() == AUDIO_FORMAT_PCM_8_BIT) ? sizeof(uint8_t) : sizeof(int16_t)); } else { return sizeof(uint8_t); } @@ -673,8 +680,8 @@ audio_io_handle_t AudioTrack::getOutput() // must be called with mLock held audio_io_handle_t AudioTrack::getOutput_l() { - return AudioSystem::getOutput((AudioSystem::stream_type)mStreamType, - mCblk->sampleRate, mFormat, mChannels, (AudioSystem::output_flags)mFlags); + return AudioSystem::getOutput((audio_stream_type_t)mStreamType, + mCblk->sampleRate, mFormat, mChannels, (audio_policy_output_flags_t)mFlags); } int AudioTrack::getSessionId() @@ -727,7 +734,7 @@ status_t AudioTrack::createTrack_l( } mNotificationFramesAct = mNotificationFramesReq; - if (!AudioSystem::isLinearPCM(format)) { + if (!audio_is_linear_pcm(format)) { if (sharedBuffer != 0) { frameCount = sharedBuffer->size(); } @@ -923,8 +930,8 @@ create_new_track: audioBuffer->channelCount = mChannelCount; audioBuffer->frameCount = framesReq; audioBuffer->size = framesReq * cblk->frameSize; - if (AudioSystem::isLinearPCM(mFormat)) { - audioBuffer->format = AudioSystem::PCM_16_BIT; + if (audio_is_linear_pcm(mFormat)) { + audioBuffer->format = AUDIO_FORMAT_PCM_16_BIT; } else { audioBuffer->format = mFormat; } @@ -982,7 +989,7 @@ ssize_t AudioTrack::write(const void* buffer, size_t userSize) size_t toWrite; - if (mFormat == AudioSystem::PCM_8_BIT && !(mFlags & AudioSystem::OUTPUT_FLAG_DIRECT)) { + if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT)) { // Divide capacity by 2 to take expansion into account toWrite = audioBuffer.size>>1; // 8 to 16 bit conversion @@ -1085,7 +1092,7 @@ bool AudioTrack::processAudioBuffer(const sp<AudioTrackThread>& thread) // Divide buffer size by 2 to take into account the expansion // due to 8 to 16 bit conversion: the callback must fill only half // of the destination buffer - if (mFormat == AudioSystem::PCM_8_BIT && !(mFlags & AudioSystem::OUTPUT_FLAG_DIRECT)) { + if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT)) { audioBuffer.size >>= 1; } @@ -1104,7 +1111,7 @@ bool AudioTrack::processAudioBuffer(const sp<AudioTrackThread>& thread) } if (writtenSize > reqSize) writtenSize = reqSize; - if (mFormat == AudioSystem::PCM_8_BIT && !(mFlags & AudioSystem::OUTPUT_FLAG_DIRECT)) { + if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT)) { // 8 to 16 bit conversion const int8_t *src = audioBuffer.i8 + writtenSize-1; int count = writtenSize; diff --git a/media/libmedia/IAudioPolicyService.cpp b/media/libmedia/IAudioPolicyService.cpp index b89a278..88a9ae0 100644 --- a/media/libmedia/IAudioPolicyService.cpp +++ b/media/libmedia/IAudioPolicyService.cpp @@ -25,6 +25,8 @@ #include <media/IAudioPolicyService.h> +#include <hardware/audio.h> + namespace android { enum { @@ -62,8 +64,8 @@ public: } virtual status_t setDeviceConnectionState( - AudioSystem::audio_devices device, - AudioSystem::device_connection_state state, + audio_devices_t device, + audio_policy_dev_state_t state, const char *device_address) { Parcel data, reply; @@ -75,8 +77,8 @@ public: return static_cast <status_t> (reply.readInt32()); } - virtual AudioSystem::device_connection_state getDeviceConnectionState( - AudioSystem::audio_devices device, + virtual audio_policy_dev_state_t getDeviceConnectionState( + audio_devices_t device, const char *device_address) { Parcel data, reply; @@ -84,7 +86,7 @@ public: data.writeInt32(static_cast <uint32_t>(device)); data.writeCString(device_address); remote()->transact(GET_DEVICE_CONNECTION_STATE, data, &reply); - return static_cast <AudioSystem::device_connection_state>(reply.readInt32()); + return static_cast <audio_policy_dev_state_t>(reply.readInt32()); } virtual status_t setPhoneState(int state) @@ -106,7 +108,7 @@ public: return static_cast <status_t> (reply.readInt32()); } - virtual status_t setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config) + virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config) { Parcel data, reply; data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); @@ -116,21 +118,21 @@ public: return static_cast <status_t> (reply.readInt32()); } - virtual AudioSystem::forced_config getForceUse(AudioSystem::force_use usage) + virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage) { Parcel data, reply; data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); data.writeInt32(static_cast <uint32_t>(usage)); remote()->transact(GET_FORCE_USE, data, &reply); - return static_cast <AudioSystem::forced_config> (reply.readInt32()); + return static_cast <audio_policy_forced_cfg_t> (reply.readInt32()); } virtual audio_io_handle_t getOutput( - AudioSystem::stream_type stream, + audio_stream_type_t stream, uint32_t samplingRate, uint32_t format, uint32_t channels, - AudioSystem::output_flags flags) + audio_policy_output_flags_t flags) { Parcel data, reply; data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); @@ -144,7 +146,7 @@ public: } virtual status_t startOutput(audio_io_handle_t output, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session) { Parcel data, reply; @@ -157,7 +159,7 @@ public: } virtual status_t stopOutput(audio_io_handle_t output, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session) { Parcel data, reply; @@ -182,7 +184,7 @@ public: uint32_t samplingRate, uint32_t format, uint32_t channels, - AudioSystem::audio_in_acoustics acoustics) + audio_in_acoustics_t acoustics) { Parcel data, reply; data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); @@ -221,7 +223,7 @@ public: remote()->transact(RELEASE_INPUT, data, &reply); } - virtual status_t initStreamVolume(AudioSystem::stream_type stream, + virtual status_t initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax) { @@ -234,7 +236,7 @@ public: return static_cast <status_t> (reply.readInt32()); } - virtual status_t setStreamVolumeIndex(AudioSystem::stream_type stream, int index) + virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, int index) { Parcel data, reply; data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); @@ -244,7 +246,7 @@ public: return static_cast <status_t> (reply.readInt32()); } - virtual status_t getStreamVolumeIndex(AudioSystem::stream_type stream, int *index) + virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, int *index) { Parcel data, reply; data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); @@ -255,7 +257,7 @@ public: return static_cast <status_t> (reply.readInt32()); } - virtual uint32_t getStrategyForStream(AudioSystem::stream_type stream) + virtual uint32_t getStrategyForStream(audio_stream_type_t stream) { Parcel data, reply; data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); @@ -264,7 +266,7 @@ public: return reply.readInt32(); } - virtual uint32_t getDevicesForStream(AudioSystem::stream_type stream) + virtual uint32_t getDevicesForStream(audio_stream_type_t stream) { Parcel data, reply; data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor()); @@ -330,10 +332,10 @@ status_t BnAudioPolicyService::onTransact( switch(code) { case SET_DEVICE_CONNECTION_STATE: { CHECK_INTERFACE(IAudioPolicyService, data, reply); - AudioSystem::audio_devices device = - static_cast <AudioSystem::audio_devices>(data.readInt32()); - AudioSystem::device_connection_state state = - static_cast <AudioSystem::device_connection_state>(data.readInt32()); + audio_devices_t device = + static_cast <audio_devices_t>(data.readInt32()); + audio_policy_dev_state_t state = + static_cast <audio_policy_dev_state_t>(data.readInt32()); const char *device_address = data.readCString(); reply->writeInt32(static_cast<uint32_t> (setDeviceConnectionState(device, state, @@ -343,8 +345,8 @@ status_t BnAudioPolicyService::onTransact( case GET_DEVICE_CONNECTION_STATE: { CHECK_INTERFACE(IAudioPolicyService, data, reply); - AudioSystem::audio_devices device = - static_cast<AudioSystem::audio_devices> (data.readInt32()); + audio_devices_t device = + static_cast<audio_devices_t> (data.readInt32()); const char *device_address = data.readCString(); reply->writeInt32(static_cast<uint32_t> (getDeviceConnectionState(device, device_address))); @@ -367,29 +369,29 @@ status_t BnAudioPolicyService::onTransact( case SET_FORCE_USE: { CHECK_INTERFACE(IAudioPolicyService, data, reply); - AudioSystem::force_use usage = static_cast <AudioSystem::force_use>(data.readInt32()); - AudioSystem::forced_config config = - static_cast <AudioSystem::forced_config>(data.readInt32()); + audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(data.readInt32()); + audio_policy_forced_cfg_t config = + static_cast <audio_policy_forced_cfg_t>(data.readInt32()); reply->writeInt32(static_cast <uint32_t>(setForceUse(usage, config))); return NO_ERROR; } break; case GET_FORCE_USE: { CHECK_INTERFACE(IAudioPolicyService, data, reply); - AudioSystem::force_use usage = static_cast <AudioSystem::force_use>(data.readInt32()); + audio_policy_force_use_t usage = static_cast <audio_policy_force_use_t>(data.readInt32()); reply->writeInt32(static_cast <uint32_t>(getForceUse(usage))); return NO_ERROR; } break; case GET_OUTPUT: { CHECK_INTERFACE(IAudioPolicyService, data, reply); - AudioSystem::stream_type stream = - static_cast <AudioSystem::stream_type>(data.readInt32()); + audio_stream_type_t stream = + static_cast <audio_stream_type_t>(data.readInt32()); uint32_t samplingRate = data.readInt32(); uint32_t format = data.readInt32(); uint32_t channels = data.readInt32(); - AudioSystem::output_flags flags = - static_cast <AudioSystem::output_flags>(data.readInt32()); + audio_policy_output_flags_t flags = + static_cast <audio_policy_output_flags_t>(data.readInt32()); audio_io_handle_t output = getOutput(stream, samplingRate, @@ -406,7 +408,7 @@ status_t BnAudioPolicyService::onTransact( uint32_t stream = data.readInt32(); int session = data.readInt32(); reply->writeInt32(static_cast <uint32_t>(startOutput(output, - (AudioSystem::stream_type)stream, + (audio_stream_type_t)stream, session))); return NO_ERROR; } break; @@ -417,7 +419,7 @@ status_t BnAudioPolicyService::onTransact( uint32_t stream = data.readInt32(); int session = data.readInt32(); reply->writeInt32(static_cast <uint32_t>(stopOutput(output, - (AudioSystem::stream_type)stream, + (audio_stream_type_t)stream, session))); return NO_ERROR; } break; @@ -435,8 +437,8 @@ status_t BnAudioPolicyService::onTransact( uint32_t samplingRate = data.readInt32(); uint32_t format = data.readInt32(); uint32_t channels = data.readInt32(); - AudioSystem::audio_in_acoustics acoustics = - static_cast <AudioSystem::audio_in_acoustics>(data.readInt32()); + audio_in_acoustics_t acoustics = + static_cast <audio_in_acoustics_t>(data.readInt32()); audio_io_handle_t input = getInput(inputSource, samplingRate, format, @@ -469,8 +471,8 @@ status_t BnAudioPolicyService::onTransact( case INIT_STREAM_VOLUME: { CHECK_INTERFACE(IAudioPolicyService, data, reply); - AudioSystem::stream_type stream = - static_cast <AudioSystem::stream_type>(data.readInt32()); + audio_stream_type_t stream = + static_cast <audio_stream_type_t>(data.readInt32()); int indexMin = data.readInt32(); int indexMax = data.readInt32(); reply->writeInt32(static_cast <uint32_t>(initStreamVolume(stream, indexMin,indexMax))); @@ -479,8 +481,8 @@ status_t BnAudioPolicyService::onTransact( case SET_STREAM_VOLUME: { CHECK_INTERFACE(IAudioPolicyService, data, reply); - AudioSystem::stream_type stream = - static_cast <AudioSystem::stream_type>(data.readInt32()); + audio_stream_type_t stream = + static_cast <audio_stream_type_t>(data.readInt32()); int index = data.readInt32(); reply->writeInt32(static_cast <uint32_t>(setStreamVolumeIndex(stream, index))); return NO_ERROR; @@ -488,8 +490,8 @@ status_t BnAudioPolicyService::onTransact( case GET_STREAM_VOLUME: { CHECK_INTERFACE(IAudioPolicyService, data, reply); - AudioSystem::stream_type stream = - static_cast <AudioSystem::stream_type>(data.readInt32()); + audio_stream_type_t stream = + static_cast <audio_stream_type_t>(data.readInt32()); int index; status_t status = getStreamVolumeIndex(stream, &index); reply->writeInt32(index); @@ -499,16 +501,16 @@ status_t BnAudioPolicyService::onTransact( case GET_STRATEGY_FOR_STREAM: { CHECK_INTERFACE(IAudioPolicyService, data, reply); - AudioSystem::stream_type stream = - static_cast <AudioSystem::stream_type>(data.readInt32()); + audio_stream_type_t stream = + static_cast <audio_stream_type_t>(data.readInt32()); reply->writeInt32(getStrategyForStream(stream)); return NO_ERROR; } break; case GET_DEVICES_FOR_STREAM: { CHECK_INTERFACE(IAudioPolicyService, data, reply); - AudioSystem::stream_type stream = - static_cast <AudioSystem::stream_type>(data.readInt32()); + audio_stream_type_t stream = + static_cast <audio_stream_type_t>(data.readInt32()); reply->writeInt32(static_cast <int>(getDevicesForStream(stream))); return NO_ERROR; } break; diff --git a/media/libmedia/JetPlayer.cpp b/media/libmedia/JetPlayer.cpp index ee9e1d8..88157d2 100644 --- a/media/libmedia/JetPlayer.cpp +++ b/media/libmedia/JetPlayer.cpp @@ -96,10 +96,10 @@ int JetPlayer::init() // create the output AudioTrack mAudioTrack = new AudioTrack(); - mAudioTrack->set(AudioSystem::MUSIC, //TODO parametrize this + mAudioTrack->set(AUDIO_STREAM_MUSIC, //TODO parametrize this pLibConfig->sampleRate, 1, // format = PCM 16bits per sample, - (pLibConfig->numChannels == 2) ? AudioSystem::CHANNEL_OUT_STEREO : AudioSystem::CHANNEL_OUT_MONO, + (pLibConfig->numChannels == 2) ? AUDIO_CHANNEL_OUT_STEREO : AUDIO_CHANNEL_OUT_MONO, mTrackBufferSize, 0); diff --git a/media/libmedia/ToneGenerator.cpp b/media/libmedia/ToneGenerator.cpp index 82fe2d4..9f1b3d6 100644 --- a/media/libmedia/ToneGenerator.cpp +++ b/media/libmedia/ToneGenerator.cpp @@ -1026,8 +1026,8 @@ bool ToneGenerator::initAudioTrack() { mpAudioTrack->set(mStreamType, 0, - AudioSystem::PCM_16_BIT, - AudioSystem::CHANNEL_OUT_MONO, + AUDIO_FORMAT_PCM_16_BIT, + AUDIO_CHANNEL_OUT_MONO, 0, 0, audioCallback, diff --git a/media/libmedia/Visualizer.cpp b/media/libmedia/Visualizer.cpp index 43571cf..366707c 100644 --- a/media/libmedia/Visualizer.cpp +++ b/media/libmedia/Visualizer.cpp @@ -24,6 +24,8 @@ #include <sys/types.h> #include <limits.h> +#include <cutils/bitops.h> + #include <media/Visualizer.h> extern void fixed_fft_real(int n, int32_t *v); @@ -127,7 +129,7 @@ status_t Visualizer::setCaptureSize(uint32_t size) { if (size > VISUALIZER_CAPTURE_SIZE_MAX || size < VISUALIZER_CAPTURE_SIZE_MIN || - AudioSystem::popCount(size) != 1) { + popcount(size) != 1) { return BAD_VALUE; } diff --git a/media/libmedia/mediaplayer.cpp b/media/libmedia/mediaplayer.cpp index e80e742..9daa80f 100644 --- a/media/libmedia/mediaplayer.cpp +++ b/media/libmedia/mediaplayer.cpp @@ -37,6 +37,8 @@ #include <utils/KeyedVector.h> #include <utils/String8.h> +#include <hardware/audio.h> + namespace android { MediaPlayer::MediaPlayer() @@ -45,7 +47,7 @@ MediaPlayer::MediaPlayer() mListener = NULL; mCookie = NULL; mDuration = -1; - mStreamType = AudioSystem::MUSIC; + mStreamType = AUDIO_STREAM_MUSIC; mCurrentPosition = -1; mSeekPosition = -1; mCurrentState = MEDIA_PLAYER_IDLE; diff --git a/media/libmediaplayerservice/MediaPlayerService.cpp b/media/libmediaplayerservice/MediaPlayerService.cpp index 6b97708..9dd353b 100644 --- a/media/libmediaplayerservice/MediaPlayerService.cpp +++ b/media/libmediaplayerservice/MediaPlayerService.cpp @@ -53,6 +53,8 @@ #include <media/AudioTrack.h> #include <media/MemoryLeakTrackUtil.h> +#include <hardware/audio.h> + #include <private/android_filesystem_config.h> #include "MediaRecorderClient.h" @@ -1209,7 +1211,7 @@ MediaPlayerService::AudioOutput::AudioOutput(int sessionId) mSessionId(sessionId) { LOGV("AudioOutput(%d)", sessionId); mTrack = 0; - mStreamType = AudioSystem::MUSIC; + mStreamType = AUDIO_STREAM_MUSIC; mLeftVolume = 1.0; mRightVolume = 1.0; mLatency = 0; @@ -1319,7 +1321,7 @@ status_t MediaPlayerService::AudioOutput::open( mStreamType, sampleRate, format, - (channelCount == 2) ? AudioSystem::CHANNEL_OUT_STEREO : AudioSystem::CHANNEL_OUT_MONO, + (channelCount == 2) ? AUDIO_CHANNEL_OUT_STEREO : AUDIO_CHANNEL_OUT_MONO, frameCount, 0 /* flags */, CallbackWrapper, @@ -1331,7 +1333,7 @@ status_t MediaPlayerService::AudioOutput::open( mStreamType, sampleRate, format, - (channelCount == 2) ? AudioSystem::CHANNEL_OUT_STEREO : AudioSystem::CHANNEL_OUT_MONO, + (channelCount == 2) ? AUDIO_CHANNEL_OUT_STEREO : AUDIO_CHANNEL_OUT_MONO, frameCount, 0, NULL, diff --git a/media/libmediaplayerservice/MediaPlayerService.h b/media/libmediaplayerservice/MediaPlayerService.h index 5539a37..31b518e 100644 --- a/media/libmediaplayerservice/MediaPlayerService.h +++ b/media/libmediaplayerservice/MediaPlayerService.h @@ -30,6 +30,8 @@ #include <media/MediaPlayerInterface.h> #include <media/Metadata.h> +#include <hardware/audio.h> + namespace android { class IMediaRecorder; @@ -130,7 +132,7 @@ class MediaPlayerService : public BnMediaPlayerService virtual ssize_t bufferSize() const { return frameSize() * mFrameCount; } virtual ssize_t frameCount() const { return mFrameCount; } virtual ssize_t channelCount() const { return (ssize_t)mChannelCount; } - virtual ssize_t frameSize() const { return ssize_t(mChannelCount * ((mFormat == AudioSystem::PCM_16_BIT)?sizeof(int16_t):sizeof(u_int8_t))); } + virtual ssize_t frameSize() const { return ssize_t(mChannelCount * ((mFormat == AUDIO_FORMAT_PCM_16_BIT)?sizeof(int16_t):sizeof(u_int8_t))); } virtual uint32_t latency() const; virtual float msecsPerFrame() const; virtual status_t getPosition(uint32_t *position); diff --git a/media/libmediaplayerservice/MediaRecorderClient.cpp b/media/libmediaplayerservice/MediaRecorderClient.cpp index 1a1780c..5a47384 100644 --- a/media/libmediaplayerservice/MediaRecorderClient.cpp +++ b/media/libmediaplayerservice/MediaRecorderClient.cpp @@ -35,6 +35,8 @@ #include <media/AudioTrack.h> +#include <hardware/audio.h> + #include "MediaRecorderClient.h" #include "MediaPlayerService.h" @@ -102,7 +104,7 @@ status_t MediaRecorderClient::setAudioSource(int as) LOGE("recorder is not initialized"); return NO_INIT; } - return mRecorder->setAudioSource((audio_source)as); + return mRecorder->setAudioSource((audio_source_t)as); } status_t MediaRecorderClient::setOutputFormat(int of) diff --git a/media/libmediaplayerservice/MidiFile.cpp b/media/libmediaplayerservice/MidiFile.cpp index 1b0b05f..37a3db3 100644 --- a/media/libmediaplayerservice/MidiFile.cpp +++ b/media/libmediaplayerservice/MidiFile.cpp @@ -30,6 +30,8 @@ #include <sys/types.h> #include <sys/stat.h> +#include <hardware/audio.h> + #include "MidiFile.h" #ifdef HAVE_GETTID @@ -58,7 +60,7 @@ static const S_EAS_LIB_CONFIG* pLibConfig = NULL; MidiFile::MidiFile() : mEasData(NULL), mEasHandle(NULL), mAudioBuffer(NULL), mPlayTime(-1), mDuration(-1), mState(EAS_STATE_ERROR), - mStreamType(AudioSystem::MUSIC), mLoop(false), mExit(false), + mStreamType(AUDIO_STREAM_MUSIC), mLoop(false), mExit(false), mPaused(false), mRender(false), mTid(-1) { LOGV("constructor"); @@ -423,7 +425,7 @@ status_t MidiFile::setLooping(int loop) } status_t MidiFile::createOutputTrack() { - if (mAudioSink->open(pLibConfig->sampleRate, pLibConfig->numChannels, AudioSystem::PCM_16_BIT, 2) != NO_ERROR) { + if (mAudioSink->open(pLibConfig->sampleRate, pLibConfig->numChannels, AUDIO_FORMAT_PCM_16_BIT, 2) != NO_ERROR) { LOGE("mAudioSink open failed"); return ERROR_OPEN_FAILED; } diff --git a/media/libmediaplayerservice/StagefrightRecorder.cpp b/media/libmediaplayerservice/StagefrightRecorder.cpp index e3dfabb..01fbea1 100644 --- a/media/libmediaplayerservice/StagefrightRecorder.cpp +++ b/media/libmediaplayerservice/StagefrightRecorder.cpp @@ -46,6 +46,8 @@ #include <ctype.h> #include <unistd.h> +#include <hardware/audio.h> + #include "ARTPWriter.h" namespace android { @@ -64,7 +66,7 @@ static void addBatteryData(uint32_t params) { StagefrightRecorder::StagefrightRecorder() : mWriter(NULL), mWriterAux(NULL), mOutputFd(-1), mOutputFdAux(-1), - mAudioSource(AUDIO_SOURCE_LIST_END), + mAudioSource(AUDIO_SOURCE_CNT), mVideoSource(VIDEO_SOURCE_LIST_END), mStarted(false) { @@ -82,10 +84,10 @@ status_t StagefrightRecorder::init() { return OK; } -status_t StagefrightRecorder::setAudioSource(audio_source as) { +status_t StagefrightRecorder::setAudioSource(audio_source_t as) { LOGV("setAudioSource: %d", as); if (as < AUDIO_SOURCE_DEFAULT || - as >= AUDIO_SOURCE_LIST_END) { + as >= AUDIO_SOURCE_CNT) { LOGE("Invalid audio source: %d", as); return BAD_VALUE; } @@ -800,7 +802,7 @@ status_t StagefrightRecorder::start() { mStarted = true; uint32_t params = IMediaPlayerService::kBatteryDataCodecStarted; - if (mAudioSource != AUDIO_SOURCE_LIST_END) { + if (mAudioSource != AUDIO_SOURCE_CNT) { params |= IMediaPlayerService::kBatteryDataTrackAudio; } if (mVideoSource != VIDEO_SOURCE_LIST_END) { @@ -874,7 +876,7 @@ status_t StagefrightRecorder::startAACRecording() { mOutputFormat == OUTPUT_FORMAT_AAC_ADTS); CHECK(mAudioEncoder == AUDIO_ENCODER_AAC); - CHECK(mAudioSource != AUDIO_SOURCE_LIST_END); + CHECK(mAudioSource != AUDIO_SOURCE_CNT); CHECK(0 == "AACWriter is not implemented yet"); @@ -900,7 +902,7 @@ status_t StagefrightRecorder::startAMRRecording() { } } - if (mAudioSource >= AUDIO_SOURCE_LIST_END) { + if (mAudioSource >= AUDIO_SOURCE_CNT) { LOGE("Invalid audio source: %d", mAudioSource); return BAD_VALUE; } @@ -933,9 +935,9 @@ status_t StagefrightRecorder::startAMRRecording() { status_t StagefrightRecorder::startRTPRecording() { CHECK_EQ(mOutputFormat, OUTPUT_FORMAT_RTP_AVP); - if ((mAudioSource != AUDIO_SOURCE_LIST_END + if ((mAudioSource != AUDIO_SOURCE_CNT && mVideoSource != VIDEO_SOURCE_LIST_END) - || (mAudioSource == AUDIO_SOURCE_LIST_END + || (mAudioSource == AUDIO_SOURCE_CNT && mVideoSource == VIDEO_SOURCE_LIST_END)) { // Must have exactly one source. return BAD_VALUE; @@ -947,7 +949,7 @@ status_t StagefrightRecorder::startRTPRecording() { sp<MediaSource> source; - if (mAudioSource != AUDIO_SOURCE_LIST_END) { + if (mAudioSource != AUDIO_SOURCE_CNT) { source = createAudioSource(); } else { @@ -975,7 +977,7 @@ status_t StagefrightRecorder::startMPEG2TSRecording() { sp<MediaWriter> writer = new MPEG2TSWriter(mOutputFd); - if (mAudioSource != AUDIO_SOURCE_LIST_END) { + if (mAudioSource != AUDIO_SOURCE_CNT) { if (mAudioEncoder != AUDIO_ENCODER_AAC) { return ERROR_UNSUPPORTED; } @@ -1383,7 +1385,7 @@ status_t StagefrightRecorder::setupMPEG4Recording( // Audio source is added at the end if it exists. // This help make sure that the "recoding" sound is suppressed for // camcorder applications in the recorded files. - if (!mCaptureTimeLapse && (mAudioSource != AUDIO_SOURCE_LIST_END)) { + if (!mCaptureTimeLapse && (mAudioSource != AUDIO_SOURCE_CNT)) { err = setupAudioEncoder(writer); if (err != OK) return err; *totalBitRate += mAudioBitRate; @@ -1504,7 +1506,7 @@ status_t StagefrightRecorder::pause() { mStarted = false; uint32_t params = 0; - if (mAudioSource != AUDIO_SOURCE_LIST_END) { + if (mAudioSource != AUDIO_SOURCE_CNT) { params |= IMediaPlayerService::kBatteryDataTrackAudio; } if (mVideoSource != VIDEO_SOURCE_LIST_END) { @@ -1555,7 +1557,7 @@ status_t StagefrightRecorder::stop() { mStarted = false; uint32_t params = 0; - if (mAudioSource != AUDIO_SOURCE_LIST_END) { + if (mAudioSource != AUDIO_SOURCE_CNT) { params |= IMediaPlayerService::kBatteryDataTrackAudio; } if (mVideoSource != VIDEO_SOURCE_LIST_END) { @@ -1581,7 +1583,7 @@ status_t StagefrightRecorder::reset() { stop(); // No audio or video source by default - mAudioSource = AUDIO_SOURCE_LIST_END; + mAudioSource = AUDIO_SOURCE_CNT; mVideoSource = VIDEO_SOURCE_LIST_END; // Default parameters diff --git a/media/libmediaplayerservice/StagefrightRecorder.h b/media/libmediaplayerservice/StagefrightRecorder.h index 2c440c1..3d463ea 100644 --- a/media/libmediaplayerservice/StagefrightRecorder.h +++ b/media/libmediaplayerservice/StagefrightRecorder.h @@ -22,6 +22,8 @@ #include <camera/CameraParameters.h> #include <utils/String8.h> +#include <hardware/audio.h> + namespace android { class Camera; @@ -39,7 +41,7 @@ struct StagefrightRecorder : public MediaRecorderBase { virtual ~StagefrightRecorder(); virtual status_t init(); - virtual status_t setAudioSource(audio_source as); + virtual status_t setAudioSource(audio_source_t as); virtual status_t setVideoSource(video_source vs); virtual status_t setOutputFormat(output_format of); virtual status_t setAudioEncoder(audio_encoder ae); @@ -69,7 +71,7 @@ private: sp<MediaWriter> mWriter, mWriterAux; sp<AudioSource> mAudioSourceNode; - audio_source mAudioSource; + audio_source_t mAudioSource; video_source mVideoSource; output_format mOutputFormat; audio_encoder mAudioEncoder; diff --git a/media/libstagefright/AudioPlayer.cpp b/media/libstagefright/AudioPlayer.cpp index fcea848..69f9c23 100644 --- a/media/libstagefright/AudioPlayer.cpp +++ b/media/libstagefright/AudioPlayer.cpp @@ -110,7 +110,7 @@ status_t AudioPlayer::start(bool sourceAlreadyStarted) { if (mAudioSink.get() != NULL) { status_t err = mAudioSink->open( - mSampleRate, numChannels, AudioSystem::PCM_16_BIT, + mSampleRate, numChannels, AUDIO_FORMAT_PCM_16_BIT, DEFAULT_AUDIOSINK_BUFFERCOUNT, &AudioPlayer::AudioSinkCallback, this); if (err != OK) { @@ -132,10 +132,10 @@ status_t AudioPlayer::start(bool sourceAlreadyStarted) { mAudioSink->start(); } else { mAudioTrack = new AudioTrack( - AudioSystem::MUSIC, mSampleRate, AudioSystem::PCM_16_BIT, + AUDIO_STREAM_MUSIC, mSampleRate, AUDIO_FORMAT_PCM_16_BIT, (numChannels == 2) - ? AudioSystem::CHANNEL_OUT_STEREO - : AudioSystem::CHANNEL_OUT_MONO, + ? AUDIO_CHANNEL_OUT_STEREO + : AUDIO_CHANNEL_OUT_MONO, 0, 0, &AudioCallback, this, 0); if ((err = mAudioTrack->initCheck()) != OK) { diff --git a/media/libstagefright/AudioSource.cpp b/media/libstagefright/AudioSource.cpp index bbdec02..99c3682 100644 --- a/media/libstagefright/AudioSource.cpp +++ b/media/libstagefright/AudioSource.cpp @@ -60,8 +60,8 @@ AudioSource::AudioSource( AudioRecord::RECORD_NS_ENABLE | AudioRecord::RECORD_IIR_ENABLE; mRecord = new AudioRecord( - inputSource, sampleRate, AudioSystem::PCM_16_BIT, - channels > 1? AudioSystem::CHANNEL_IN_STEREO: AudioSystem::CHANNEL_IN_MONO, + inputSource, sampleRate, AUDIO_FORMAT_PCM_16_BIT, + channels > 1? AUDIO_CHANNEL_IN_STEREO: AUDIO_CHANNEL_IN_MONO, 4 * kMaxBufferSize / sizeof(int16_t), /* Enable ping-pong buffers */ flags, AudioRecordCallbackFunction, diff --git a/services/audioflinger/Android.mk b/services/audioflinger/Android.mk index 6d78614..2222e8b 100644 --- a/services/audioflinger/Android.mk +++ b/services/audioflinger/Android.mk @@ -15,9 +15,12 @@ LOCAL_SHARED_LIBRARIES := \ libutils \ libbinder \ libmedia \ + libhardware \ libhardware_legacy \ libeffects +LOCAL_STATIC_LIBRARIES := \ + libmedia_helper ifeq ($(TARGET_SIMULATOR),true) LOCAL_LDLIBS += -ldl diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp index 04cfa08..301f467 100644 --- a/services/audioflinger/AudioFlinger.cpp +++ b/services/audioflinger/AudioFlinger.cpp @@ -33,6 +33,7 @@ #include <utils/threads.h> #include <utils/Atomic.h> +#include <cutils/bitops.h> #include <cutils/properties.h> #include <media/AudioTrack.h> @@ -41,15 +42,13 @@ #include <private/media/AudioTrackShared.h> #include <private/media/AudioEffectShared.h> -#include <hardware_legacy/AudioHardwareInterface.h> + +#include <hardware/audio.h> +#include <hardware/audio_hal.h> #include "AudioMixer.h" #include "AudioFlinger.h" -#ifdef WITH_A2DP -#include "A2dpAudioInterface.h" -#endif - #include <media/EffectsFactoryApi.h> #include <media/EffectVisualizerApi.h> @@ -141,22 +140,37 @@ static void addBatteryData(uint32_t params) { AudioFlinger::AudioFlinger() : BnAudioFlinger(), - mAudioHardware(0), mMasterVolume(1.0f), mMasterMute(false), mNextUniqueId(1) + mAudioHardwareDev(0), mMasterVolume(1.0f), mMasterMute(false), mNextUniqueId(1) { + const hw_module_t *module; + int rc; + char mod_name[PATH_MAX]; + Mutex::Autolock _l(mLock); mHardwareStatus = AUDIO_HW_IDLE; - mAudioHardware = AudioHardwareInterface::create(); + /* get the audio hw module and create an audio_hw device */ + snprintf(mod_name, PATH_MAX, "%s.%s", AUDIO_HARDWARE_MODULE_ID, "primary"); + rc = hw_get_module(mod_name, &module); + if (rc) + return; + + rc = audio_hw_device_open(module, &mAudioHardwareDev); + LOGE_IF(rc, "couldn't open audio hw device (%s)", strerror(-rc)); + if (rc) + return; mHardwareStatus = AUDIO_HW_INIT; - if (mAudioHardware->initCheck() == NO_ERROR) { + + rc = mAudioHardwareDev->init_check(mAudioHardwareDev); + if (rc == 0) { AutoMutex lock(mHardwareLock); - mMode = AudioSystem::MODE_NORMAL; + mMode = AUDIO_MODE_NORMAL; mHardwareStatus = AUDIO_HW_SET_MODE; - mAudioHardware->setMode(mMode); + mAudioHardwareDev->set_mode(mAudioHardwareDev, mMode); mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME; - mAudioHardware->setMasterVolume(1.0f); + mAudioHardwareDev->set_master_volume(mAudioHardwareDev, 1.0f); mHardwareStatus = AUDIO_HW_IDLE; } else { LOGE("Couldn't even initialize the stubbed audio hardware!"); @@ -173,8 +187,8 @@ AudioFlinger::~AudioFlinger() // closeOutput() will remove first entry from mPlaybackThreads closeOutput(mPlaybackThreads.keyAt(0)); } - if (mAudioHardware) { - delete mAudioHardware; + if (mAudioHardwareDev) { + audio_hw_device_close(mAudioHardwareDev); } } @@ -277,8 +291,8 @@ status_t AudioFlinger::dump(int fd, const Vector<String16>& args) mRecordThreads.valueAt(i)->dump(fd, args); } - if (mAudioHardware) { - mAudioHardware->dumpState(fd, args); + if (mAudioHardwareDev) { + mAudioHardwareDev->dump(mAudioHardwareDev, fd); } if (locked) mLock.unlock(); } @@ -309,7 +323,7 @@ sp<IAudioTrack> AudioFlinger::createTrack( status_t lStatus; int lSessionId; - if (streamType >= AudioSystem::NUM_STREAM_TYPES) { + if (streamType >= AUDIO_STREAM_CNT) { LOGE("invalid stream type"); lStatus = BAD_VALUE; goto Exit; @@ -335,7 +349,7 @@ sp<IAudioTrack> AudioFlinger::createTrack( } LOGV("createTrack() sessionId: %d", (sessionId == NULL) ? -2 : *sessionId); - if (sessionId != NULL && *sessionId != AudioSystem::SESSION_OUTPUT_MIX) { + if (sessionId != NULL && *sessionId != AUDIO_SESSION_OUTPUT_MIX) { for (size_t i = 0; i < mPlaybackThreads.size(); i++) { sp<PlaybackThread> t = mPlaybackThreads.valueAt(i); if (mPlaybackThreads.keyAt(i) != output) { @@ -454,7 +468,7 @@ status_t AudioFlinger::setMasterVolume(float value) { // scope for the lock AutoMutex lock(mHardwareLock); mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME; - if (mAudioHardware->setMasterVolume(value) == NO_ERROR) { + if (mAudioHardwareDev->set_master_volume(mAudioHardwareDev, value) == NO_ERROR) { value = 1.0f; } mHardwareStatus = AUDIO_HW_IDLE; @@ -476,7 +490,7 @@ status_t AudioFlinger::setMode(int mode) if (!settingsAllowed()) { return PERMISSION_DENIED; } - if ((mode < 0) || (mode >= AudioSystem::NUM_MODES)) { + if ((mode < 0) || (mode >= AUDIO_MODE_CNT)) { LOGW("Illegal value: setMode(%d)", mode); return BAD_VALUE; } @@ -484,7 +498,7 @@ status_t AudioFlinger::setMode(int mode) { // scope for the lock AutoMutex lock(mHardwareLock); mHardwareStatus = AUDIO_HW_SET_MODE; - ret = mAudioHardware->setMode(mode); + ret = mAudioHardwareDev->set_mode(mAudioHardwareDev, mode); mHardwareStatus = AUDIO_HW_IDLE; } @@ -507,16 +521,16 @@ status_t AudioFlinger::setMicMute(bool state) AutoMutex lock(mHardwareLock); mHardwareStatus = AUDIO_HW_SET_MIC_MUTE; - status_t ret = mAudioHardware->setMicMute(state); + status_t ret = mAudioHardwareDev->set_mic_mute(mAudioHardwareDev, state); mHardwareStatus = AUDIO_HW_IDLE; return ret; } bool AudioFlinger::getMicMute() const { - bool state = AudioSystem::MODE_INVALID; + bool state = AUDIO_MODE_INVALID; mHardwareStatus = AUDIO_HW_GET_MIC_MUTE; - mAudioHardware->getMicMute(&state); + mAudioHardwareDev->get_mic_mute(mAudioHardwareDev, &state); mHardwareStatus = AUDIO_HW_IDLE; return state; } @@ -553,7 +567,7 @@ status_t AudioFlinger::setStreamVolume(int stream, float value, int output) return PERMISSION_DENIED; } - if (stream < 0 || uint32_t(stream) >= AudioSystem::NUM_STREAM_TYPES) { + if (stream < 0 || uint32_t(stream) >= AUDIO_STREAM_CNT) { return BAD_VALUE; } @@ -586,8 +600,8 @@ status_t AudioFlinger::setStreamMute(int stream, bool muted) return PERMISSION_DENIED; } - if (stream < 0 || uint32_t(stream) >= AudioSystem::NUM_STREAM_TYPES || - uint32_t(stream) == AudioSystem::ENFORCED_AUDIBLE) { + if (stream < 0 || uint32_t(stream) >= AUDIO_STREAM_CNT || + uint32_t(stream) == AUDIO_STREAM_ENFORCED_AUDIBLE) { return BAD_VALUE; } @@ -601,7 +615,7 @@ status_t AudioFlinger::setStreamMute(int stream, bool muted) float AudioFlinger::streamVolume(int stream, int output) const { - if (stream < 0 || uint32_t(stream) >= AudioSystem::NUM_STREAM_TYPES) { + if (stream < 0 || uint32_t(stream) >= AUDIO_STREAM_CNT) { return 0.0f; } @@ -622,7 +636,7 @@ float AudioFlinger::streamVolume(int stream, int output) const bool AudioFlinger::streamMute(int stream) const { - if (stream < 0 || stream >= (int)AudioSystem::NUM_STREAM_TYPES) { + if (stream < 0 || stream >= (int)AUDIO_STREAM_CNT) { return true; } @@ -644,7 +658,7 @@ status_t AudioFlinger::setParameters(int ioHandle, const String8& keyValuePairs) if (ioHandle == 0) { AutoMutex lock(mHardwareLock); mHardwareStatus = AUDIO_SET_PARAMETER; - result = mAudioHardware->setParameters(keyValuePairs); + result = mAudioHardwareDev->set_parameters(mAudioHardwareDev, keyValuePairs.string()); mHardwareStatus = AUDIO_HW_IDLE; return result; } @@ -672,7 +686,13 @@ String8 AudioFlinger::getParameters(int ioHandle, const String8& keys) // ioHandle, keys.string(), gettid(), IPCThreadState::self()->getCallingPid()); if (ioHandle == 0) { - return mAudioHardware->getParameters(keys); + char *s; + String8 out_s8; + + s = mAudioHardwareDev->get_parameters(mAudioHardwareDev, keys.string()); + out_s8 = String8(s); + free(s); + return out_s8; } Mutex::Autolock _l(mLock); @@ -690,7 +710,7 @@ String8 AudioFlinger::getParameters(int ioHandle, const String8& keys) size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, int format, int channelCount) { - return mAudioHardware->getInputBufferSize(sampleRate, format, channelCount); + return mAudioHardwareDev->get_input_buffer_size(mAudioHardwareDev, sampleRate, format, channelCount); } unsigned int AudioFlinger::getInputFramesLost(int ioHandle) @@ -717,7 +737,7 @@ status_t AudioFlinger::setVoiceVolume(float value) AutoMutex lock(mHardwareLock); mHardwareStatus = AUDIO_SET_VOICE_VOLUME; - status_t ret = mAudioHardware->setVoiceVolume(value); + status_t ret = mAudioHardwareDev->set_voice_volume(mAudioHardwareDev, value); mHardwareStatus = AUDIO_HW_IDLE; return ret; @@ -957,7 +977,7 @@ status_t AudioFlinger::ThreadBase::dumpBase(int fd, const Vector<String16>& args // ---------------------------------------------------------------------------- -AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device) +AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger, struct audio_stream_out* output, int id, uint32_t device) : ThreadBase(audioFlinger, id), mMixBuffer(0), mSuspended(0), mBytesWritten(0), mOutput(output), mLastWriteTime(0), mNumWrites(0), mNumDelayedWrites(0), mInWrite(false), @@ -968,7 +988,7 @@ AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinge mMasterVolume = mAudioFlinger->masterVolume(); mMasterMute = mAudioFlinger->masterMute(); - for (int stream = 0; stream < AudioSystem::NUM_STREAM_TYPES; stream++) { + for (int stream = 0; stream < AUDIO_STREAM_CNT; stream++) { mStreamTypes[stream].volume = mAudioFlinger->streamVolumeInternal(stream); mStreamTypes[stream].mute = mAudioFlinger->streamMute(stream); } @@ -1131,12 +1151,12 @@ sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTra // conflicts will happen when tracks are moved from one output to another by audio policy // manager uint32_t strategy = - AudioSystem::getStrategyForStream((AudioSystem::stream_type)streamType); + AudioSystem::getStrategyForStream((audio_stream_type_t)streamType); for (size_t i = 0; i < mTracks.size(); ++i) { sp<Track> t = mTracks[i]; if (t != 0) { if (sessionId == t->sessionId() && - strategy != AudioSystem::getStrategyForStream((AudioSystem::stream_type)t->type())) { + strategy != AudioSystem::getStrategyForStream((audio_stream_type_t)t->type())) { lStatus = BAD_VALUE; goto Exit; } @@ -1155,7 +1175,7 @@ sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTra if (chain != 0) { LOGV("createTrack_l() setting main buffer %p", chain->inBuffer()); track->setMainBuffer(chain->inBuffer()); - chain->setStrategy(AudioSystem::getStrategyForStream((AudioSystem::stream_type)track->type())); + chain->setStrategy(AudioSystem::getStrategyForStream((audio_stream_type_t)track->type())); } } lStatus = NO_ERROR; @@ -1170,7 +1190,7 @@ Exit: uint32_t AudioFlinger::PlaybackThread::latency() const { if (mOutput) { - return mOutput->latency(); + return mOutput->get_latency(mOutput); } else { return 0; @@ -1264,7 +1284,13 @@ void AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track) String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys) { - return mOutput->getParameters(keys); + String8 out_s8; + char *s; + + s = mOutput->common.get_parameters(&mOutput->common, keys.string()); + out_s8 = String8(s); + free(s); + return out_s8; } // destroyTrack_l() must be called with AudioFlinger::mLock held @@ -1296,12 +1322,12 @@ void AudioFlinger::PlaybackThread::audioConfigChanged_l(int event, int param) { void AudioFlinger::PlaybackThread::readOutputParameters() { - mSampleRate = mOutput->sampleRate(); - mChannels = mOutput->channels(); - mChannelCount = (uint16_t)AudioSystem::popCount(mChannels); - mFormat = mOutput->format(); - mFrameSize = (uint16_t)mOutput->frameSize(); - mFrameCount = mOutput->bufferSize() / mFrameSize; + mSampleRate = mOutput->common.get_sample_rate(&mOutput->common); + mChannels = mOutput->common.get_channels(&mOutput->common); + mChannelCount = (uint16_t)popcount(mChannels); + mFormat = mOutput->common.get_format(&mOutput->common); + mFrameSize = (uint16_t)audio_stream_frame_size(&mOutput->common); + mFrameCount = mOutput->common.get_buffer_size(&mOutput->common) / mFrameSize; // FIXME - Current mixer implementation only supports stereo output: Always // Allocate a stereo buffer even if HW output is mono. @@ -1329,9 +1355,9 @@ status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, ui if (mOutput == 0) { return INVALID_OPERATION; } - *halFrames = mBytesWritten/mOutput->frameSize(); + *halFrames = mBytesWritten / audio_stream_frame_size(&mOutput->common); - return mOutput->getRenderPosition(dspFrames); + return mOutput->get_render_position(mOutput, dspFrames); } uint32_t AudioFlinger::PlaybackThread::hasAudioSession(int sessionId) @@ -1356,19 +1382,19 @@ uint32_t AudioFlinger::PlaybackThread::hasAudioSession(int sessionId) uint32_t AudioFlinger::PlaybackThread::getStrategyForSession_l(int sessionId) { - // session AudioSystem::SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that + // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that // it is moved to correct output by audio policy manager when A2DP is connected or disconnected - if (sessionId == AudioSystem::SESSION_OUTPUT_MIX) { - return AudioSystem::getStrategyForStream(AudioSystem::MUSIC); + if (sessionId == AUDIO_SESSION_OUTPUT_MIX) { + return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC); } for (size_t i = 0; i < mTracks.size(); i++) { sp<Track> track = mTracks[i]; if (sessionId == track->sessionId() && !(track->mCblk->flags & CBLK_INVALID_MSK)) { - return AudioSystem::getStrategyForStream((AudioSystem::stream_type) track->type()); + return AudioSystem::getStrategyForStream((audio_stream_type_t) track->type()); } } - return AudioSystem::getStrategyForStream(AudioSystem::MUSIC); + return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC); } sp<AudioFlinger::EffectChain> AudioFlinger::PlaybackThread::getEffectChain(int sessionId) @@ -1402,7 +1428,7 @@ void AudioFlinger::PlaybackThread::setMode(uint32_t mode) // ---------------------------------------------------------------------------- -AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device) +AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, struct audio_stream_out* output, int id, uint32_t device) : PlaybackThread(audioFlinger, output, id, device), mAudioMixer(0) { @@ -1461,7 +1487,7 @@ bool AudioFlinger::MixerThread::threadLoop() mSuspended) { if (!mStandby) { LOGV("Audio hardware entering standby, mixer %p, mSuspended %d\n", this, mSuspended); - mOutput->standby(); + mOutput->common.standby(&mOutput->common); mStandby = true; mBytesWritten = 0; } @@ -1538,7 +1564,7 @@ bool AudioFlinger::MixerThread::threadLoop() mInWrite = true; mBytesWritten += mixBufferSize; - int bytesWritten = (int)mOutput->write(mMixBuffer, mixBufferSize); + int bytesWritten = (int)mOutput->write(mOutput, mMixBuffer, mixBufferSize); if (bytesWritten < 0) mBytesWritten -= mixBufferSize; mNumWrites++; mInWrite = false; @@ -1573,7 +1599,7 @@ bool AudioFlinger::MixerThread::threadLoop() } if (!mStandby) { - mOutput->standby(); + mOutput->common.standby(&mOutput->common); } LOGV("MixerThread %p exiting", this); @@ -1597,7 +1623,7 @@ uint32_t AudioFlinger::MixerThread::prepareTracks_l(const SortedVector< wp<Track masterVolume = 0; } // Delegate master volume control to effect in output mix effect chain if needed - sp<EffectChain> chain = getEffectChain_l(AudioSystem::SESSION_OUTPUT_MIX); + sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX); if (chain != 0) { uint32_t v = (uint32_t)(masterVolume * (1 << 24)); chain->setVolume_l(&v, &v); @@ -1823,14 +1849,14 @@ bool AudioFlinger::MixerThread::checkForNewParameters_l() reconfig = true; } if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) { - if (value != AudioSystem::PCM_16_BIT) { + if (value != AUDIO_FORMAT_PCM_16_BIT) { status = BAD_VALUE; } else { reconfig = true; } } if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) { - if (value != AudioSystem::CHANNEL_OUT_STEREO) { + if (value != AUDIO_CHANNEL_OUT_STEREO) { status = BAD_VALUE; } else { reconfig = true; @@ -1852,12 +1878,12 @@ bool AudioFlinger::MixerThread::checkForNewParameters_l() if (mDevice != value) { uint32_t params = 0; // check whether speaker is on - if (value & AudioSystem::DEVICE_OUT_SPEAKER) { + if (value & AUDIO_DEVICE_OUT_SPEAKER) { params |= IMediaPlayerService::kBatteryDataSpeakerOn; } int deviceWithoutSpeaker - = AudioSystem::DEVICE_OUT_ALL & ~AudioSystem::DEVICE_OUT_SPEAKER; + = AUDIO_DEVICE_OUT_ALL & ~AUDIO_DEVICE_OUT_SPEAKER; // check if any other device (except speaker) is on if (value & deviceWithoutSpeaker ) { params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn; @@ -1877,12 +1903,14 @@ bool AudioFlinger::MixerThread::checkForNewParameters_l() } if (status == NO_ERROR) { - status = mOutput->setParameters(keyValuePair); + status = mOutput->common.set_parameters(&mOutput->common, + keyValuePair.string()); if (!mStandby && status == INVALID_OPERATION) { - mOutput->standby(); + mOutput->common.standby(&mOutput->common); mStandby = true; mBytesWritten = 0; - status = mOutput->setParameters(keyValuePair); + status = mOutput->common.set_parameters(&mOutput->common, + keyValuePair.string()); } if (status == NO_ERROR && reconfig) { delete mAudioMixer; @@ -1926,7 +1954,7 @@ status_t AudioFlinger::MixerThread::dumpInternals(int fd, const Vector<String16> uint32_t AudioFlinger::MixerThread::activeSleepTimeUs() { - return (uint32_t)(mOutput->latency() * 1000) / 2; + return (uint32_t)(mOutput->get_latency(mOutput) * 1000) / 2; } uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() @@ -1940,7 +1968,7 @@ uint32_t AudioFlinger::MixerThread::suspendSleepTimeUs() } // ---------------------------------------------------------------------------- -AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device) +AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger, struct audio_stream_out* output, int id, uint32_t device) : PlaybackThread(audioFlinger, output, id, device) { mType = PlaybackThread::DIRECT; @@ -1976,12 +2004,12 @@ int32_t mul(int16_t in, int16_t v) void AudioFlinger::DirectOutputThread::applyVolume(uint16_t leftVol, uint16_t rightVol, bool ramp) { // Do not apply volume on compressed audio - if (!AudioSystem::isLinearPCM(mFormat)) { + if (!audio_is_linear_pcm(mFormat)) { return; } // convert to signed 16 bit before volume calculation - if (mFormat == AudioSystem::PCM_8_BIT) { + if (mFormat == AUDIO_FORMAT_PCM_8_BIT) { size_t count = mFrameCount * mChannelCount; uint8_t *src = (uint8_t *)mMixBuffer + count-1; int16_t *dst = mMixBuffer + count-1; @@ -2034,7 +2062,7 @@ void AudioFlinger::DirectOutputThread::applyVolume(uint16_t leftVol, uint16_t ri } // convert back to unsigned 8 bit after volume calculation - if (mFormat == AudioSystem::PCM_8_BIT) { + if (mFormat == AUDIO_FORMAT_PCM_8_BIT) { size_t count = mFrameCount * mChannelCount; int16_t *src = mMixBuffer; uint8_t *dst = (uint8_t *)mMixBuffer; @@ -2090,7 +2118,7 @@ bool AudioFlinger::DirectOutputThread::threadLoop() // wait until we have something to do... if (!mStandby) { LOGV("Audio hardware entering standby, mixer %p\n", this); - mOutput->standby(); + mOutput->common.standby(&mOutput->common); mStandby = true; mBytesWritten = 0; } @@ -2175,7 +2203,7 @@ bool AudioFlinger::DirectOutputThread::threadLoop() // If audio HAL implements volume control, // force software volume to nominal value - if (mOutput->setVolume(left, right) == NO_ERROR) { + if (mOutput->set_volume(mOutput, left, right) == NO_ERROR) { left = 1.0f; right = 1.0f; } @@ -2276,7 +2304,7 @@ bool AudioFlinger::DirectOutputThread::threadLoop() } else { sleepTime = idleSleepTime; } - } else if (mBytesWritten != 0 && AudioSystem::isLinearPCM(mFormat)) { + } else if (mBytesWritten != 0 && audio_is_linear_pcm(mFormat)) { memset (mMixBuffer, 0, mFrameCount * mFrameSize); sleepTime = 0; } @@ -2298,7 +2326,7 @@ bool AudioFlinger::DirectOutputThread::threadLoop() mLastWriteTime = systemTime(); mInWrite = true; mBytesWritten += mixBufferSize; - int bytesWritten = (int)mOutput->write(mMixBuffer, mixBufferSize); + int bytesWritten = (int)mOutput->write(mOutput, mMixBuffer, mixBufferSize); if (bytesWritten < 0) mBytesWritten -= mixBufferSize; mNumWrites++; mInWrite = false; @@ -2320,7 +2348,7 @@ bool AudioFlinger::DirectOutputThread::threadLoop() } if (!mStandby) { - mOutput->standby(); + mOutput->common.standby(&mOutput->common); } LOGV("DirectOutputThread %p exiting", this); @@ -2360,12 +2388,14 @@ bool AudioFlinger::DirectOutputThread::checkForNewParameters_l() } } if (status == NO_ERROR) { - status = mOutput->setParameters(keyValuePair); + status = mOutput->common.set_parameters(&mOutput->common, + keyValuePair.string()); if (!mStandby && status == INVALID_OPERATION) { - mOutput->standby(); + mOutput->common.standby(&mOutput->common); mStandby = true; mBytesWritten = 0; - status = mOutput->setParameters(keyValuePair); + status = mOutput->common.set_parameters(&mOutput->common, + keyValuePair.string()); } if (status == NO_ERROR && reconfig) { readOutputParameters(); @@ -2385,8 +2415,8 @@ bool AudioFlinger::DirectOutputThread::checkForNewParameters_l() uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() { uint32_t time; - if (AudioSystem::isLinearPCM(mFormat)) { - time = (uint32_t)(mOutput->latency() * 1000) / 2; + if (audio_is_linear_pcm(mFormat)) { + time = (uint32_t)(mOutput->get_latency(mOutput) * 1000) / 2; } else { time = 10000; } @@ -2396,7 +2426,7 @@ uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() { uint32_t time; - if (AudioSystem::isLinearPCM(mFormat)) { + if (audio_is_linear_pcm(mFormat)) { time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2; } else { time = 10000; @@ -2407,7 +2437,7 @@ uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() uint32_t AudioFlinger::DirectOutputThread::suspendSleepTimeUs() { uint32_t time; - if (AudioSystem::isLinearPCM(mFormat)) { + if (audio_is_linear_pcm(mFormat)) { time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000); } else { time = 10000; @@ -2588,7 +2618,7 @@ void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread) mChannelCount, frameCount); if (outputTrack->cblk() != NULL) { - thread->setStreamVolume(AudioSystem::NUM_STREAM_TYPES, 1.0f); + thread->setStreamVolume(AUDIO_STREAM_CNT, 1.0f); mOutputTracks.add(outputTrack); LOGV("addOutputTrack() track %p, on thread %p", outputTrack, thread); updateWaitTime(); @@ -2833,7 +2863,7 @@ AudioFlinger::PlaybackThread::Track::Track( mStreamType = streamType; // NOTE: audio_track_cblk_t::frameSize for 8 bit PCM data is based on a sample size of // 16 bit because data is converted to 16 bit before being stored in buffer by AudioTrack - mCblk->frameSize = AudioSystem::isLinearPCM(format) ? channelCount * sizeof(int16_t) : sizeof(int8_t); + mCblk->frameSize = audio_is_linear_pcm(format) ? channelCount * sizeof(int16_t) : sizeof(int8_t); } } @@ -2864,7 +2894,7 @@ void AudioFlinger::PlaybackThread::Track::destroy() if (!isOutputTrack()) { if (mState == ACTIVE || mState == RESUMING) { AudioSystem::stopOutput(thread->id(), - (AudioSystem::stream_type)mStreamType, + (audio_stream_type_t)mStreamType, mSessionId); // to track the speaker usage @@ -2976,7 +3006,7 @@ status_t AudioFlinger::PlaybackThread::Track::start() if (!isOutputTrack() && state != ACTIVE && state != RESUMING) { thread->mLock.unlock(); status = AudioSystem::startOutput(thread->id(), - (AudioSystem::stream_type)mStreamType, + (audio_stream_type_t)mStreamType, mSessionId); thread->mLock.lock(); @@ -3016,7 +3046,7 @@ void AudioFlinger::PlaybackThread::Track::stop() if (!isOutputTrack() && (state == ACTIVE || state == RESUMING)) { thread->mLock.unlock(); AudioSystem::stopOutput(thread->id(), - (AudioSystem::stream_type)mStreamType, + (audio_stream_type_t)mStreamType, mSessionId); thread->mLock.lock(); @@ -3038,7 +3068,7 @@ void AudioFlinger::PlaybackThread::Track::pause() if (!isOutputTrack()) { thread->mLock.unlock(); AudioSystem::stopOutput(thread->id(), - (AudioSystem::stream_type)mStreamType, + (audio_stream_type_t)mStreamType, mSessionId); thread->mLock.lock(); @@ -3132,9 +3162,9 @@ AudioFlinger::RecordThread::RecordTrack::RecordTrack( { if (mCblk != NULL) { LOGV("RecordTrack constructor, size %d", (int)mBufferEnd - (int)mBuffer); - if (format == AudioSystem::PCM_16_BIT) { + if (format == AUDIO_FORMAT_PCM_16_BIT) { mCblk->frameSize = channelCount * sizeof(int16_t); - } else if (format == AudioSystem::PCM_8_BIT) { + } else if (format == AUDIO_FORMAT_PCM_8_BIT) { mCblk->frameSize = channelCount * sizeof(int8_t); } else { mCblk->frameSize = sizeof(int8_t); @@ -3237,7 +3267,7 @@ AudioFlinger::PlaybackThread::OutputTrack::OutputTrack( int format, int channelCount, int frameCount) - : Track(thread, NULL, AudioSystem::NUM_STREAM_TYPES, sampleRate, format, channelCount, frameCount, NULL, 0), + : Track(thread, NULL, AUDIO_STREAM_CNT, sampleRate, format, channelCount, frameCount, NULL, 0), mActive(false), mSourceThread(sourceThread) { @@ -3609,7 +3639,7 @@ sp<IAudioRecord> AudioFlinger::openRecord( } // If no audio session id is provided, create one here - if (sessionId != NULL && *sessionId != AudioSystem::SESSION_OUTPUT_MIX) { + if (sessionId != NULL && *sessionId != AUDIO_SESSION_OUTPUT_MIX) { lSessionId = *sessionId; } else { lSessionId = nextUniqueId_l(); @@ -3675,11 +3705,11 @@ status_t AudioFlinger::RecordHandle::onTransact( // ---------------------------------------------------------------------------- -AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger, AudioStreamIn *input, uint32_t sampleRate, uint32_t channels, int id) : +AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger, struct audio_stream_in *input, uint32_t sampleRate, uint32_t channels, int id) : ThreadBase(audioFlinger, id), mInput(input), mResampler(0), mRsmpOutBuffer(0), mRsmpInBuffer(0) { - mReqChannelCount = AudioSystem::popCount(channels); + mReqChannelCount = popcount(channels); mReqSampleRate = sampleRate; readInputParameters(); } @@ -3721,7 +3751,7 @@ bool AudioFlinger::RecordThread::threadLoop() checkForNewParameters_l(); if (mActiveTrack == 0 && mConfigEvents.isEmpty()) { if (!mStandby) { - mInput->standby(); + mInput->common.standby(&mInput->common); mStandby = true; } @@ -3736,7 +3766,7 @@ bool AudioFlinger::RecordThread::threadLoop() if (mActiveTrack != 0) { if (mActiveTrack->mState == TrackBase::PAUSING) { if (!mStandby) { - mInput->standby(); + mInput->common.standby(&mInput->common); mStandby = true; } mActiveTrack.clear(); @@ -3781,7 +3811,7 @@ bool AudioFlinger::RecordThread::threadLoop() mRsmpInIndex += framesIn; framesOut -= framesIn; if ((int)mChannelCount == mReqChannelCount || - mFormat != AudioSystem::PCM_16_BIT) { + mFormat != AUDIO_FORMAT_PCM_16_BIT) { memcpy(dst, src, framesIn * mFrameSize); } else { int16_t *src16 = (int16_t *)src; @@ -3801,11 +3831,11 @@ bool AudioFlinger::RecordThread::threadLoop() } if (framesOut && mFrameCount == mRsmpInIndex) { if (framesOut == mFrameCount && - ((int)mChannelCount == mReqChannelCount || mFormat != AudioSystem::PCM_16_BIT)) { - mBytesRead = mInput->read(buffer.raw, mInputBytes); + ((int)mChannelCount == mReqChannelCount || mFormat != AUDIO_FORMAT_PCM_16_BIT)) { + mBytesRead = mInput->read(mInput, buffer.raw, mInputBytes); framesOut = 0; } else { - mBytesRead = mInput->read(mRsmpInBuffer, mInputBytes); + mBytesRead = mInput->read(mInput, mRsmpInBuffer, mInputBytes); mRsmpInIndex = 0; } if (mBytesRead < 0) { @@ -3813,7 +3843,7 @@ bool AudioFlinger::RecordThread::threadLoop() if (mActiveTrack->mState == TrackBase::ACTIVE) { // Force input into standby so that it tries to // recover at next read attempt - mInput->standby(); + mInput->common.standby(&mInput->common); usleep(5000); } mRsmpInIndex = mFrameCount; @@ -3868,7 +3898,7 @@ bool AudioFlinger::RecordThread::threadLoop() } if (!mStandby) { - mInput->standby(); + mInput->common.standby(&mInput->common); } mActiveTrack.clear(); @@ -4000,13 +4030,13 @@ status_t AudioFlinger::RecordThread::getNextBuffer(AudioBufferProvider::Buffer* int channelCount; if (framesReady == 0) { - mBytesRead = mInput->read(mRsmpInBuffer, mInputBytes); + mBytesRead = mInput->read(mInput, mRsmpInBuffer, mInputBytes); if (mBytesRead < 0) { LOGE("RecordThread::getNextBuffer() Error reading audio input"); if (mActiveTrack->mState == TrackBase::ACTIVE) { // Force input into standby so that it tries to // recover at next read attempt - mInput->standby(); + mInput->common.standby(&mInput->common); usleep(5000); } buffer->raw = 0; @@ -4059,7 +4089,7 @@ bool AudioFlinger::RecordThread::checkForNewParameters_l() reconfig = true; } if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) { - reqChannelCount = AudioSystem::popCount(value); + reqChannelCount = popcount(value); reconfig = true; } if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) { @@ -4073,16 +4103,18 @@ bool AudioFlinger::RecordThread::checkForNewParameters_l() } } if (status == NO_ERROR) { - status = mInput->setParameters(keyValuePair); + status = mInput->common.set_parameters(&mInput->common, keyValuePair.string()); if (status == INVALID_OPERATION) { - mInput->standby(); - status = mInput->setParameters(keyValuePair); + mInput->common.standby(&mInput->common); + status = mInput->common.set_parameters(&mInput->common, keyValuePair.string()); } if (reconfig) { if (status == BAD_VALUE && - reqFormat == mInput->format() && reqFormat == AudioSystem::PCM_16_BIT && - ((int)mInput->sampleRate() <= 2 * reqSamplingRate) && - (AudioSystem::popCount(mInput->channels()) < 3) && (reqChannelCount < 3)) { + reqFormat == mInput->common.get_format(&mInput->common) && + reqFormat == AUDIO_FORMAT_PCM_16_BIT && + ((int)mInput->common.get_sample_rate(&mInput->common) <= (2 * reqSamplingRate)) && + (popcount(mInput->common.get_channels(&mInput->common)) < 3) && + (reqChannelCount < 3)) { status = NO_ERROR; } if (status == NO_ERROR) { @@ -4103,7 +4135,13 @@ bool AudioFlinger::RecordThread::checkForNewParameters_l() String8 AudioFlinger::RecordThread::getParameters(const String8& keys) { - return mInput->getParameters(keys); + char *s; + String8 out_s8; + + s = mInput->common.get_parameters(&mInput->common, keys.string()); + out_s8 = String8(s); + free(s); + return out_s8; } void AudioFlinger::RecordThread::audioConfigChanged_l(int event, int param) { @@ -4135,12 +4173,12 @@ void AudioFlinger::RecordThread::readInputParameters() if (mResampler) delete mResampler; mResampler = 0; - mSampleRate = mInput->sampleRate(); - mChannels = mInput->channels(); - mChannelCount = (uint16_t)AudioSystem::popCount(mChannels); - mFormat = mInput->format(); - mFrameSize = (uint16_t)mInput->frameSize(); - mInputBytes = mInput->bufferSize(); + mSampleRate = mInput->common.get_sample_rate(&mInput->common); + mChannels = mInput->common.get_channels(&mInput->common); + mChannelCount = (uint16_t)popcount(mChannels); + mFormat = mInput->common.get_format(&mInput->common); + mFrameSize = (uint16_t)audio_stream_frame_size(&mInput->common); + mInputBytes = mInput->common.get_buffer_size(&mInput->common); mFrameCount = mInputBytes / mFrameSize; mRsmpInBuffer = new int16_t[mFrameCount * mChannelCount]; @@ -4170,7 +4208,7 @@ void AudioFlinger::RecordThread::readInputParameters() unsigned int AudioFlinger::RecordThread::getInputFramesLost() { - return mInput->getInputFramesLost(); + return mInput->get_input_frames_lost(mInput); } // ---------------------------------------------------------------------------- @@ -4189,6 +4227,7 @@ int AudioFlinger::openOutput(uint32_t *pDevices, uint32_t format = pFormat ? *pFormat : 0; uint32_t channels = pChannels ? *pChannels : 0; uint32_t latency = pLatencyMs ? *pLatencyMs : 0; + struct audio_stream_out *output; LOGV("openOutput(), Device %x, SamplingRate %d, Format %d, Channels %x, flags %x", pDevices ? *pDevices : 0, @@ -4202,11 +4241,11 @@ int AudioFlinger::openOutput(uint32_t *pDevices, } Mutex::Autolock _l(mLock); - AudioStreamOut *output = mAudioHardware->openOutputStream(*pDevices, - (int *)&format, - &channels, - &samplingRate, - &status); + status = mAudioHardwareDev->open_output_stream(mAudioHardwareDev, *pDevices, + (int *)&format, + &channels, + &samplingRate, + &output); LOGV("openOutput() openOutputStream returned output %p, SamplingRate %d, Format %d, Channels %x, status %d", output, samplingRate, @@ -4217,9 +4256,9 @@ int AudioFlinger::openOutput(uint32_t *pDevices, mHardwareStatus = AUDIO_HW_IDLE; if (output != 0) { int id = nextUniqueId_l(); - if ((flags & AudioSystem::OUTPUT_FLAG_DIRECT) || - (format != AudioSystem::PCM_16_BIT) || - (channels != AudioSystem::CHANNEL_OUT_STEREO)) { + if ((flags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT) || + (format != AUDIO_FORMAT_PCM_16_BIT) || + (channels != AUDIO_CHANNEL_OUT_STEREO)) { thread = new DirectOutputThread(this, output, id, *pDevices); LOGV("openOutput() created direct output: ID %d thread %p", id, thread); } else { @@ -4290,7 +4329,7 @@ status_t AudioFlinger::closeOutput(int output) thread->exit(); if (thread->type() != PlaybackThread::DUPLICATING) { - mAudioHardware->closeOutputStream(thread->getOutput()); + mAudioHardwareDev->close_output_stream(mAudioHardwareDev, thread->getOutput()); } return NO_ERROR; } @@ -4340,18 +4379,20 @@ int AudioFlinger::openInput(uint32_t *pDevices, uint32_t reqSamplingRate = samplingRate; uint32_t reqFormat = format; uint32_t reqChannels = channels; + struct audio_stream_in *input; if (pDevices == NULL || *pDevices == 0) { return 0; } Mutex::Autolock _l(mLock); - AudioStreamIn *input = mAudioHardware->openInputStream(*pDevices, - (int *)&format, - &channels, - &samplingRate, - &status, - (AudioSystem::audio_in_acoustics)acoustics); + status = mAudioHardwareDev->open_input_stream(mAudioHardwareDev, + *pDevices, + (int *)&format, + &channels, + &samplingRate, + (audio_in_acoustics_t)acoustics, + &input); LOGV("openInput() openInputStream returned input %p, SamplingRate %d, Format %d, Channels %x, acoustics %x, status %d", input, samplingRate, @@ -4364,16 +4405,17 @@ int AudioFlinger::openInput(uint32_t *pDevices, // try to open again with the proposed parameters. The AudioFlinger can resample the input and do mono to stereo // or stereo to mono conversions on 16 bit PCM inputs. if (input == 0 && status == BAD_VALUE && - reqFormat == format && format == AudioSystem::PCM_16_BIT && + reqFormat == format && format == AUDIO_FORMAT_PCM_16_BIT && (samplingRate <= 2 * reqSamplingRate) && - (AudioSystem::popCount(channels) < 3) && (AudioSystem::popCount(reqChannels) < 3)) { + (popcount(channels) < 3) && (popcount(reqChannels) < 3)) { LOGV("openInput() reopening with proposed sampling rate and channels"); - input = mAudioHardware->openInputStream(*pDevices, - (int *)&format, - &channels, - &samplingRate, - &status, - (AudioSystem::audio_in_acoustics)acoustics); + status = mAudioHardwareDev->open_input_stream(mAudioHardwareDev, + *pDevices, + (int *)&format, + &channels, + &samplingRate, + (audio_in_acoustics_t)acoustics, + &input); } if (input != 0) { @@ -4386,7 +4428,7 @@ int AudioFlinger::openInput(uint32_t *pDevices, if (pFormat) *pFormat = format; if (pChannels) *pChannels = reqChannels; - input->standby(); + input->common.standby(&input->common); // notify client processes of the new input creation thread->audioConfigChanged_l(AudioSystem::INPUT_OPENED); @@ -4415,7 +4457,7 @@ status_t AudioFlinger::closeInput(int input) } thread->exit(); - mAudioHardware->closeInputStream(thread->getInput()); + mAudioHardwareDev->close_input_stream(mAudioHardwareDev, thread->getInput()); return NO_ERROR; } @@ -4569,14 +4611,14 @@ sp<IEffect> AudioFlinger::createEffect(pid_t pid, } // check audio settings permission for global effects - if (sessionId == AudioSystem::SESSION_OUTPUT_MIX && !settingsAllowed()) { + if (sessionId == AUDIO_SESSION_OUTPUT_MIX && !settingsAllowed()) { lStatus = PERMISSION_DENIED; goto Exit; } - // Session AudioSystem::SESSION_OUTPUT_STAGE is reserved for output stage effects + // Session AUDIO_SESSION_OUTPUT_STAGE is reserved for output stage effects // that can only be created by audio policy manager (running in same process) - if (sessionId == AudioSystem::SESSION_OUTPUT_STAGE && getpid() != pid) { + if (sessionId == AUDIO_SESSION_OUTPUT_STAGE && getpid() != pid) { lStatus = PERMISSION_DENIED; goto Exit; } @@ -4590,12 +4632,12 @@ sp<IEffect> AudioFlinger::createEffect(pid_t pid, } if (output == 0) { - if (sessionId == AudioSystem::SESSION_OUTPUT_STAGE) { + if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) { // output must be specified by AudioPolicyManager when using session - // AudioSystem::SESSION_OUTPUT_STAGE + // AUDIO_SESSION_OUTPUT_STAGE lStatus = BAD_VALUE; goto Exit; - } else if (sessionId == AudioSystem::SESSION_OUTPUT_MIX) { + } else if (sessionId == AUDIO_SESSION_OUTPUT_MIX) { // if the output returned by getOutputForEffect() is removed before we lock the // mutex below, the call to checkPlaybackThread_l(output) below will detect it // and we will exit safely @@ -4643,7 +4685,7 @@ sp<IEffect> AudioFlinger::createEffect(pid_t pid, // an auxiliary version of this effect type is available found = true; memcpy(&d, &desc, sizeof(effect_descriptor_t)); - if (sessionId != AudioSystem::SESSION_OUTPUT_MIX || + if (sessionId != AUDIO_SESSION_OUTPUT_MIX || (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { break; } @@ -4656,14 +4698,14 @@ sp<IEffect> AudioFlinger::createEffect(pid_t pid, } // For same effect type, chose auxiliary version over insert version if // connect to output mix (Compliance to OpenSL ES) - if (sessionId == AudioSystem::SESSION_OUTPUT_MIX && + if (sessionId == AUDIO_SESSION_OUTPUT_MIX && (d.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) { memcpy(&desc, &d, sizeof(effect_descriptor_t)); } } // Do not allow auxiliary effects on a session different from 0 (output mix) - if (sessionId != AudioSystem::SESSION_OUTPUT_MIX && + if (sessionId != AUDIO_SESSION_OUTPUT_MIX && (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { lStatus = INVALID_OPERATION; goto Exit; @@ -4836,7 +4878,7 @@ sp<AudioFlinger::EffectHandle> AudioFlinger::PlaybackThread::createEffect_l( // Do not allow auxiliary effect on session other than 0 if ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY && - sessionId != AudioSystem::SESSION_OUTPUT_MIX) { + sessionId != AUDIO_SESSION_OUTPUT_MIX) { LOGW("createEffect_l() Cannot add auxiliary effect %s to session %d", desc->name, sessionId); lStatus = BAD_VALUE; @@ -4845,7 +4887,7 @@ sp<AudioFlinger::EffectHandle> AudioFlinger::PlaybackThread::createEffect_l( // Do not allow effects with session ID 0 on direct output or duplicating threads // TODO: add rule for hw accelerated effects on direct outputs with non PCM format - if (sessionId == AudioSystem::SESSION_OUTPUT_MIX && mType != MIXER) { + if (sessionId == AUDIO_SESSION_OUTPUT_MIX && mType != MIXER) { LOGW("createEffect_l() Cannot add auxiliary effect %s to session %d", desc->name, sessionId); lStatus = BAD_VALUE; @@ -5032,13 +5074,13 @@ status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& c chain->setInBuffer(buffer, ownsBuffer); chain->setOutBuffer(mMixBuffer); - // Effect chain for session AudioSystem::SESSION_OUTPUT_STAGE is inserted at end of effect + // Effect chain for session AUDIO_SESSION_OUTPUT_STAGE is inserted at end of effect // chains list in order to be processed last as it contains output stage effects - // Effect chain for session AudioSystem::SESSION_OUTPUT_MIX is inserted before - // session AudioSystem::SESSION_OUTPUT_STAGE to be processed + // Effect chain for session AUDIO_SESSION_OUTPUT_MIX is inserted before + // session AUDIO_SESSION_OUTPUT_STAGE to be processed // after track specific effects and before output stage - // It is therefore mandatory that AudioSystem::SESSION_OUTPUT_MIX == 0 and - // that AudioSystem::SESSION_OUTPUT_STAGE < AudioSystem::SESSION_OUTPUT_MIX + // It is therefore mandatory that AUDIO_SESSION_OUTPUT_MIX == 0 and + // that AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX // Effect chain for other sessions are inserted at beginning of effect // chains list to be processed before output mix effects. Relative order between other // sessions is not important @@ -5118,8 +5160,8 @@ status_t AudioFlinger::PlaybackThread::attachAuxEffect_l( if (EffectId == 0) { track->setAuxBuffer(0, NULL); } else { - // Auxiliary effects are always in audio session AudioSystem::SESSION_OUTPUT_MIX - sp<EffectModule> effect = getEffect_l(AudioSystem::SESSION_OUTPUT_MIX, EffectId); + // Auxiliary effects are always in audio session AUDIO_SESSION_OUTPUT_MIX + sp<EffectModule> effect = getEffect_l(AUDIO_SESSION_OUTPUT_MIX, EffectId); if (effect != 0) { if ((effect->desc().flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) { track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer()); @@ -5403,7 +5445,7 @@ status_t AudioFlinger::EffectModule::configure() mConfig.outputCfg.bufferProvider.releaseBuffer = NULL; mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ; // Insert effect: - // - in session AudioSystem::SESSION_OUTPUT_MIX or AudioSystem::SESSION_OUTPUT_STAGE, + // - in session AUDIO_SESSION_OUTPUT_MIX or AUDIO_SESSION_OUTPUT_STAGE, // always overwrites output buffer: input buffer == output buffer // - in other sessions: // last effect in the chain accumulates in output buffer: input buffer != output buffer @@ -5684,17 +5726,17 @@ status_t AudioFlinger::EffectModule::setMode(uint32_t mode) // update this table when AudioSystem::audio_devices or audio_device_e (in EffectApi.h) are modified const uint32_t AudioFlinger::EffectModule::sDeviceConvTable[] = { - DEVICE_EARPIECE, // AudioSystem::DEVICE_OUT_EARPIECE - DEVICE_SPEAKER, // AudioSystem::DEVICE_OUT_SPEAKER - DEVICE_WIRED_HEADSET, // case AudioSystem::DEVICE_OUT_WIRED_HEADSET - DEVICE_WIRED_HEADPHONE, // AudioSystem::DEVICE_OUT_WIRED_HEADPHONE - DEVICE_BLUETOOTH_SCO, // AudioSystem::DEVICE_OUT_BLUETOOTH_SCO - DEVICE_BLUETOOTH_SCO_HEADSET, // AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET - DEVICE_BLUETOOTH_SCO_CARKIT, // AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT - DEVICE_BLUETOOTH_A2DP, // AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP - DEVICE_BLUETOOTH_A2DP_HEADPHONES, // AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES - DEVICE_BLUETOOTH_A2DP_SPEAKER, // AudioSystem::DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER - DEVICE_AUX_DIGITAL // AudioSystem::DEVICE_OUT_AUX_DIGITAL + DEVICE_EARPIECE, // AUDIO_DEVICE_OUT_EARPIECE + DEVICE_SPEAKER, // AUDIO_DEVICE_OUT_SPEAKER + DEVICE_WIRED_HEADSET, // case AUDIO_DEVICE_OUT_WIRED_HEADSET + DEVICE_WIRED_HEADPHONE, // AUDIO_DEVICE_OUT_WIRED_HEADPHONE + DEVICE_BLUETOOTH_SCO, // AUDIO_DEVICE_OUT_BLUETOOTH_SCO + DEVICE_BLUETOOTH_SCO_HEADSET, // AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET + DEVICE_BLUETOOTH_SCO_CARKIT, // AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT + DEVICE_BLUETOOTH_A2DP, // AUDIO_DEVICE_OUT_BLUETOOTH_A2DP + DEVICE_BLUETOOTH_A2DP_HEADPHONES, // AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES + DEVICE_BLUETOOTH_A2DP_SPEAKER, // AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER + DEVICE_AUX_DIGITAL // AUDIO_DEVICE_OUT_AUX_DIGITAL }; uint32_t AudioFlinger::EffectModule::deviceAudioSystemToEffectApi(uint32_t device) @@ -5714,10 +5756,10 @@ uint32_t AudioFlinger::EffectModule::deviceAudioSystemToEffectApi(uint32_t devic // update this table when AudioSystem::audio_mode or audio_mode_e (in EffectApi.h) are modified const uint32_t AudioFlinger::EffectModule::sModeConvTable[] = { - AUDIO_MODE_NORMAL, // AudioSystem::MODE_NORMAL - AUDIO_MODE_RINGTONE, // AudioSystem::MODE_RINGTONE - AUDIO_MODE_IN_CALL, // AudioSystem::MODE_IN_CALL - AUDIO_MODE_IN_CALL // AudioSystem::MODE_IN_COMMUNICATION, same conversion as for MODE_IN_CALL + AUDIO_EFFECT_MODE_NORMAL, // AUDIO_MODE_NORMAL + AUDIO_EFFECT_MODE_RINGTONE, // AUDIO_MODE_RINGTONE + AUDIO_EFFECT_MODE_IN_CALL, // AUDIO_MODE_IN_CALL + AUDIO_EFFECT_MODE_IN_CALL // AUDIO_MODE_IN_COMMUNICATION, same conversion as for AUDIO_MODE_IN_CALL }; int AudioFlinger::EffectModule::modeAudioSystemToEffectApi(uint32_t mode) @@ -6027,7 +6069,7 @@ AudioFlinger::EffectChain::EffectChain(const wp<ThreadBase>& wThread, mVolumeCtrlIdx(-1), mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX), mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX) { - mStrategy = AudioSystem::getStrategyForStream(AudioSystem::MUSIC); + mStrategy = AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC); } AudioFlinger::EffectChain::~EffectChain() @@ -6078,8 +6120,8 @@ void AudioFlinger::EffectChain::process_l() return; } PlaybackThread *playbackThread = (PlaybackThread *)thread.get(); - bool isGlobalSession = (mSessionId == AudioSystem::SESSION_OUTPUT_MIX) || - (mSessionId == AudioSystem::SESSION_OUTPUT_STAGE); + bool isGlobalSession = (mSessionId == AUDIO_SESSION_OUTPUT_MIX) || + (mSessionId == AUDIO_SESSION_OUTPUT_STAGE); bool tracksOnSession = false; if (!isGlobalSession) { tracksOnSession = diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h index ec3d202..4ac1ee3 100644 --- a/services/audioflinger/AudioFlinger.h +++ b/services/audioflinger/AudioFlinger.h @@ -37,7 +37,7 @@ #include <binder/BinderService.h> #include <binder/MemoryDealer.h> -#include <hardware_legacy/AudioHardwareInterface.h> +#include <hardware/audio.h> #include "AudioBufferProvider.h" @@ -495,7 +495,7 @@ private: void reset(); bool isOutputTrack() const { - return (mStreamType == AudioSystem::NUM_STREAM_TYPES); + return (mStreamType == AUDIO_STREAM_CNT); } // we don't really need a lock for these @@ -554,7 +554,7 @@ private: DuplicatingThread* mSourceThread; }; // end of OutputTrack - PlaybackThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device); + PlaybackThread (const sp<AudioFlinger>& audioFlinger, struct audio_stream_out* output, int id, uint32_t device); virtual ~PlaybackThread(); virtual status_t dump(int fd, const Vector<String16>& args); @@ -588,7 +588,7 @@ private: int sessionId, status_t *status); - AudioStreamOut* getOutput() { return mOutput; } + struct audio_stream_out* getOutput() { return mOutput; } virtual int type() const { return mType; } void suspend() { mSuspended++; } @@ -689,8 +689,8 @@ private: SortedVector< sp<Track> > mTracks; // mStreamTypes[] uses 1 additionnal stream type internally for the OutputTrack used by DuplicatingThread - stream_type_t mStreamTypes[AudioSystem::NUM_STREAM_TYPES + 1]; - AudioStreamOut* mOutput; + stream_type_t mStreamTypes[AUDIO_STREAM_CNT + 1]; + struct audio_stream_out* mOutput; float mMasterVolume; nsecs_t mLastWriteTime; int mNumWrites; @@ -703,7 +703,7 @@ private: class MixerThread : public PlaybackThread { public: MixerThread (const sp<AudioFlinger>& audioFlinger, - AudioStreamOut* output, + struct audio_stream_out* output, int id, uint32_t device); virtual ~MixerThread(); @@ -730,7 +730,7 @@ private: class DirectOutputThread : public PlaybackThread { public: - DirectOutputThread (const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device); + DirectOutputThread (const sp<AudioFlinger>& audioFlinger, struct audio_stream_out* output, int id, uint32_t device); ~DirectOutputThread(); // Thread virtuals @@ -854,7 +854,7 @@ private: RecordThread(const sp<AudioFlinger>& audioFlinger, - AudioStreamIn *input, + struct audio_stream_in *input, uint32_t sampleRate, uint32_t channels, int id); @@ -867,7 +867,7 @@ private: status_t start(RecordTrack* recordTrack); void stop(RecordTrack* recordTrack); status_t dump(int fd, const Vector<String16>& args); - AudioStreamIn* getInput() { return mInput; } + struct audio_stream_in* getInput() { return mInput; } virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer); virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer); @@ -879,7 +879,7 @@ private: private: RecordThread(); - AudioStreamIn *mInput; + struct audio_stream_in *mInput; sp<RecordTrack> mActiveTrack; Condition mStartStopCond; AudioResampler *mResampler; @@ -1168,12 +1168,13 @@ private: DefaultKeyedVector< pid_t, wp<Client> > mClients; mutable Mutex mHardwareLock; - AudioHardwareInterface* mAudioHardware; + struct audio_hw_device* mAudioHardwareDev; + Vector<struct audio_hw_device *> mAudioHwDevs; mutable int mHardwareStatus; DefaultKeyedVector< int, sp<PlaybackThread> > mPlaybackThreads; - PlaybackThread::stream_type_t mStreamTypes[AudioSystem::NUM_STREAM_TYPES]; + PlaybackThread::stream_type_t mStreamTypes[AUDIO_STREAM_CNT]; float mMasterVolume; bool mMasterMute; diff --git a/services/audioflinger/AudioPolicyService.cpp b/services/audioflinger/AudioPolicyService.cpp index b614c48..eebc1b3 100644 --- a/services/audioflinger/AudioPolicyService.cpp +++ b/services/audioflinger/AudioPolicyService.cpp @@ -30,11 +30,15 @@ #include <utils/String16.h> #include <utils/threads.h> #include "AudioPolicyService.h" -#include <hardware_legacy/AudioPolicyManagerBase.h> #include <cutils/properties.h> #include <dlfcn.h> #include <hardware_legacy/power.h> +#include <hardware/hardware.h> +#include <hardware/audio.h> +#include <hardware/audio_policy.h> +#include <hardware/audio_policy_hal.h> + // ---------------------------------------------------------------------------- // the sim build doesn't have gettid @@ -44,7 +48,6 @@ namespace android { - static const char *kDeadlockedString = "AudioPolicyService may be deadlocked\n"; static const char *kCmdDeadlockedString = "AudioPolicyService command thread may be deadlocked\n"; @@ -61,12 +64,19 @@ static bool checkPermission() { return ok; } +namespace { + extern struct audio_policy_service_ops aps_ops; +}; + // ---------------------------------------------------------------------------- AudioPolicyService::AudioPolicyService() - : BnAudioPolicyService() , mpPolicyManager(NULL) + : BnAudioPolicyService() , mpAudioPolicyDev(NULL) , mpAudioPolicy(NULL) { char value[PROPERTY_VALUE_MAX]; + const struct hw_module_t *module; + int forced_val; + int rc; Mutex::Autolock _l(mLock); @@ -75,33 +85,32 @@ AudioPolicyService::AudioPolicyService() // start audio commands thread mAudioCommandThread = new AudioCommandThread(String8("ApmCommandThread")); -#if (defined GENERIC_AUDIO) || (defined AUDIO_POLICY_TEST) - mpPolicyManager = new AudioPolicyManagerBase(this); - LOGV("build for GENERIC_AUDIO - using generic audio policy"); -#else - // if running in emulation - use the emulator driver - if (property_get("ro.kernel.qemu", value, 0)) { - LOGV("Running in emulation - using generic audio policy"); - mpPolicyManager = new AudioPolicyManagerBase(this); - } - else { - LOGV("Using hardware specific audio policy"); - mpPolicyManager = createAudioPolicyManager(this); - } -#endif + /* instantiate the audio policy manager */ + rc = hw_get_module(AUDIO_POLICY_HARDWARE_MODULE_ID, &module); + if (rc) + return; - if ((mpPolicyManager != NULL) && (mpPolicyManager->initCheck() != NO_ERROR)) { - delete mpPolicyManager; - mpPolicyManager = NULL; - } + rc = audio_policy_dev_open(module, &mpAudioPolicyDev); + LOGE_IF(rc, "couldn't open audio policy device (%s)", strerror(-rc)); + if (rc) + return; - if (mpPolicyManager == NULL) { - LOGE("Could not create AudioPolicyManager"); - } else { - // load properties - property_get("ro.camera.sound.forced", value, "0"); - mpPolicyManager->setSystemProperty("ro.camera.sound.forced", value); - } + rc = mpAudioPolicyDev->create_audio_policy(mpAudioPolicyDev, &aps_ops, this, + &mpAudioPolicy); + LOGE_IF(rc, "couldn't create audio policy (%s)", strerror(-rc)); + if (rc) + return; + + rc = mpAudioPolicy->init_check(mpAudioPolicy); + LOGE_IF(rc, "couldn't init_check the audio policy (%s)", strerror(-rc)); + if (rc) + return; + + property_get("ro.camera.sound.forced", value, "0"); + forced_val = strtol(value, NULL, 0); + mpAudioPolicy->set_can_mute_enforced_audible(mpAudioPolicy, !forced_val); + + LOGI("Loaded audio policy from %s (%s)", module->name, module->id); } AudioPolicyService::~AudioPolicyService() @@ -111,57 +120,59 @@ AudioPolicyService::~AudioPolicyService() mAudioCommandThread->exit(); mAudioCommandThread.clear(); - if (mpPolicyManager) { - delete mpPolicyManager; - } + if (mpAudioPolicy && mpAudioPolicyDev) + mpAudioPolicyDev->destroy_audio_policy(mpAudioPolicyDev, mpAudioPolicy); + if (mpAudioPolicyDev) + audio_policy_dev_close(mpAudioPolicyDev); } - -status_t AudioPolicyService::setDeviceConnectionState(AudioSystem::audio_devices device, - AudioSystem::device_connection_state state, +status_t AudioPolicyService::setDeviceConnectionState(audio_devices_t device, + audio_policy_dev_state_t state, const char *device_address) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } if (!checkPermission()) { return PERMISSION_DENIED; } - if (!AudioSystem::isOutputDevice(device) && !AudioSystem::isInputDevice(device)) { + if (!audio_is_output_device(device) && !audio_is_input_device(device)) { return BAD_VALUE; } - if (state != AudioSystem::DEVICE_STATE_AVAILABLE && - state != AudioSystem::DEVICE_STATE_UNAVAILABLE) { + if (state != AUDIO_POLICY_DEVICE_STATE_AVAILABLE && + state != AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE) { return BAD_VALUE; } LOGV("setDeviceConnectionState() tid %d", gettid()); Mutex::Autolock _l(mLock); - return mpPolicyManager->setDeviceConnectionState(device, state, device_address); + return mpAudioPolicy->set_device_connection_state(mpAudioPolicy, device, + state, device_address); } -AudioSystem::device_connection_state AudioPolicyService::getDeviceConnectionState( - AudioSystem::audio_devices device, +audio_policy_dev_state_t AudioPolicyService::getDeviceConnectionState( + audio_devices_t device, const char *device_address) { - if (mpPolicyManager == NULL) { - return AudioSystem::DEVICE_STATE_UNAVAILABLE; + if (mpAudioPolicy == NULL) { + return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE; } if (!checkPermission()) { - return AudioSystem::DEVICE_STATE_UNAVAILABLE; + return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE; } - return mpPolicyManager->getDeviceConnectionState(device, device_address); + return mpAudioPolicy->get_device_connection_state(mpAudioPolicy, device, + device_address); } status_t AudioPolicyService::setPhoneState(int state) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } if (!checkPermission()) { return PERMISSION_DENIED; } - if (state < 0 || state >= AudioSystem::NUM_MODES) { + if (state < 0 || state >= AUDIO_MODE_CNT) { return BAD_VALUE; } @@ -171,215 +182,215 @@ status_t AudioPolicyService::setPhoneState(int state) AudioSystem::setMode(state); Mutex::Autolock _l(mLock); - mpPolicyManager->setPhoneState(state); + mpAudioPolicy->set_phone_state(mpAudioPolicy, state); return NO_ERROR; } status_t AudioPolicyService::setRingerMode(uint32_t mode, uint32_t mask) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } if (!checkPermission()) { return PERMISSION_DENIED; } - mpPolicyManager->setRingerMode(mode, mask); + mpAudioPolicy->set_ringer_mode(mpAudioPolicy, mode, mask); return NO_ERROR; } -status_t AudioPolicyService::setForceUse(AudioSystem::force_use usage, - AudioSystem::forced_config config) +status_t AudioPolicyService::setForceUse(audio_policy_force_use_t usage, + audio_policy_forced_cfg_t config) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } if (!checkPermission()) { return PERMISSION_DENIED; } - if (usage < 0 || usage >= AudioSystem::NUM_FORCE_USE) { + if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) { return BAD_VALUE; } - if (config < 0 || config >= AudioSystem::NUM_FORCE_CONFIG) { + if (config < 0 || config >= AUDIO_POLICY_FORCE_CFG_CNT) { return BAD_VALUE; } LOGV("setForceUse() tid %d", gettid()); Mutex::Autolock _l(mLock); - mpPolicyManager->setForceUse(usage, config); + mpAudioPolicy->set_force_use(mpAudioPolicy, usage, config); return NO_ERROR; } -AudioSystem::forced_config AudioPolicyService::getForceUse(AudioSystem::force_use usage) +audio_policy_forced_cfg_t AudioPolicyService::getForceUse(audio_policy_force_use_t usage) { - if (mpPolicyManager == NULL) { - return AudioSystem::FORCE_NONE; + if (mpAudioPolicy == NULL) { + return AUDIO_POLICY_FORCE_NONE; } if (!checkPermission()) { - return AudioSystem::FORCE_NONE; + return AUDIO_POLICY_FORCE_NONE; } - if (usage < 0 || usage >= AudioSystem::NUM_FORCE_USE) { - return AudioSystem::FORCE_NONE; + if (usage < 0 || usage >= AUDIO_POLICY_FORCE_USE_CNT) { + return AUDIO_POLICY_FORCE_NONE; } - return mpPolicyManager->getForceUse(usage); + return mpAudioPolicy->get_force_use(mpAudioPolicy, usage); } -audio_io_handle_t AudioPolicyService::getOutput(AudioSystem::stream_type stream, +audio_io_handle_t AudioPolicyService::getOutput(audio_stream_type_t stream, uint32_t samplingRate, uint32_t format, uint32_t channels, - AudioSystem::output_flags flags) + audio_policy_output_flags_t flags) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return 0; } LOGV("getOutput() tid %d", gettid()); Mutex::Autolock _l(mLock); - return mpPolicyManager->getOutput(stream, samplingRate, format, channels, flags); + return mpAudioPolicy->get_output(mpAudioPolicy, stream, samplingRate, format, channels, flags); } status_t AudioPolicyService::startOutput(audio_io_handle_t output, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } LOGV("startOutput() tid %d", gettid()); Mutex::Autolock _l(mLock); - return mpPolicyManager->startOutput(output, stream, session); + return mpAudioPolicy->start_output(mpAudioPolicy, output, stream, session); } status_t AudioPolicyService::stopOutput(audio_io_handle_t output, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } LOGV("stopOutput() tid %d", gettid()); Mutex::Autolock _l(mLock); - return mpPolicyManager->stopOutput(output, stream, session); + return mpAudioPolicy->stop_output(mpAudioPolicy, output, stream, session); } void AudioPolicyService::releaseOutput(audio_io_handle_t output) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return; } LOGV("releaseOutput() tid %d", gettid()); Mutex::Autolock _l(mLock); - mpPolicyManager->releaseOutput(output); + mpAudioPolicy->release_output(mpAudioPolicy, output); } audio_io_handle_t AudioPolicyService::getInput(int inputSource, uint32_t samplingRate, uint32_t format, uint32_t channels, - AudioSystem::audio_in_acoustics acoustics) + audio_in_acoustics_t acoustics) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return 0; } Mutex::Autolock _l(mLock); - return mpPolicyManager->getInput(inputSource, samplingRate, format, channels, acoustics); + return mpAudioPolicy->get_input(mpAudioPolicy, inputSource, samplingRate, format, channels, acoustics); } status_t AudioPolicyService::startInput(audio_io_handle_t input) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } Mutex::Autolock _l(mLock); - return mpPolicyManager->startInput(input); + return mpAudioPolicy->start_input(mpAudioPolicy, input); } status_t AudioPolicyService::stopInput(audio_io_handle_t input) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } Mutex::Autolock _l(mLock); - return mpPolicyManager->stopInput(input); + return mpAudioPolicy->stop_input(mpAudioPolicy, input); } void AudioPolicyService::releaseInput(audio_io_handle_t input) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return; } Mutex::Autolock _l(mLock); - mpPolicyManager->releaseInput(input); + mpAudioPolicy->release_input(mpAudioPolicy, input); } -status_t AudioPolicyService::initStreamVolume(AudioSystem::stream_type stream, +status_t AudioPolicyService::initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } if (!checkPermission()) { return PERMISSION_DENIED; } - if (stream < 0 || stream >= AudioSystem::NUM_STREAM_TYPES) { + if (stream < 0 || stream >= AUDIO_STREAM_CNT) { return BAD_VALUE; } - mpPolicyManager->initStreamVolume(stream, indexMin, indexMax); + mpAudioPolicy->init_stream_volume(mpAudioPolicy, stream, indexMin, indexMax); return NO_ERROR; } -status_t AudioPolicyService::setStreamVolumeIndex(AudioSystem::stream_type stream, int index) +status_t AudioPolicyService::setStreamVolumeIndex(audio_stream_type_t stream, int index) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } if (!checkPermission()) { return PERMISSION_DENIED; } - if (stream < 0 || stream >= AudioSystem::NUM_STREAM_TYPES) { + if (stream < 0 || stream >= AUDIO_STREAM_CNT) { return BAD_VALUE; } - return mpPolicyManager->setStreamVolumeIndex(stream, index); + return mpAudioPolicy->set_stream_volume_index(mpAudioPolicy, stream, index); } -status_t AudioPolicyService::getStreamVolumeIndex(AudioSystem::stream_type stream, int *index) +status_t AudioPolicyService::getStreamVolumeIndex(audio_stream_type_t stream, int *index) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } if (!checkPermission()) { return PERMISSION_DENIED; } - if (stream < 0 || stream >= AudioSystem::NUM_STREAM_TYPES) { + if (stream < 0 || stream >= AUDIO_STREAM_CNT) { return BAD_VALUE; } - return mpPolicyManager->getStreamVolumeIndex(stream, index); + return mpAudioPolicy->get_stream_volume_index(mpAudioPolicy, stream, index); } -uint32_t AudioPolicyService::getStrategyForStream(AudioSystem::stream_type stream) +uint32_t AudioPolicyService::getStrategyForStream(audio_stream_type_t stream) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return 0; } - return mpPolicyManager->getStrategyForStream(stream); + return mpAudioPolicy->get_strategy_for_stream(mpAudioPolicy, stream); } -uint32_t AudioPolicyService::getDevicesForStream(AudioSystem::stream_type stream) +uint32_t AudioPolicyService::getDevicesForStream(audio_stream_type_t stream) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return 0; } - return mpPolicyManager->getDevicesForStream(stream); + return mpAudioPolicy->get_devices_for_stream(mpAudioPolicy, stream); } audio_io_handle_t AudioPolicyService::getOutputForEffect(effect_descriptor_t *desc) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } Mutex::Autolock _l(mLock); - return mpPolicyManager->getOutputForEffect(desc); + return mpAudioPolicy->get_output_for_effect(mpAudioPolicy, desc); } status_t AudioPolicyService::registerEffect(effect_descriptor_t *desc, @@ -388,27 +399,27 @@ status_t AudioPolicyService::registerEffect(effect_descriptor_t *desc, int session, int id) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } - return mpPolicyManager->registerEffect(desc, output, strategy, session, id); + return mpAudioPolicy->register_effect(mpAudioPolicy, desc, output, strategy, session, id); } status_t AudioPolicyService::unregisterEffect(int id) { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return NO_INIT; } - return mpPolicyManager->unregisterEffect(id); + return mpAudioPolicy->unregister_effect(mpAudioPolicy, id); } bool AudioPolicyService::isStreamActive(int stream, uint32_t inPastMs) const { - if (mpPolicyManager == NULL) { + if (mpAudioPolicy == NULL) { return 0; } Mutex::Autolock _l(mLock); - return mpPolicyManager->isStreamActive(stream, inPastMs); + return mpAudioPolicy->is_stream_active(mpAudioPolicy, stream, inPastMs); } void AudioPolicyService::binderDied(const wp<IBinder>& who) { @@ -435,7 +446,7 @@ status_t AudioPolicyService::dumpInternals(int fd) char buffer[SIZE]; String8 result; - snprintf(buffer, SIZE, "PolicyManager Interface: %p\n", mpPolicyManager); + snprintf(buffer, SIZE, "PolicyManager Interface: %p\n", mpAudioPolicy); result.append(buffer); snprintf(buffer, SIZE, "Command Thread: %p\n", mAudioCommandThread.get()); result.append(buffer); @@ -465,8 +476,8 @@ status_t AudioPolicyService::dump(int fd, const Vector<String16>& args) mTonePlaybackThread->dump(fd); } - if (mpPolicyManager) { - mpPolicyManager->dump(fd); + if (mpAudioPolicy) { + mpAudioPolicy->dump(mpAudioPolicy, fd); } if (locked) mLock.unlock(); @@ -495,154 +506,6 @@ status_t AudioPolicyService::onTransact( } -// ---------------------------------------------------------------------------- -// AudioPolicyClientInterface implementation -// ---------------------------------------------------------------------------- - - -audio_io_handle_t AudioPolicyService::openOutput(uint32_t *pDevices, - uint32_t *pSamplingRate, - uint32_t *pFormat, - uint32_t *pChannels, - uint32_t *pLatencyMs, - AudioSystem::output_flags flags) -{ - sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); - if (af == 0) { - LOGW("openOutput() could not get AudioFlinger"); - return 0; - } - - return af->openOutput(pDevices, - pSamplingRate, - (uint32_t *)pFormat, - pChannels, - pLatencyMs, - flags); -} - -audio_io_handle_t AudioPolicyService::openDuplicateOutput(audio_io_handle_t output1, - audio_io_handle_t output2) -{ - sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); - if (af == 0) { - LOGW("openDuplicateOutput() could not get AudioFlinger"); - return 0; - } - return af->openDuplicateOutput(output1, output2); -} - -status_t AudioPolicyService::closeOutput(audio_io_handle_t output) -{ - sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); - if (af == 0) return PERMISSION_DENIED; - - return af->closeOutput(output); -} - - -status_t AudioPolicyService::suspendOutput(audio_io_handle_t output) -{ - sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); - if (af == 0) { - LOGW("suspendOutput() could not get AudioFlinger"); - return PERMISSION_DENIED; - } - - return af->suspendOutput(output); -} - -status_t AudioPolicyService::restoreOutput(audio_io_handle_t output) -{ - sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); - if (af == 0) { - LOGW("restoreOutput() could not get AudioFlinger"); - return PERMISSION_DENIED; - } - - return af->restoreOutput(output); -} - -audio_io_handle_t AudioPolicyService::openInput(uint32_t *pDevices, - uint32_t *pSamplingRate, - uint32_t *pFormat, - uint32_t *pChannels, - uint32_t acoustics) -{ - sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); - if (af == 0) { - LOGW("openInput() could not get AudioFlinger"); - return 0; - } - - return af->openInput(pDevices, pSamplingRate, (uint32_t *)pFormat, pChannels, acoustics); -} - -status_t AudioPolicyService::closeInput(audio_io_handle_t input) -{ - sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); - if (af == 0) return PERMISSION_DENIED; - - return af->closeInput(input); -} - -status_t AudioPolicyService::setStreamVolume(AudioSystem::stream_type stream, - float volume, - audio_io_handle_t output, - int delayMs) -{ - return mAudioCommandThread->volumeCommand((int)stream, volume, (int)output, delayMs); -} - -status_t AudioPolicyService::setStreamOutput(AudioSystem::stream_type stream, - audio_io_handle_t output) -{ - sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); - if (af == 0) return PERMISSION_DENIED; - - return af->setStreamOutput(stream, output); -} - -status_t AudioPolicyService::moveEffects(int session, audio_io_handle_t srcOutput, - audio_io_handle_t dstOutput) -{ - sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); - if (af == 0) return PERMISSION_DENIED; - - return af->moveEffects(session, (int)srcOutput, (int)dstOutput); -} - -void AudioPolicyService::setParameters(audio_io_handle_t ioHandle, - const String8& keyValuePairs, - int delayMs) -{ - mAudioCommandThread->parametersCommand((int)ioHandle, keyValuePairs, delayMs); -} - -String8 AudioPolicyService::getParameters(audio_io_handle_t ioHandle, const String8& keys) -{ - String8 result = AudioSystem::getParameters(ioHandle, keys); - return result; -} - -status_t AudioPolicyService::startTone(ToneGenerator::tone_type tone, - AudioSystem::stream_type stream) -{ - mTonePlaybackThread->startToneCommand(tone, stream); - return NO_ERROR; -} - -status_t AudioPolicyService::stopTone() -{ - mTonePlaybackThread->stopToneCommand(); - return NO_ERROR; -} - -status_t AudioPolicyService::setVoiceVolume(float volume, int delayMs) -{ - return mAudioCommandThread->voiceVolumeCommand(volume, delayMs); -} - // ----------- AudioPolicyService::AudioCommandThread implementation ---------- AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name) @@ -859,7 +722,7 @@ status_t AudioPolicyService::AudioCommandThread::volumeCommand(int stream, } status_t AudioPolicyService::AudioCommandThread::parametersCommand(int ioHandle, - const String8& keyValuePairs, + const char *keyValuePairs, int delayMs) { status_t status = NO_ERROR; @@ -868,7 +731,7 @@ status_t AudioPolicyService::AudioCommandThread::parametersCommand(int ioHandle, command->mCommand = SET_PARAMETERS; ParametersData *data = new ParametersData(); data->mIO = ioHandle; - data->mKeyValuePairs = keyValuePairs; + data->mKeyValuePairs = String8(keyValuePairs); command->mParam = data; if (delayMs == 0) { command->mWaitStatus = true; @@ -878,7 +741,7 @@ status_t AudioPolicyService::AudioCommandThread::parametersCommand(int ioHandle, Mutex::Autolock _l(mLock); insertCommand_l(command, delayMs); LOGV("AudioCommandThread() adding set parameter string %s, io %d ,delay %d", - keyValuePairs.string(), ioHandle, delayMs); + keyValuePairs, ioHandle, delayMs); mWaitWorkCV.signal(); if (command->mWaitStatus) { command->mCond.wait(mLock); @@ -1023,4 +886,226 @@ void AudioPolicyService::AudioCommandThread::AudioCommand::dump(char* buffer, si mParam); } +/******* helpers for the service_ops callbacks defined below *********/ +void AudioPolicyService::setParameters(audio_io_handle_t ioHandle, + const char *keyValuePairs, + int delayMs) +{ + mAudioCommandThread->parametersCommand((int)ioHandle, keyValuePairs, + delayMs); +} + +int AudioPolicyService::setStreamVolume(audio_stream_type_t stream, + float volume, + audio_io_handle_t output, + int delayMs) +{ + return (int)mAudioCommandThread->volumeCommand((int)stream, volume, + (int)output, delayMs); +} + +int AudioPolicyService::startTone(audio_policy_tone_t tone, + audio_stream_type_t stream) +{ + if (tone != AUDIO_POLICY_TONE_IN_CALL_NOTIFICATION) + LOGE("startTone: illegal tone requested (%d)", tone); + if (stream != AUDIO_STREAM_VOICE_CALL) + LOGE("startTone: illegal stream (%d) requested for tone %d", stream, + tone); + mTonePlaybackThread->startToneCommand(ToneGenerator::TONE_SUP_CALL_WAITING, + AUDIO_STREAM_VOICE_CALL); + return 0; +} + +int AudioPolicyService::stopTone() +{ + mTonePlaybackThread->stopToneCommand(); + return 0; +} + +int AudioPolicyService::setVoiceVolume(float volume, int delayMs) +{ + return (int)mAudioCommandThread->voiceVolumeCommand(volume, delayMs); +} + +/* implementation of the interface to the policy manager */ +extern "C" { + +static audio_io_handle_t aps_open_output(void *service, + uint32_t *pDevices, + uint32_t *pSamplingRate, + uint32_t *pFormat, + uint32_t *pChannels, + uint32_t *pLatencyMs, + audio_policy_output_flags_t flags) +{ + sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); + if (af == NULL) { + LOGW("%s: could not get AudioFlinger", __func__); + return 0; + } + + return af->openOutput(pDevices, pSamplingRate, pFormat, pChannels, + pLatencyMs, flags); +} + +static audio_io_handle_t aps_open_dup_output(void *service, + audio_io_handle_t output1, + audio_io_handle_t output2) +{ + sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); + if (af == NULL) { + LOGW("%s: could not get AudioFlinger", __func__); + return 0; + } + return af->openDuplicateOutput(output1, output2); +} + +static int aps_close_output(void *service, audio_io_handle_t output) +{ + sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); + if (af == NULL) + return PERMISSION_DENIED; + + return af->closeOutput(output); +} + +static int aps_suspend_output(void *service, audio_io_handle_t output) +{ + sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); + if (af == NULL) { + LOGW("%s: could not get AudioFlinger", __func__); + return PERMISSION_DENIED; + } + + return af->suspendOutput(output); +} + +static int aps_restore_output(void *service, audio_io_handle_t output) +{ + sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); + if (af == NULL) { + LOGW("%s: could not get AudioFlinger", __func__); + return PERMISSION_DENIED; + } + + return af->restoreOutput(output); +} + +static audio_io_handle_t aps_open_input(void *service, + uint32_t *pDevices, + uint32_t *pSamplingRate, + uint32_t *pFormat, + uint32_t *pChannels, + uint32_t acoustics) +{ + sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); + if (af == NULL) { + LOGW("%s: could not get AudioFlinger", __func__); + return 0; + } + + return af->openInput(pDevices, pSamplingRate, pFormat, pChannels, + acoustics); +} + +static int aps_close_input(void *service, audio_io_handle_t input) +{ + sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); + if (af == NULL) + return PERMISSION_DENIED; + + return af->closeInput(input); +} + +static int aps_set_stream_output(void *service, audio_stream_type_t stream, + audio_io_handle_t output) +{ + sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); + if (af == NULL) + return PERMISSION_DENIED; + + return af->setStreamOutput(stream, output); +} + +static int aps_move_effects(void *service, int session, + audio_io_handle_t src_output, + audio_io_handle_t dst_output) +{ + sp<IAudioFlinger> af = AudioSystem::get_audio_flinger(); + if (af == NULL) + return PERMISSION_DENIED; + + return af->moveEffects(session, (int)src_output, (int)dst_output); +} + +static char * aps_get_parameters(void *service, audio_io_handle_t io_handle, + const char *keys) +{ + String8 result = AudioSystem::getParameters(io_handle, String8(keys)); + return strdup(result.string()); +} + +static void aps_set_parameters(void *service, audio_io_handle_t io_handle, + const char *kv_pairs, int delay_ms) +{ + AudioPolicyService *audioPolicyService = (AudioPolicyService *)service; + + audioPolicyService->setParameters(io_handle, kv_pairs, delay_ms); +} + +static int aps_set_stream_volume(void *service, audio_stream_type_t stream, + float volume, audio_io_handle_t output, + int delay_ms) +{ + AudioPolicyService *audioPolicyService = (AudioPolicyService *)service; + + return audioPolicyService->setStreamVolume(stream, volume, output, + delay_ms); +} + +static int aps_start_tone(void *service, audio_policy_tone_t tone, + audio_stream_type_t stream) +{ + AudioPolicyService *audioPolicyService = (AudioPolicyService *)service; + + return audioPolicyService->startTone(tone, stream); +} + +static int aps_stop_tone(void *service) +{ + AudioPolicyService *audioPolicyService = (AudioPolicyService *)service; + + return audioPolicyService->stopTone(); +} + +static int aps_set_voice_volume(void *service, float volume, int delay_ms) +{ + AudioPolicyService *audioPolicyService = (AudioPolicyService *)service; + + return audioPolicyService->setVoiceVolume(volume, delay_ms); +} + +}; // extern "C" + +namespace { + struct audio_policy_service_ops aps_ops = { + open_output : aps_open_output, + open_duplicate_output : aps_open_dup_output, + close_output : aps_close_output, + suspend_output : aps_suspend_output, + restore_output : aps_restore_output, + open_input : aps_open_input, + close_input : aps_close_input, + set_stream_volume : aps_set_stream_volume, + set_stream_output : aps_set_stream_output, + set_parameters : aps_set_parameters, + get_parameters : aps_get_parameters, + start_tone : aps_start_tone, + stop_tone : aps_stop_tone, + set_voice_volume : aps_set_voice_volume, + move_effects : aps_move_effects, + }; +}; // namespace <unnamed> + }; // namespace android diff --git a/services/audioflinger/AudioPolicyService.h b/services/audioflinger/AudioPolicyService.h index faad893..01e592b 100644 --- a/services/audioflinger/AudioPolicyService.h +++ b/services/audioflinger/AudioPolicyService.h @@ -18,11 +18,14 @@ #define ANDROID_AUDIOPOLICYSERVICE_H #include <media/IAudioPolicyService.h> -#include <hardware_legacy/AudioPolicyInterface.h> #include <media/ToneGenerator.h> #include <utils/Vector.h> #include <binder/BinderService.h> +#include <hardware/audio.h> +#include <hardware/audio_policy.h> +#include <hardware/audio_policy_hal.h> + namespace android { class String8; @@ -32,7 +35,7 @@ class String8; class AudioPolicyService : public BinderService<AudioPolicyService>, public BnAudioPolicyService, - public AudioPolicyClientInterface, +// public AudioPolicyClientInterface, public IBinder::DeathRecipient { friend class BinderService<AudioPolicyService>; @@ -47,46 +50,46 @@ public: // BnAudioPolicyService (see AudioPolicyInterface for method descriptions) // - virtual status_t setDeviceConnectionState(AudioSystem::audio_devices device, - AudioSystem::device_connection_state state, + virtual status_t setDeviceConnectionState(audio_devices_t device, + audio_policy_dev_state_t state, const char *device_address); - virtual AudioSystem::device_connection_state getDeviceConnectionState( - AudioSystem::audio_devices device, + virtual audio_policy_dev_state_t getDeviceConnectionState( + audio_devices_t device, const char *device_address); virtual status_t setPhoneState(int state); virtual status_t setRingerMode(uint32_t mode, uint32_t mask); - virtual status_t setForceUse(AudioSystem::force_use usage, AudioSystem::forced_config config); - virtual AudioSystem::forced_config getForceUse(AudioSystem::force_use usage); - virtual audio_io_handle_t getOutput(AudioSystem::stream_type stream, + virtual status_t setForceUse(audio_policy_force_use_t usage, audio_policy_forced_cfg_t config); + virtual audio_policy_forced_cfg_t getForceUse(audio_policy_force_use_t usage); + virtual audio_io_handle_t getOutput(audio_stream_type_t stream, uint32_t samplingRate = 0, - uint32_t format = AudioSystem::FORMAT_DEFAULT, + uint32_t format = AUDIO_FORMAT_DEFAULT, uint32_t channels = 0, - AudioSystem::output_flags flags = - AudioSystem::OUTPUT_FLAG_INDIRECT); + audio_policy_output_flags_t flags = + AUDIO_POLICY_OUTPUT_FLAG_INDIRECT); virtual status_t startOutput(audio_io_handle_t output, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session = 0); virtual status_t stopOutput(audio_io_handle_t output, - AudioSystem::stream_type stream, + audio_stream_type_t stream, int session = 0); virtual void releaseOutput(audio_io_handle_t output); virtual audio_io_handle_t getInput(int inputSource, uint32_t samplingRate = 0, - uint32_t format = AudioSystem::FORMAT_DEFAULT, + uint32_t format = AUDIO_FORMAT_DEFAULT, uint32_t channels = 0, - AudioSystem::audio_in_acoustics acoustics = - (AudioSystem::audio_in_acoustics)0); + audio_in_acoustics_t acoustics = + (audio_in_acoustics_t)0); virtual status_t startInput(audio_io_handle_t input); virtual status_t stopInput(audio_io_handle_t input); virtual void releaseInput(audio_io_handle_t input); - virtual status_t initStreamVolume(AudioSystem::stream_type stream, + virtual status_t initStreamVolume(audio_stream_type_t stream, int indexMin, int indexMax); - virtual status_t setStreamVolumeIndex(AudioSystem::stream_type stream, int index); - virtual status_t getStreamVolumeIndex(AudioSystem::stream_type stream, int *index); + virtual status_t setStreamVolumeIndex(audio_stream_type_t stream, int index); + virtual status_t getStreamVolumeIndex(audio_stream_type_t stream, int *index); - virtual uint32_t getStrategyForStream(AudioSystem::stream_type stream); - virtual uint32_t getDevicesForStream(AudioSystem::stream_type stream); + virtual uint32_t getStrategyForStream(audio_stream_type_t stream); + virtual uint32_t getDevicesForStream(audio_stream_type_t stream); virtual audio_io_handle_t getOutputForEffect(effect_descriptor_t *desc); virtual status_t registerEffect(effect_descriptor_t *desc, @@ -107,40 +110,21 @@ public: virtual void binderDied(const wp<IBinder>& who); // - // AudioPolicyClientInterface + // Helpers for the struct audio_policy_service_ops implementation. + // This is used by the audio policy manager for certain operations that + // are implemented by the policy service. // - virtual audio_io_handle_t openOutput(uint32_t *pDevices, - uint32_t *pSamplingRate, - uint32_t *pFormat, - uint32_t *pChannels, - uint32_t *pLatencyMs, - AudioSystem::output_flags flags); - virtual audio_io_handle_t openDuplicateOutput(audio_io_handle_t output1, - audio_io_handle_t output2); - virtual status_t closeOutput(audio_io_handle_t output); - virtual status_t suspendOutput(audio_io_handle_t output); - virtual status_t restoreOutput(audio_io_handle_t output); - virtual audio_io_handle_t openInput(uint32_t *pDevices, - uint32_t *pSamplingRate, - uint32_t *pFormat, - uint32_t *pChannels, - uint32_t acoustics); - virtual status_t closeInput(audio_io_handle_t input); - virtual status_t setStreamVolume(AudioSystem::stream_type stream, + virtual void setParameters(audio_io_handle_t ioHandle, + const char *keyValuePairs, + int delayMs); + + virtual status_t setStreamVolume(audio_stream_type_t stream, float volume, audio_io_handle_t output, int delayMs = 0); - virtual status_t setStreamOutput(AudioSystem::stream_type stream, audio_io_handle_t output); - virtual void setParameters(audio_io_handle_t ioHandle, - const String8& keyValuePairs, - int delayMs = 0); - virtual String8 getParameters(audio_io_handle_t ioHandle, const String8& keys); - virtual status_t startTone(ToneGenerator::tone_type tone, AudioSystem::stream_type stream); + virtual status_t startTone(audio_policy_tone_t tone, audio_stream_type_t stream); virtual status_t stopTone(); virtual status_t setVoiceVolume(float volume, int delayMs = 0); - virtual status_t moveEffects(int session, - audio_io_handle_t srcOutput, - audio_io_handle_t dstOutput); private: AudioPolicyService(); @@ -180,7 +164,7 @@ private: void startToneCommand(int type = 0, int stream = 0); void stopToneCommand(); status_t volumeCommand(int stream, float volume, int output, int delayMs = 0); - status_t parametersCommand(int ioHandle, const String8& keyValuePairs, int delayMs = 0); + status_t parametersCommand(int ioHandle, const char *keyValuePairs, int delayMs = 0); status_t voiceVolumeCommand(float volume, int delayMs = 0); void insertCommand_l(AudioCommand *command, int delayMs = 0); @@ -240,9 +224,11 @@ private: mutable Mutex mLock; // prevents concurrent access to AudioPolicy manager functions changing // device connection state or routing - AudioPolicyInterface* mpPolicyManager; // the platform specific policy manager sp <AudioCommandThread> mAudioCommandThread; // audio commands thread sp <AudioCommandThread> mTonePlaybackThread; // tone playback thread + + struct audio_policy_device *mpAudioPolicyDev; + struct audio_policy *mpAudioPolicy; }; }; // namespace android diff --git a/services/camera/libcameraservice/CameraService.cpp b/services/camera/libcameraservice/CameraService.cpp index 7e3c643..f4859ec 100644 --- a/services/camera/libcameraservice/CameraService.cpp +++ b/services/camera/libcameraservice/CameraService.cpp @@ -244,7 +244,7 @@ void CameraService::setCameraFree(int cameraId) { static MediaPlayer* newMediaPlayer(const char *file) { MediaPlayer* mp = new MediaPlayer(); if (mp->setDataSource(file, NULL) == NO_ERROR) { - mp->setAudioStreamType(AudioSystem::ENFORCED_AUDIBLE); + mp->setAudioStreamType(AUDIO_STREAM_ENFORCED_AUDIBLE); mp->prepare(); } else { LOGE("Failed to load CameraService sounds: %s", file); @@ -283,7 +283,7 @@ void CameraService::playSound(sound_kind kind) { // do not play the sound if stream volume is 0 // (typically because ringer mode is silent). int index; - AudioSystem::getStreamVolumeIndex(AudioSystem::ENFORCED_AUDIBLE, &index); + AudioSystem::getStreamVolumeIndex(AUDIO_STREAM_ENFORCED_AUDIBLE, &index); if (index != 0) { player->seekTo(0); player->start(); |