Merge "u8500: add ST Ericsson audio configs" into ics

8 files changed, 313 insertions, 9 deletions

diff --git a/include/media/IAudioFlinger.h b/include/media/IAudioFlinger.h
index 6a9d4b03ea3..743a0de962a 100644
--- a/include/media/IAudioFlinger.h
+++ b/include/media/IAudioFlinger.h
@@ -151,13 +151,22 @@ public:
     virtual status_t suspendOutput(int output) = 0;
     virtual status_t restoreOutput(int output) = 0;
 
+#ifdef STE_AUDIO
+    virtual uint32_t *addInputClient(uint32_t clientId) = 0;
+    virtual status_t removeInputClient(uint32_t *pClientId) = 0;
+#endif
     virtual int openInput(uint32_t *pDevices,
                                     uint32_t *pSamplingRate,
                                     uint32_t *pFormat,
                                     uint32_t *pChannels,
+#ifdef STE_AUDIO
+                                    uint32_t acoustics,
+                                    uint32_t *pInputClientId = NULL) = 0;
+    virtual status_t closeInput(int input, uint32_t* inputClientId = NULL) = 0;
+#else
                                     uint32_t acoustics) = 0;
     virtual status_t closeInput(int input) = 0;
-
+#endif
     virtual status_t setStreamOutput(uint32_t stream, int output) = 0;
 
     virtual status_t setVoiceVolume(float volume) = 0;
@@ -191,6 +200,9 @@ public:
 #ifdef WITH_QCOM_LPA
     virtual status_t deregisterClient(const sp<IAudioFlingerClient>& client) { return false; };
 #endif
+#ifdef STE_AUDIO
+    virtual size_t readInput(uint32_t *input, uint32_t inputClientId, void *buffer, uint32_t bytes, uint32_t *pOverwrittenBytes) = 0;
+#endif
 };
 
 
diff --git a/include/media/IAudioPolicyService.h b/include/media/IAudioPolicyService.h
index b8a462170fe..6134ad057f4 100644
--- a/include/media/IAudioPolicyService.h
+++ b/include/media/IAudioPolicyService.h
@@ -75,7 +75,12 @@ public:
                                     uint32_t format = AUDIO_FORMAT_DEFAULT,
                                     uint32_t channels = 0,
                                     audio_in_acoustics_t acoustics = (audio_in_acoustics_t)0,
+#ifdef STE_AUDIO
+                                    int audioSession = 0,
+                                    audio_input_clients *inputClientId = NULL) = 0;
+#else
                                     int audioSession = 0) = 0;
+#endif
     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;
diff --git a/media/libmedia/IAudioFlinger.cpp b/media/libmedia/IAudioFlinger.cpp
index 9aa0d650548..fd4c66c03d9 100644
--- a/media/libmedia/IAudioFlinger.cpp
+++ b/media/libmedia/IAudioFlinger.cpp
@@ -67,6 +67,10 @@ enum {
 #endif
     SUSPEND_OUTPUT,
     RESTORE_OUTPUT,
+#ifdef STE_AUDIO
+    ADD_INPUT_CLIENT,
+    REMOVE_INPUT_CLIENT,
+#endif
     OPEN_INPUT,
     CLOSE_INPUT,
     SET_STREAM_OUTPUT,
@@ -81,6 +85,9 @@ enum {
     GET_EFFECT_DESCRIPTOR,
     CREATE_EFFECT,
     MOVE_EFFECTS,
+#ifdef STE_AUDIO
+    READ_INPUT,
+#endif
 #ifdef WITH_QCOM_LPA
     SET_FM_VOLUME,
     CREATE_SESSION,
@@ -567,11 +574,35 @@ public:
         return reply.readInt32();
     }
 
+#ifdef STE_AUDIO
+    virtual uint32_t *addInputClient(uint32_t clientId)
+    {
+        Parcel data, reply;
+        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
+        data.writeInt32(clientId);
+        remote()->transact(ADD_INPUT_CLIENT, data, &reply);
+        return (uint32_t*) reply.readIntPtr();
+    }
+
+    virtual status_t removeInputClient(uint32_t *pClientId)
+    {
+        Parcel data, reply;
+        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
+        data.writeIntPtr((intptr_t)pClientId);
+        remote()->transact(REMOVE_INPUT_CLIENT, data, &reply);
+        return reply.readInt32();
+    }
+#endif
     virtual int openInput(uint32_t *pDevices,
                             uint32_t *pSamplingRate,
                             uint32_t *pFormat,
                             uint32_t *pChannels,
+#ifdef STE_AUDIO
+                            uint32_t acoustics,
+                            uint32_t *pInputClientId)
+#else
                             uint32_t acoustics)
