audio/media: convert to using the audio HAL and new audio defs

Change-Id: Ibc637918637329e4f2b62f4ac7781102fbc269f5
Signed-off-by: Dima Zavin <dima@android.com>

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();