+#endif
     {
         Parcel data, reply;
         uint32_t devices = pDevices ? *pDevices : 0;
@@ -585,6 +616,9 @@ public:
         data.writeInt32(format);
         data.writeInt32(channels);
         data.writeInt32(acoustics);
+#ifdef STE_AUDIO
+        data.writeIntPtr((intptr_t)pInputClientId);
+#endif
         remote()->transact(OPEN_INPUT, data, &reply);
         int input = reply.readInt32();
         devices = reply.readInt32();
@@ -598,6 +632,17 @@ public:
         return input;
     }
 
+#ifdef STE_AUDIO
+    virtual status_t closeInput(int input, uint32_t *inputClientId)
+    {
+        Parcel data, reply;
+        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
+        data.writeInt32(input);
+        data.writeIntPtr((intptr_t) inputClientId);
+        remote()->transact(CLOSE_INPUT, data, &reply);
+        return reply.readInt32();
+    }
+#else
     virtual status_t closeInput(int input)
     {
         Parcel data, reply;
@@ -606,7 +651,7 @@ public:
         remote()->transact(CLOSE_INPUT, data, &reply);
         return reply.readInt32();
     }
-
+#endif
     virtual status_t setStreamOutput(uint32_t stream, int output)
     {
         Parcel data, reply;
@@ -655,6 +700,20 @@ public:
         return reply.readInt32();
     }
 
+#ifdef STE_AUDIO
+    virtual size_t readInput(uint32_t *input, uint32_t inputClientId, void *buffer, uint32_t bytes, uint32_t *pOverwrittenBytes)
+    {
+        Parcel data, reply;
+        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());
+        data.writeIntPtr((intptr_t) input);
+        data.writeInt32(inputClientId);
+        data.writeIntPtr((intptr_t) buffer);
+        data.writeInt32(bytes);
+        data.writeIntPtr((intptr_t) pOverwrittenBytes);
+        remote()->transact(READ_INPUT, data, &reply);
+        return reply.readInt32();
+    }
+#endif
     virtual int newAudioSessionId()
     {
         Parcel data, reply;
@@ -1092,6 +1151,20 @@ status_t BnAudioFlinger::onTransact(
             reply->writeInt32(restoreOutput(data.readInt32()));
             return NO_ERROR;
         } break;
+#ifdef STE_AUDIO
+        case ADD_INPUT_CLIENT: {
+            CHECK_INTERFACE(IAudioFlinger, data, reply);
+            uint32_t clientId = data.readInt32();
+            reply->writeIntPtr((intptr_t)addInputClient(clientId));
+            return NO_ERROR;
+        } break;
+        case REMOVE_INPUT_CLIENT: {
+            CHECK_INTERFACE(IAudioFlinger, data, reply);
+            uint32_t *pClientId = (uint32_t*) data.readIntPtr();
+            reply->writeInt32(removeInputClient(pClientId));
+            return NO_ERROR;
+        } break;
+#endif
         case OPEN_INPUT: {
             CHECK_INTERFACE(IAudioFlinger, data, reply);
             uint32_t devices = data.readInt32();
@@ -1099,12 +1172,19 @@ status_t BnAudioFlinger::onTransact(
             uint32_t format = data.readInt32();
             uint32_t channels = data.readInt32();
             uint32_t acoutics = data.readInt32();
-
+#ifdef STE_AUDIO
+            uint32_t *inputClientId = (uint32_t*) data.readIntPtr();
+#endif
             int input = openInput(&devices,
                                      &samplingRate,
                                      &format,
                                      &channels,
+#ifdef STE_AUDIO
+                                     acoutics,
+                                     inputClientId);
+#else
                                      acoutics);
+#endif
             reply->writeInt32(input);
             reply->writeInt32(devices);
             reply->writeInt32(samplingRate);
@@ -1114,7 +1194,13 @@ status_t BnAudioFlinger::onTransact(
         } break;
         case CLOSE_INPUT: {
             CHECK_INTERFACE(IAudioFlinger, data, reply);
+#ifdef STE_AUDIO
+            uint32_t input = data.readInt32();
+            uint32_t *inputClientId = (uint32_t*) data.readIntPtr();
+            reply->writeInt32(closeInput(input, inputClientId));
+#else
             reply->writeInt32(closeInput(data.readInt32()));
+#endif
             return NO_ERROR;
         } break;
         case SET_STREAM_OUTPUT: {
@@ -1227,6 +1313,18 @@ status_t BnAudioFlinger::onTransact(
             reply->writeInt32(moveEffects(session, srcOutput, dstOutput));
             return NO_ERROR;
         } break;
+#ifdef STE_AUDIO
+        case READ_INPUT: {
+            CHECK_INTERFACE(IAudioFlinger, data, reply);
+            uint32_t* input = (uint32_t*) data.readIntPtr();
+            uint32_t inputClientId = data.readInt32();
+            void* buffer = (void*) data.readIntPtr();
+            uint32_t bytes = data.readInt32();
+            uint32_t *pOverwrittenBytes = (uint32_t*) data.readIntPtr();
+            reply->writeInt32(readInput(input, inputClientId, buffer, bytes, pOverwrittenBytes));
+            return NO_ERROR;
+        } break;
+#endif
         default:
             return BBinder::onTransact(code, data, reply, flags);
     }
diff --git a/media/libmedia/IAudioPolicyService.cpp b/media/libmedia/IAudioPolicyService.cpp
index 8aa877177ac..bbb041ac994 100644
--- a/media/libmedia/IAudioPolicyService.cpp
+++ b/media/libmedia/IAudioPolicyService.cpp
@@ -238,7 +238,12 @@ public:
                                     uint32_t format,
                                     uint32_t channels,
                                     audio_in_acoustics_t acoustics,
+#ifdef STE_AUDIO
+                                    int audioSession,
+                                    audio_input_clients *inputClientId)
+#else
                                     int audioSession)
+#endif
     {
         Parcel data, reply;
         data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());
@@ -247,6 +252,9 @@ public:
         data.writeInt32(static_cast <uint32_t>(format));
         data.writeInt32(channels);
         data.writeInt32(static_cast <uint32_t>(acoustics));
+#ifdef STE_AUDIO
+        data.writeIntPtr((intptr_t)inputClientId);
+#endif
         data.writeInt32(audioSession);
         remote()->transact(GET_INPUT, data, &reply);
         return static_cast <audio_io_handle_t> (reply.readInt32());
@@ -569,13 +577,22 @@ status_t BnAudioPolicyService::onTransact(
             uint32_t channels = data.readInt32();
             audio_in_acoustics_t acoustics =
                     static_cast <audio_in_acoustics_t>(data.readInt32());
+#ifdef STE_AUDIO
+            audio_input_clients *inputClientId =
+                    (audio_input_clients*) data.readIntPtr();
+#endif
             int audioSession = data.readInt32();
             audio_io_handle_t input = getInput(inputSource,
                                                samplingRate,
                                                format,
                                                channels,
                                                acoustics,
+#ifdef STE_AUDIO
+                                               audioSession,
+                                               inputClientId);
+#else
                                                audioSession);
+#endif
             reply->writeInt32(static_cast <int>(input));
             return NO_ERROR;
         } break;
diff --git a/services/audioflinger/AudioFlinger.cpp b/services/audioflinger/AudioFlinger.cpp
index 7c253808cb5..36c40754254 100644
--- a/services/audioflinger/AudioFlinger.cpp
+++ b/services/audioflinger/AudioFlinger.cpp
@@ -233,6 +233,7 @@ void AudioFlinger::onFirstRef()
             mHardwareStatus = AUDIO_HW_IDLE;
         }
     }
+
 }
 
 status_t AudioFlinger::initCheck() const
@@ -266,6 +267,9 @@ AudioFlinger::~AudioFlinger()
         audio_hw_device_close(dev);
     }
     mAudioHwDevs.clear();
+#ifdef STE_AUDIO
+    delete mInputFMStream;
+#endif
 }
 
 audio_hw_device_t* AudioFlinger::findSuitableHwDev_l(uint32_t devices)
@@ -1144,6 +1148,17 @@ unsigned int AudioFlinger::getInputFramesLost(int ioHandle)
     return 0;
 }
 
+#ifdef STE_AUDIO
+size_t AudioFlinger::readInput(uint32_t *input, uint32_t inputClientId, void *buffer, uint32_t bytes, uint32_t *pOverwrittenBytes)
+{
+    if (input == NULL || buffer == NULL) {
+        return 0;
+    }
+
+    AudioStreamIn* stream = (AudioStreamIn*)input;
+    return 0; //return stream->read(buffer, bytes);
+}
+#endif
 status_t AudioFlinger::setVoiceVolume(float value)
 {
     status_t ret = initCheck();
@@ -4643,7 +4658,12 @@ AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
                                          uint32_t sampleRate,
                                          uint32_t channels,
                                          int id,
+#ifdef STE_AUDIO
+                                         uint32_t device,
+                                         audio_input_clients pInputClientId) :
+#else
                                          uint32_t device) :
+#endif
     ThreadBase(audioFlinger, id, device),
     mInput(input), mTrack(NULL), mResampler(0), mRsmpOutBuffer(0), mRsmpInBuffer(0)
 {
@@ -4653,6 +4673,9 @@ AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
 
     mReqChannelCount = popcount(channels);
     mReqSampleRate = sampleRate;
+#ifdef STE_AUDIO
+    mInputClientId = pInputClientId;
+#endif
     readInputParameters();
 }
 
@@ -4787,10 +4810,27 @@ bool AudioFlinger::RecordThread::threadLoop()
                         if (framesOut && mFrameCount == mRsmpInIndex) {
                             if (framesOut == mFrameCount &&
                                 ((int)mChannelCount == mReqChannelCount || mFormat != AUDIO_FORMAT_PCM_16_BIT)) {
+#ifdef STE_AUDIO
+                                mBytesRead = mAudioFlinger->readInput((uint32_t*) mInput,
+                                                                      (uint32_t)mInputClientId,
+                                                                      buffer.raw,
+                                                                      mInputBytes,
+                                                                      NULL);
+#else
                                 mBytesRead = mInput->stream->read(mInput->stream, buffer.raw, mInputBytes);
+#endif
                                 framesOut = 0;
                             } else {
+#ifdef STE_AUDIO
+                                mBytesRead = mAudioFlinger->readInput((uint32_t*) mInput,
+                                                                      (uint32_t)mInputClientId,
+                                                                      mRsmpInBuffer,
+                                                                      mInputBytes,
+                                                                      NULL);
+
+#else
                                 mBytesRead = mInput->stream->read(mInput->stream, mRsmpInBuffer, mInputBytes);
+#endif
                                 mRsmpInIndex = 0;
                             }
                             if (mBytesRead < 0) {
@@ -5038,7 +5078,15 @@ status_t AudioFlinger::RecordThread::getNextBuffer(AudioBufferProvider::Buffer*
     int channelCount;
 
     if (framesReady == 0) {
+#ifdef STE_AUDIO
+        mBytesRead = mAudioFlinger->readInput((uint32_t*) mInput,
+                                              (uint32_t)mInputClientId,
+                                              mRsmpInBuffer,
+                                              mInputBytes,
+                                              NULL);
+#else
         mBytesRead = mInput->stream->read(mInput->stream, mRsmpInBuffer, mInputBytes);
+#endif
         if (mBytesRead < 0) {
             LOGE("RecordThread::getNextBuffer() Error reading audio input");
             if (mActiveTrack->mState == TrackBase::ACTIVE) {
@@ -5567,11 +5615,49 @@ status_t AudioFlinger::restoreOutput(int output)
     return NO_ERROR;
 }
 
+#ifdef STE_AUDIO
+uint32_t *AudioFlinger::addInputClient(uint32_t clientId)
+{
+    Mutex::Autolock _l(mLock);
+
+    uint32_t *pNewClient = new uint32_t;
+    if (pNewClient) {
+        *pNewClient = clientId;
+        mInputClients.add(pNewClient);
+    }
+
+    return pNewClient;
+}
+
+status_t AudioFlinger::removeInputClient(uint32_t *pClientId)
+{
+    status_t result = NO_ERROR;
+
+    Mutex::Autolock _l(mLock);
+
+    if (pClientId == NULL) {
+        result = BAD_VALUE;
+    } else if (mInputClients.remove(pClientId) < 0) {
+        result = BAD_VALUE;
+    } else {
+        // the pointer was found in the vector and is non-NULL, so it must point to memory
+        // allocated by addInputClient => free it.
+        delete pClientId;
+    }
+
+    return result;
+}
+#endif
 int AudioFlinger::openInput(uint32_t *pDevices,
                                 uint32_t *pSamplingRate,
                                 uint32_t *pFormat,
                                 uint32_t *pChannels,
+#ifdef STE_AUDIO
+                                uint32_t acoustics,
+                                uint32_t *pInputClientId)
+#else
                                 uint32_t acoustics)
+#endif
 {
     status_t status;
     RecordThread *thread = NULL;
@@ -5583,7 +5669,10 @@ int AudioFlinger::openInput(uint32_t *pDevices,
     uint32_t reqChannels = channels;
     audio_stream_in_t *inStream;
     audio_hw_device_t *inHwDev;
-
+#ifdef STE_AUDIO
+    bool returnRecordThread = true;
+    audio_input_clients inputClientId;
+#endif
     if (pDevices == NULL || *pDevices == 0) {
         return 0;
     }
@@ -5594,6 +5683,12 @@ int AudioFlinger::openInput(uint32_t *pDevices,
     if (inHwDev == NULL)
         return 0;
 
+#ifdef STE_AUDIO
+    if (pInputClientId != NULL && *pInputClientId == AUDIO_INPUT_CLIENT_PLAYBACK) {
+        returnRecordThread = false;
+    }
+#endif
+
     status = inHwDev->open_input_stream(inHwDev, *pDevices, (int *)&format,
                                         &channels, &samplingRate,
                                         (audio_in_acoustics_t)acoustics,
@@ -5620,6 +5715,7 @@ int AudioFlinger::openInput(uint32_t *pDevices,
                                             &inStream);
     }
 
+
     if (inStream != NULL) {
         AudioStreamIn *input = new AudioStreamIn(inHwDev, inStream);
 
@@ -5633,13 +5729,22 @@ int AudioFlinger::openInput(uint32_t *pDevices,
                                   reqSamplingRate,
                                   reqChannels,
                                   id,
+#ifdef STE_AUDIO
+                                  device,
+                                  inputClientId);
+#else
                                   device);
+#endif
         mRecordThreads.add(id, thread);
         LOGV("openInput() created record thread: ID %d thread %p", id, thread);
         if (pSamplingRate) *pSamplingRate = reqSamplingRate;
         if (pFormat) *pFormat = format;
         if (pChannels) *pChannels = reqChannels;
-
+#ifdef STE_AUDIO
+        if (pInputClientId != NULL) {
+            *pInputClientId = inputClientId;
+        }
+#endif
         input->stream->common.standby(&input->stream->common);
 
         // notify client processes of the new input creation
@@ -5650,10 +5755,17 @@ int AudioFlinger::openInput(uint32_t *pDevices,
     return 0;
 }
 
+#ifdef STE_AUDIO
+status_t AudioFlinger::closeInput(int input, uint32_t *inputClientId)
+#else
 status_t AudioFlinger::closeInput(int input)
+#endif
 {
-    // keep strong reference on the record thread so that
+   // keep strong reference on the record thread so that
     // it is not destroyed while exit() is executed
+#ifdef STE_AUDIO
+    audio_input_clients clientId = (audio_input_clients) *inputClientId;
+#endif
     sp <RecordThread> thread;
     {
         Mutex::Autolock _l(mLock);
@@ -5675,6 +5787,7 @@ status_t AudioFlinger::closeInput(int input)
     delete in;
 
     return NO_ERROR;
+
 }
 
 status_t AudioFlinger::setStreamOutput(uint32_t stream, int output)
@@ -6187,7 +6300,6 @@ status_t AudioFlinger::moveEffectChain_l(int sessionId,
     return NO_ERROR;
 }
 
-
 // PlaybackThread::createEffect_l() must be called with AudioFlinger::mLock held
 sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l(
         const sp<AudioFlinger::Client>& client,
diff --git a/services/audioflinger/AudioFlinger.h b/services/audioflinger/AudioFlinger.h
index ddc062bc982..c2786136cd3 100644
--- a/services/audioflinger/AudioFlinger.h
+++ b/services/audioflinger/AudioFlinger.h
@@ -70,7 +70,9 @@ class AudioFlinger :
     friend class BinderService<AudioFlinger>;
 public:
     static char const* getServiceName() { return "media.audio_flinger"; }
-
+#ifdef STE_AUDIO
+    int getNbrOfClients(audio_stream_in_t* input);
+#endif
     virtual     status_t    dump(int fd, const Vector<String16>& args);
 
     // IAudioFlinger interface
@@ -161,13 +163,27 @@ public:
 
     virtual status_t restoreOutput(int output);
 
+#ifdef STE_AUDIO
+    virtual uint32_t *addInputClient(uint32_t clientId);
+
+    virtual status_t removeInputClient(uint32_t *pClientId);
+#endif
     virtual int openInput(uint32_t *pDevices,
                             uint32_t *pSamplingRate,
                             uint32_t *pFormat,
                             uint32_t *pChannels,
+#ifdef STE_AUDIO
+                            uint32_t acoustics,
+                            uint32_t *pInputClientId = NULL);
+
+    virtual status_t closeInput(int input, uint32_t *inputClientId = NULL);
+
+    virtual size_t readInput(uint32_t *input, uint32_t inputClientId, void *buffer, uint32_t bytes, uint32_t *pOverwrittenBytes);
+#else
                             uint32_t acoustics);
 
     virtual status_t closeInput(int input);
+#endif
 
     virtual status_t setStreamOutput(uint32_t stream, int output);
 
@@ -1026,7 +1042,12 @@ private:
                         uint32_t sampleRate,
                         uint32_t channels,
                         int id,
+#ifdef STE_AUDIO
+                        uint32_t device,
+                        audio_input_clients pInputClientId);
+#else
                         uint32_t device);
+#endif
                 ~RecordThread();
 
         virtual bool        threadLoop();
@@ -1078,6 +1099,9 @@ private:
                 int                                 mReqChannelCount;
                 uint32_t                            mReqSampleRate;
                 ssize_t                             mBytesRead;
+#ifdef STE_AUDIO
+                audio_input_clients                 mInputClientId;
+#endif
     };
 
     class RecordHandle : public android::BnAudioRecord {
@@ -1469,6 +1493,9 @@ private:
 
                 mutable     Mutex                   mHardwareLock;
                 audio_hw_device_t*                  mPrimaryHardwareDev;
+#ifdef STE_AUDIO
+                AudioStreamIn*                      mInputFMStream;
+#endif
                 Vector<audio_hw_device_t*>          mAudioHwDevs;
     mutable     int                                 mHardwareStatus;
 
@@ -1501,7 +1528,9 @@ private:
 #endif
 
                 Vector<AudioSessionRef*> mAudioSessionRefs;
-
+#ifdef STE_AUDIO
+                SortedVector<uint32_t*> mInputClients;
+#endif
 #ifdef WITH_QCOM_LPA
                 public:
                 int                                 mLPASessionId;
diff --git a/services/audioflinger/AudioPolicyService.cpp b/services/audioflinger/AudioPolicyService.cpp
index b9a9115d425..37ca8faed2f 100644
--- a/services/audioflinger/AudioPolicyService.cpp
+++ b/services/audioflinger/AudioPolicyService.cpp
@@ -410,14 +410,23 @@ audio_io_handle_t AudioPolicyService::getInput(int inputSource,
                                     uint32_t format,
                                     uint32_t channels,
                                     audio_in_acoustics_t acoustics,
+#ifdef STE_AUDIO
+                                    int audioSession,
+                                    audio_input_clients *inputClientId)
+#else
                                     int audioSession)
+#endif
 {
     if (mpAudioPolicy == NULL) {
         return 0;
     }
     Mutex::Autolock _l(mLock);
     audio_io_handle_t input = mpAudioPolicy->get_input(mpAudioPolicy, inputSource, samplingRate,
+#ifdef STE_AUDIO
+                                                       format, channels, acoustics, inputClientId);
+#else
                                                        format, channels, acoustics);
+#endif
 
     if (input == 0) {
         return input;
@@ -1543,7 +1552,12 @@ static audio_io_handle_t aps_open_input(void *service,
                                             uint32_t *pSamplingRate,
                                             uint32_t *pFormat,
                                             uint32_t *pChannels,
+#ifdef STE_AUDIO
+                                            uint32_t acoustics,
+                                            uint32_t *inputClientId)
+#else
                                             uint32_t acoustics)
+#endif
 {
     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
     if (af == NULL) {
@@ -1552,16 +1566,28 @@ static audio_io_handle_t aps_open_input(void *service,
     }
 
     return af->openInput(pDevices, pSamplingRate, pFormat, pChannels,
+#ifdef STE_AUDIO
+                         acoustics, inputClientId);
+#else
                          acoustics);
+#endif
 }
 
+#ifdef STE_AUDIO
+static int aps_close_input(void *service, audio_io_handle_t input, uint32_t *inputClientId = NULL)
+#else
 static int aps_close_input(void *service, audio_io_handle_t input)
+#endif
 {
     sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();
     if (af == NULL)
         return PERMISSION_DENIED;
 
+#ifdef STE_AUDIO
+    return af->closeInput(input, inputClientId);
+#else
     return af->closeInput(input);
+#endif
 }
 
 static int aps_set_stream_output(void *service, audio_stream_type_t stream,
diff --git a/services/audioflinger/AudioPolicyService.h b/services/audioflinger/AudioPolicyService.h
index fe82d6d5a00..f9d7caca969 100644
--- a/services/audioflinger/AudioPolicyService.h
+++ b/services/audioflinger/AudioPolicyService.h
@@ -93,7 +93,12 @@ public:
                                     uint32_t channels = 0,
                                     audio_in_acoustics_t acoustics =
                                             (audio_in_acoustics_t)0,
+#ifdef STE_AUDIO
+                                    int audioSession = 0,
+                                    audio_input_clients *inputClientId = NULL);
+#else
                                     int audioSession = 0);
+#endif
     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);