/* ** Copyright 2010, The Android Open-Source Project ** ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file except in compliance with the License. ** You may obtain a copy of the License at ** ** http://www.apache.org/licenses/LICENSE-2.0 ** ** Unless required by applicable law or agreed to in writing, software ** distributed under the License is distributed on an "AS IS" BASIS, ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** See the License for the specific language governing permissions and ** limitations under the License. */ #include #define LOG_NDEBUG 0 #define LOG_TAG "AudioHardware" #include #include #include #include #include #include #include #include #include #include #include "AudioHardware.h" #include #include extern "C" { #include } #ifdef HAVE_FM_RADIO #define Si4709_IOC_MAGIC 0xFA #define Si4709_IOC_VOLUME_SET _IOW(Si4709_IOC_MAGIC, 15, __u8) #endif #ifdef USES_FROYO_RILCLIENT #define OEM_FUNC_SOUND 0x08 #define OEM_SND_SET_VOLUME_CTRL 0x03 #define OEM_SND_SET_AUDIO_PATH 0x05 #define OEM_SND_SET_CLOCK_CTRL 0x0A #define OEM_SND_TYPE_VOICE 0x01 #define OEM_SND_TYPE_SPEAKER 0x11 #define OEM_SND_TYPE_HEADSET 0x31 #define OEM_SND_TYPE_BTVOICE 0x41 #define OEM_SND_AUDIO_PATH_HANDSET 0x01 #define OEM_SND_AUDIO_PATH_HEADSET 0x02 #define OEM_SND_AUDIO_PATH_BLUETOOTH 0x04 #define OEM_SND_AUDIO_PATH_STEREO_BLUETOOTH 0x05 #define OEM_SND_AUDIO_PATH_SPEAKER 0x06 #define OEM_SND_AUDIO_PATH_HEADPHONE 0x07 #define OEM_SND_AUDIO_PATH_BT_NSEC_OFF 0x08 #endif namespace android_audio_legacy { const uint32_t AudioHardware::inputConfigTable[][AudioHardware::INPUT_CONFIG_CNT] = { {8000, 4}, {11025, 4}, {16000, 2}, {22050, 2}, {32000, 1}, {44100, 1} }; // trace driver operations for dump // #define DRIVER_TRACE enum { DRV_NONE, DRV_PCM_OPEN, DRV_PCM_CLOSE, DRV_PCM_WRITE, DRV_PCM_READ, DRV_MIXER_OPEN, DRV_MIXER_CLOSE, DRV_MIXER_GET, DRV_MIXER_SEL }; #ifdef DRIVER_TRACE #define TRACE_DRIVER_IN(op) mDriverOp = op; #define TRACE_DRIVER_OUT mDriverOp = DRV_NONE; #else #define TRACE_DRIVER_IN(op) #define TRACE_DRIVER_OUT #endif // ---------------------------------------------------------------------------- const char *AudioHardware::inputPathNameDefault = "Default"; const char *AudioHardware::inputPathNameCamcorder = "Camcorder"; const char *AudioHardware::inputPathNameVoiceRecognition = "Voice Recognition"; const char *AudioHardware::inputPathNameVoiceCommunication = "Voice Communication"; AudioHardware::AudioHardware() : mInit(false), mMicMute(false), mPcm(NULL), mMixer(NULL), mPcmOpenCnt(0), mMixerOpenCnt(0), mInCallAudioMode(false), mVoiceVol(1.0f), mInputSource(AUDIO_SOURCE_DEFAULT), mBluetoothNrec(true), mTTYMode(TTY_MODE_OFF), mSecRilLibHandle(NULL), mRilClient(0), mActivatedCP(false), mEchoReference(NULL), #ifdef HAVE_FM_RADIO mFmFd(-1), mFmVolume(1), mFmResumeAfterCall(false), #endif mDriverOp(DRV_NONE) { loadRILD(); mInit = true; } AudioHardware::~AudioHardware() { for (size_t index = 0; index < mInputs.size(); index++) { closeInputStream(mInputs[index].get()); } mInputs.clear(); closeOutputStream((AudioStreamOut*)mOutput.get()); if (mMixer) { TRACE_DRIVER_IN(DRV_MIXER_CLOSE) mixer_close(mMixer); TRACE_DRIVER_OUT } if (mPcm) { TRACE_DRIVER_IN(DRV_PCM_CLOSE) pcm_close(mPcm); TRACE_DRIVER_OUT } if (mSecRilLibHandle) { if (disconnectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) ALOGE("Disconnect_RILD() error"); if (closeClientRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) ALOGE("CloseClient_RILD() error"); mRilClient = 0; dlclose(mSecRilLibHandle); mSecRilLibHandle = NULL; } mInit = false; } status_t AudioHardware::initCheck() { return mInit ? NO_ERROR : NO_INIT; } void AudioHardware::loadRILD(void) { mSecRilLibHandle = dlopen("libaudio-ril-interface.so", RTLD_NOW); if (mSecRilLibHandle) { ALOGV("libaudio-ril-interface.so is loaded"); openClientRILD = (HRilClient (*)(void)) dlsym(mSecRilLibHandle, "OpenClient_RILD"); disconnectRILD = (int (*)(HRilClient)) dlsym(mSecRilLibHandle, "Disconnect_RILD"); closeClientRILD = (int (*)(HRilClient)) dlsym(mSecRilLibHandle, "CloseClient_RILD"); isConnectedRILD = (int (*)(HRilClient)) dlsym(mSecRilLibHandle, "isConnected_RILD"); connectRILD = (int (*)(HRilClient)) dlsym(mSecRilLibHandle, "Connect_RILD"); #ifdef USES_FROYO_RILCLIENT invokeOemRequestHookRaw = (int (*)(HRilClient client, char *data, size_t len)) dlsym(mSecRilLibHandle, "InvokeOemRequestHookRaw"); bool rilFunctionsLoaded = invokeOemRequestHookRaw; #else setCallVolume = (int (*)(HRilClient, SoundType, int)) dlsym(mSecRilLibHandle, "SetCallVolume"); setCallAudioPath = (int (*)(HRilClient, AudioPath)) dlsym(mSecRilLibHandle, "SetCallAudioPath"); setCallClockSync = (int (*)(HRilClient, SoundClockCondition)) dlsym(mSecRilLibHandle, "SetCallClockSync"); bool rilFunctionsLoaded = setCallVolume && setCallAudioPath && setCallClockSync; #endif if (!openClientRILD || !disconnectRILD || !closeClientRILD || !isConnectedRILD || !connectRILD || !rilFunctionsLoaded) { ALOGE("Can't load all functions from libaudio-ril-interface.so"); dlclose(mSecRilLibHandle); mSecRilLibHandle = NULL; } else { mRilClient = openClientRILD(); if (!mRilClient) { ALOGE("OpenClient_RILD() error"); dlclose(mSecRilLibHandle); mSecRilLibHandle = NULL; } } } else { ALOGE("Can't load libaudio-ril-interface.so"); } } status_t AudioHardware::connectRILDIfRequired(void) { if (!mSecRilLibHandle) { ALOGE("connectIfRequired() lib is not loaded"); return INVALID_OPERATION; } if (isConnectedRILD(mRilClient)) { return OK; } if (connectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) { ALOGE("Connect_RILD() error"); return INVALID_OPERATION; } return OK; } #ifdef USES_FROYO_RILCLIENT int AudioHardware::convertSoundType(SoundType type) { switch (type) { case SOUND_TYPE_VOICE: return OEM_SND_TYPE_VOICE; case SOUND_TYPE_SPEAKER: return OEM_SND_TYPE_SPEAKER; case SOUND_TYPE_HEADSET: return OEM_SND_TYPE_HEADSET; case SOUND_TYPE_BTVOICE: return OEM_SND_TYPE_BTVOICE; default: ALOGE("convertSoundType: unknown type! %d", type); return OEM_SND_TYPE_VOICE; } } int AudioHardware::convertAudioPath(AudioPath path) { switch (path) { case SOUND_AUDIO_PATH_HANDSET: return OEM_SND_AUDIO_PATH_HANDSET; case SOUND_AUDIO_PATH_SPEAKER: return OEM_SND_AUDIO_PATH_SPEAKER; case SOUND_AUDIO_PATH_BLUETOOTH: return OEM_SND_AUDIO_PATH_BLUETOOTH; case SOUND_AUDIO_PATH_BLUETOOTH_NO_NR: return OEM_SND_AUDIO_PATH_BT_NSEC_OFF; case SOUND_AUDIO_PATH_HEADPHONE: return OEM_SND_AUDIO_PATH_HEADPHONE; case SOUND_AUDIO_PATH_HEADSET: return OEM_SND_AUDIO_PATH_HEADSET; default: ALOGE("convertAudioPath: unknown path! %d", path); return OEM_SND_AUDIO_PATH_HANDSET; } } int AudioHardware::setCallVolume(HRilClient client, SoundType type, int vol) { char data[6] = {0,}; data[0] = OEM_FUNC_SOUND; data[1] = OEM_SND_SET_VOLUME_CTRL; data[2] = 0x00; data[3] = 0x06; data[4] = convertSoundType(type); data[5] = vol; return invokeOemRequestHookRaw(client, data, sizeof(data)); } int AudioHardware::setCallAudioPath(HRilClient client, AudioPath path) { char data[5] = {0,}; data[0] = OEM_FUNC_SOUND; data[1] = OEM_SND_SET_AUDIO_PATH; data[2] = 0x00; data[3] = 0x05; data[4] = convertAudioPath(path); return invokeOemRequestHookRaw(client, data, sizeof(data)); } int AudioHardware::setCallClockSync(HRilClient client, SoundClockCondition condition) { char data[5] = {0,}; data[0] = OEM_FUNC_SOUND; data[1] = OEM_SND_SET_CLOCK_CTRL; data[2] = 0x00; data[3] = 0x05; data[4] = condition; return invokeOemRequestHookRaw(client, data, sizeof(data)); } #endif AudioStreamOut* AudioHardware::openOutputStream( uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status) { sp out; status_t rc; { // scope for the lock Mutex::Autolock lock(mLock); // only one output stream allowed if (mOutput != 0) { if (status) { *status = INVALID_OPERATION; } return NULL; } out = new AudioStreamOutALSA(); rc = out->set(this, devices, format, channels, sampleRate); if (rc == NO_ERROR) { mOutput = out; } } if (rc != NO_ERROR) { if (out != 0) { out.clear(); } } if (status) { *status = rc; } return out.get(); } void AudioHardware::closeOutputStream(AudioStreamOut* out) { sp spOut; sp spIn; { Mutex::Autolock lock(mLock); if (mOutput == 0 || mOutput.get() != out) { ALOGW("Attempt to close invalid output stream"); return; } spOut = mOutput; mOutput.clear(); if (mEchoReference != NULL) { spIn = getActiveInput_l(); } } if (spIn != 0) { // this will safely release the echo reference by calling releaseEchoReference() // after placing the active input in standby spIn->standby(); } spOut.clear(); } AudioStreamIn* AudioHardware::openInputStream( uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status, AudioSystem::audio_in_acoustics acoustic_flags) { // check for valid input source if (!AudioSystem::isInputDevice((AudioSystem::audio_devices)devices)) { if (status) { *status = BAD_VALUE; } return NULL; } status_t rc = NO_ERROR; sp in; { // scope for the lock Mutex::Autolock lock(mLock); in = new AudioStreamInALSA(); rc = in->set(this, devices, format, channels, sampleRate, acoustic_flags); if (rc == NO_ERROR) { mInputs.add(in); } } if (rc != NO_ERROR) { if (in != 0) { in.clear(); } } if (status) { *status = rc; } ALOGV("AudioHardware::openInputStream()%p", in.get()); return in.get(); } void AudioHardware::closeInputStream(AudioStreamIn* in) { sp spIn; { Mutex::Autolock lock(mLock); ssize_t index = mInputs.indexOf((AudioStreamInALSA *)in); if (index < 0) { ALOGW("Attempt to close invalid input stream"); return; } spIn = mInputs[index]; mInputs.removeAt(index); } ALOGV("AudioHardware::closeInputStream()%p", in); spIn.clear(); } status_t AudioHardware::setMode(int mode) { sp spOut; sp spIn; status_t status; // Mutex acquisition order is always out -> in -> hw AutoMutex lock(mLock); spOut = mOutput; while (spOut != 0) { if (!spOut->checkStandby()) { int cnt = spOut->prepareLock(); mLock.unlock(); spOut->lock(); mLock.lock(); // make sure that another thread did not change output state while the // mutex is released if ((spOut == mOutput) && (cnt == spOut->standbyCnt())) { break; } spOut->unlock(); spOut = mOutput; } else { spOut.clear(); } } // spOut is not 0 here only if the output is active spIn = getActiveInput_l(); while (spIn != 0) { int cnt = spIn->prepareLock(); mLock.unlock(); spIn->lock(); mLock.lock(); // make sure that another thread did not change input state while the // mutex is released if ((spIn == getActiveInput_l()) && (cnt == spIn->standbyCnt())) { break; } spIn->unlock(); spIn = getActiveInput_l(); } // spIn is not 0 here only if the input is active int prevMode = mMode; status = AudioHardwareBase::setMode(mode); ALOGV("setMode() : new %d, old %d", mMode, prevMode); if (status == NO_ERROR) { // activate call clock in radio when entering in call mode if (mMode == AudioSystem::MODE_IN_CALL) { if ((!mActivatedCP) && (mSecRilLibHandle) && (connectRILDIfRequired() == OK)) { setCallClockSync(mRilClient, SOUND_CLOCK_START); mActivatedCP = true; } } if (mMode == AudioSystem::MODE_IN_CALL && !mInCallAudioMode) { if (spOut != 0) { ALOGV("setMode() in call force output standby"); spOut->doStandby_l(); } if (spIn != 0) { ALOGV("setMode() in call force input standby"); spIn->doStandby_l(); } ALOGV("setMode() openPcmOut_l()"); openPcmOut_l(); openMixer_l(); setInputSource_l(AUDIO_SOURCE_DEFAULT); setVoiceVolume_l(mVoiceVol); mInCallAudioMode = true; } if (mMode == AudioSystem::MODE_NORMAL && mInCallAudioMode) { setInputSource_l(mInputSource); if (mMixer != NULL) { TRACE_DRIVER_IN(DRV_MIXER_GET) struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer, "Playback Path"); TRACE_DRIVER_OUT if (ctl != NULL) { ALOGV("setMode() reset Playback Path to RCV"); TRACE_DRIVER_IN(DRV_MIXER_SEL) mixer_ctl_set_enum_by_string(ctl, "RCV"); TRACE_DRIVER_OUT } } ALOGV("setMode() closePcmOut_l()"); closeMixer_l(); closePcmOut_l(); if (spOut != 0) { ALOGV("setMode() off call force output standby"); spOut->doStandby_l(); } if (spIn != 0) { ALOGV("setMode() off call force input standby"); spIn->doStandby_l(); } mInCallAudioMode = false; } if (mMode == AudioSystem::MODE_NORMAL) { if(mActivatedCP) mActivatedCP = false; } } if (spIn != 0) { spIn->unlock(); } if (spOut != 0) { spOut->unlock(); } #ifdef HAVE_FM_RADIO if (mFmResumeAfterCall) { mFmResumeAfterCall = false; enableFMRadio(); } #endif return status; } status_t AudioHardware::setMicMute(bool state) { ALOGV("setMicMute(%d) mMicMute %d", state, mMicMute); sp spIn; { AutoMutex lock(mLock); if (mMicMute != state) { mMicMute = state; // in call mute is handled by RIL if (mMode != AudioSystem::MODE_IN_CALL) { spIn = getActiveInput_l(); } } } if (spIn != 0) { spIn->standby(); } return NO_ERROR; } status_t AudioHardware::getMicMute(bool* state) { *state = mMicMute; return NO_ERROR; } status_t AudioHardware::setParameters(const String8& keyValuePairs) { AudioParameter param = AudioParameter(keyValuePairs); String8 value; String8 key; const char BT_NREC_KEY[] = "bt_headset_nrec"; const char BT_NREC_VALUE_ON[] = "on"; const char TTY_MODE_KEY[] = "tty_mode"; const char TTY_MODE_VALUE_OFF[] = "tty_off"; const char TTY_MODE_VALUE_VCO[] = "tty_vco"; const char TTY_MODE_VALUE_HCO[] = "tty_hco"; const char TTY_MODE_VALUE_FULL[] = "tty_full"; #ifdef HAVE_FM_RADIO const char FM_RADIO_KEY_ON[] = "fm_on"; const char FM_RADIO_KEY_OFF[] = "fm_off"; const char FM_RADIO_VALUE_ON[] = "2055"; const char FM_RADIO_VALUE_OFF[] = "7"; #endif key = String8(BT_NREC_KEY); if (param.get(key, value) == NO_ERROR) { if (value == BT_NREC_VALUE_ON) { mBluetoothNrec = true; } else { mBluetoothNrec = false; ALOGD("Turning noise reduction and echo cancellation off for BT " "headset"); } param.remove(String8(BT_NREC_KEY)); } key = String8(TTY_MODE_KEY); if (param.get(key, value) == NO_ERROR) { int ttyMode; if (value == TTY_MODE_VALUE_OFF) { ttyMode = TTY_MODE_OFF; } else if (value == TTY_MODE_VALUE_VCO) { ttyMode = TTY_MODE_VCO; } else if (value == TTY_MODE_VALUE_HCO) { ttyMode = TTY_MODE_HCO; } else if (value == TTY_MODE_VALUE_FULL) { ttyMode = TTY_MODE_FULL; } else { return BAD_VALUE; } if (ttyMode != mTTYMode) { ALOGV("new tty mode %d", ttyMode); mTTYMode = ttyMode; if (mOutput != 0 && mMode == AudioSystem::MODE_IN_CALL) { setIncallPath_l(mOutput->device()); } } param.remove(String8(TTY_MODE_KEY)); } #ifdef HAVE_FM_RADIO // fm radio on key = String8(AudioParameter::keyFmOn); if (param.get(key, value) == NO_ERROR) { enableFMRadio(); } param.remove(key); // fm radio off key = String8(AudioParameter::keyFmOff); if (param.get(key, value) == NO_ERROR) { disableFMRadio(); } param.remove(key); #endif return NO_ERROR; } String8 AudioHardware::getParameters(const String8& keys) { AudioParameter request = AudioParameter(keys); AudioParameter reply = AudioParameter(); ALOGV("getParameters() %s", keys.string()); return reply.toString(); } size_t AudioHardware::getInputBufferSize(uint32_t sampleRate, int format, int channelCount) { if (format != AudioSystem::PCM_16_BIT) { ALOGW("getInputBufferSize bad format: %d", format); return 0; } if (channelCount < 1 || channelCount > 2) { ALOGW("getInputBufferSize bad channel count: %d", channelCount); return 0; } if (sampleRate != getInputSampleRate(sampleRate)) { ALOGW("getInputBufferSize bad sample rate: %d", sampleRate); return 0; } return AudioStreamInALSA::getBufferSize(sampleRate, channelCount); } status_t AudioHardware::setVoiceVolume(float volume) { AutoMutex lock(mLock); setVoiceVolume_l(volume); return NO_ERROR; } void AudioHardware::setVoiceVolume_l(float volume) { ALOGD("### setVoiceVolume_l"); mVoiceVol = volume; if ( (AudioSystem::MODE_IN_CALL == mMode) && (mSecRilLibHandle) && (connectRILDIfRequired() == OK) ) { uint32_t device = AudioSystem::DEVICE_OUT_EARPIECE; if (mOutput != 0) { device = mOutput->device(); } int int_volume = (int)(volume * 5); SoundType type; ALOGD("### route(%d) call volume(%f)", device, volume); switch (device) { case AudioSystem::DEVICE_OUT_EARPIECE: ALOGD("### earpiece call volume"); type = SOUND_TYPE_VOICE; break; case AudioSystem::DEVICE_OUT_SPEAKER: case AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET: ALOGD("### speaker call volume"); type = SOUND_TYPE_SPEAKER; break; case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: ALOGD("### bluetooth call volume"); type = SOUND_TYPE_BTVOICE; break; case AudioSystem::DEVICE_OUT_WIRED_HEADSET: case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: // Use receive path with 3 pole headset. ALOGD("### headset call volume"); type = SOUND_TYPE_HEADSET; break; default: ALOGW("### Call volume setting error!!!0x%08x \n", device); type = SOUND_TYPE_VOICE; break; } setCallVolume(mRilClient, type, int_volume); } } status_t AudioHardware::setMasterVolume(float volume) { ALOGV("Set master volume to %f.\n", volume); // We return an error code here to let the audioflinger do in-software // volume on top of the maximum volume that we set through the SND API. // return error - software mixer will handle it return -1; } #ifdef HAVE_FM_RADIO status_t AudioHardware::setFmVolume(float v) { mFmVolume = v; if (mFmFd > 0) { __u8 fmVolume = (AudioSystem::logToLinear(v) + 5) / 7; ALOGD("%s %f %d", __func__, v, (int) fmVolume); if (ioctl(mFmFd, Si4709_IOC_VOLUME_SET, &fmVolume) < 0) { ALOGE("set_volume_fm error."); return -EIO; } } return NO_ERROR; } #endif static const int kDumpLockRetries = 50; static const int kDumpLockSleep = 20000; static bool tryLock(Mutex& mutex) { bool locked = false; for (int i = 0; i < kDumpLockRetries; ++i) { if (mutex.tryLock() == NO_ERROR) { locked = true; break; } usleep(kDumpLockSleep); } return locked; } status_t AudioHardware::dump(int fd, const Vector& args) { const size_t SIZE = 256; char buffer[SIZE]; String8 result; bool locked = tryLock(mLock); if (!locked) { snprintf(buffer, SIZE, "\n\tAudioHardware maybe deadlocked\n"); } else { mLock.unlock(); } snprintf(buffer, SIZE, "\tInit %s\n", (mInit) ? "OK" : "Failed"); result.append(buffer); snprintf(buffer, SIZE, "\tMic Mute %s\n", (mMicMute) ? "ON" : "OFF"); result.append(buffer); snprintf(buffer, SIZE, "\tmPcm: %p\n", mPcm); result.append(buffer); snprintf(buffer, SIZE, "\tmPcmOpenCnt: %d\n", mPcmOpenCnt); result.append(buffer); snprintf(buffer, SIZE, "\tmMixer: %p\n", mMixer); result.append(buffer); snprintf(buffer, SIZE, "\tmMixerOpenCnt: %d\n", mMixerOpenCnt); result.append(buffer); snprintf(buffer, SIZE, "\tIn Call Audio Mode %s\n", (mInCallAudioMode) ? "ON" : "OFF"); result.append(buffer); snprintf(buffer, SIZE, "\tInput source %d\n", mInputSource); result.append(buffer); snprintf(buffer, SIZE, "\tmSecRilLibHandle: %p\n", mSecRilLibHandle); result.append(buffer); snprintf(buffer, SIZE, "\tmRilClient: %p\n", mRilClient); result.append(buffer); snprintf(buffer, SIZE, "\tCP %s\n", (mActivatedCP) ? "Activated" : "Deactivated"); result.append(buffer); snprintf(buffer, SIZE, "\tmDriverOp: %d\n", mDriverOp); result.append(buffer); snprintf(buffer, SIZE, "\n\tmOutput %p dump:\n", mOutput.get()); result.append(buffer); write(fd, result.string(), result.size()); if (mOutput != 0) { mOutput->dump(fd, args); } snprintf(buffer, SIZE, "\n\t%d inputs opened:\n", mInputs.size()); write(fd, buffer, strlen(buffer)); for (size_t i = 0; i < mInputs.size(); i++) { snprintf(buffer, SIZE, "\t- input %d dump:\n", i); write(fd, buffer, strlen(buffer)); mInputs[i]->dump(fd, args); } return NO_ERROR; } status_t AudioHardware::setIncallPath_l(uint32_t device) { ALOGV("setIncallPath_l: device %x", device); // Setup sound path for CP clocking if ((mSecRilLibHandle) && (connectRILDIfRequired() == OK)) { if (mMode == AudioSystem::MODE_IN_CALL) { ALOGD("### incall mode route (%d)", device); AudioPath path; switch(device){ case AudioSystem::DEVICE_OUT_EARPIECE: ALOGD("### incall mode earpiece route"); path = SOUND_AUDIO_PATH_HANDSET; break; case AudioSystem::DEVICE_OUT_SPEAKER: case AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET: ALOGD("### incall mode speaker route"); path = SOUND_AUDIO_PATH_SPEAKER; break; case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: ALOGD("### incall mode bluetooth route %s NR", mBluetoothNrec ? "" : "NO"); if (mBluetoothNrec) { path = SOUND_AUDIO_PATH_BLUETOOTH; } else { path = SOUND_AUDIO_PATH_BLUETOOTH_NO_NR; } break; case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE : ALOGD("### incall mode headphone route"); path = SOUND_AUDIO_PATH_HEADPHONE; break; case AudioSystem::DEVICE_OUT_WIRED_HEADSET : ALOGD("### incall mode headset route"); path = SOUND_AUDIO_PATH_HEADSET; break; default: ALOGW("### incall mode Error!! route = [%d]", device); path = SOUND_AUDIO_PATH_HANDSET; break; } setCallAudioPath(mRilClient, path); if (mMixer != NULL) { TRACE_DRIVER_IN(DRV_MIXER_GET) struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer, "Voice Call Path"); TRACE_DRIVER_OUT ALOGE_IF(ctl == NULL, "setIncallPath_l() could not get mixer ctl"); if (ctl != NULL) { ALOGV("setIncallPath_l() Voice Call Path, (%x)", device); TRACE_DRIVER_IN(DRV_MIXER_SEL) mixer_ctl_set_enum_by_string(ctl, getVoiceRouteFromDevice(device)); TRACE_DRIVER_OUT } } } } return NO_ERROR; } #ifdef HAVE_FM_RADIO void AudioHardware::enableFMRadio() { ALOGV("AudioHardware::enableFMRadio() Turning FM Radio ON"); if (mMode == AudioSystem::MODE_IN_CALL) { ALOGV("AudioHardware::enableFMRadio() Call is active. Delaying FM enable."); mFmResumeAfterCall = true; } else { openPcmOut_l(); openMixer_l(); setInputSource_l(AUDIO_SOURCE_DEFAULT); if (mMixer != NULL) { ALOGV("AudioHardware::enableFMRadio() FM Radio is ON, calling setFMRadioPath_l()"); setFMRadioPath_l(mOutput->device()); } if (mFmFd < 0) { mFmFd = open("/dev/radio0", O_RDWR); // In case setFmVolume was called before FM was enabled, we save the volume and call it here. setFmVolume(mFmVolume); } } } void AudioHardware::disableFMRadio() { ALOGV("AudioHardware::disableFMRadio() Turning FM Radio OFF"); if (mMixer != NULL) { // Disable FM radio flag to allow the codec to be turned off // (the flag is automatically set by the kernel driver when FM is enabled) // No need to turn off the FM Radio path as the kernel driver will handle that TRACE_DRIVER_IN(DRV_MIXER_GET) struct mixer_ctl *ctl = mixer_get_control(mMixer, "Codec Status", 0); TRACE_DRIVER_OUT if (ctl != NULL) { TRACE_DRIVER_IN(DRV_MIXER_SEL) mixer_ctl_select(ctl, "FMR_FLAG_CLEAR"); TRACE_DRIVER_OUT } closeMixer_l(); closePcmOut_l(); } if (mFmFd > 0) { close(mFmFd); mFmFd = -1; } } status_t AudioHardware::setFMRadioPath_l(uint32_t device) { ALOGV("setFMRadioPath_l() device %x", device); AudioPath path; const char *fmpath; if (device != AudioSystem::DEVICE_OUT_SPEAKER && (device & AudioSystem::DEVICE_OUT_SPEAKER) != 0) { /* Fix the case where we're on headset and the system has just played a * notification sound to both the speaker and the headset. The device * now is an ORed value and we need to get back its original value. */ device -= AudioSystem::DEVICE_OUT_SPEAKER; ALOGD("setFMRadioPath_l() device removed speaker %x", device); } switch(device){ case AudioSystem::DEVICE_OUT_SPEAKER: ALOGD("setFMRadioPath_l() fmradio speaker route"); fmpath = "FMR_SPK"; break; case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: ALOGD("setFMRadioPath_l() fmradio bluetooth route"); break; case AudioSystem::DEVICE_OUT_WIRED_HEADSET: case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: ALOGD("setFMRadioPath_l() fmradio headphone route"); fmpath = "FMR_HP"; break; default: ALOGE("setFMRadioPath_l() fmradio error, route = [%d]", device); fmpath = "FMR_HP"; break; } if (mMixer != NULL) { ALOGV("setFMRadioPath_l() mixer is open"); TRACE_DRIVER_IN(DRV_MIXER_GET) struct mixer_ctl *ctl= mixer_get_control(mMixer, "FM Radio Path", 0); TRACE_DRIVER_OUT if (ctl != NULL) { ALOGV("setFMRadioPath_l() FM Radio Path, (%s)", fmpath); TRACE_DRIVER_IN(DRV_MIXER_SEL) mixer_ctl_select(ctl, fmpath); TRACE_DRIVER_OUT } else { ALOGE("setFMRadioPath_l() could not get FM Radio Path mixer ctl"); } TRACE_DRIVER_IN(DRV_MIXER_GET) ctl = mixer_get_control(mMixer, "Playback Path", 0); TRACE_DRIVER_OUT const char *route = getOutputRouteFromDevice(device); ALOGV("setFMRadioPath_l() Playpack Path, (%s)", route); if (ctl) { TRACE_DRIVER_IN(DRV_MIXER_SEL) mixer_ctl_select(ctl, route); TRACE_DRIVER_OUT } else { ALOGE("setFMRadioPath_l() could not get Playback Path mixer ctl"); } } else { ALOGE("setFMRadioPath_l() mixer is not open"); } return NO_ERROR; } #endif struct pcm *AudioHardware::openPcmOut_l() { ALOGD("openPcmOut_l() mPcmOpenCnt: %d", mPcmOpenCnt); if (mPcmOpenCnt++ == 0) { if (mPcm != NULL) { ALOGE("openPcmOut_l() mPcmOpenCnt == 0 and mPcm == %p\n", mPcm); mPcmOpenCnt--; return NULL; } unsigned flags = PCM_OUT; struct pcm_config config = { channels : 2, rate : AUDIO_HW_OUT_SAMPLERATE, period_size : AUDIO_HW_OUT_PERIOD_SZ, period_count : AUDIO_HW_OUT_PERIOD_CNT, format : PCM_FORMAT_S16_LE, start_threshold : 0, stop_threshold : 0, silence_threshold : 0, }; TRACE_DRIVER_IN(DRV_PCM_OPEN) mPcm = pcm_open(0, 0, flags, &config); TRACE_DRIVER_OUT if (!pcm_is_ready(mPcm)) { ALOGE("openPcmOut_l() cannot open pcm_out driver: %s\n", pcm_get_error(mPcm)); TRACE_DRIVER_IN(DRV_PCM_CLOSE) pcm_close(mPcm); TRACE_DRIVER_OUT mPcmOpenCnt--; mPcm = NULL; } } return mPcm; } void AudioHardware::closePcmOut_l() { ALOGD("closePcmOut_l() mPcmOpenCnt: %d", mPcmOpenCnt); if (mPcmOpenCnt == 0) { ALOGE("closePcmOut_l() mPcmOpenCnt == 0"); return; } if (--mPcmOpenCnt == 0) { TRACE_DRIVER_IN(DRV_PCM_CLOSE) pcm_close(mPcm); TRACE_DRIVER_OUT mPcm = NULL; } } struct mixer *AudioHardware::openMixer_l() { ALOGV("openMixer_l() mMixerOpenCnt: %d", mMixerOpenCnt); if (mMixerOpenCnt++ == 0) { if (mMixer != NULL) { ALOGE("openMixer_l() mMixerOpenCnt == 0 and mMixer == %p\n", mMixer); mMixerOpenCnt--; return NULL; } TRACE_DRIVER_IN(DRV_MIXER_OPEN) mMixer = mixer_open(0); TRACE_DRIVER_OUT if (mMixer == NULL) { ALOGE("openMixer_l() cannot open mixer"); mMixerOpenCnt--; return NULL; } } return mMixer; } void AudioHardware::closeMixer_l() { ALOGV("closeMixer_l() mMixerOpenCnt: %d", mMixerOpenCnt); if (mMixerOpenCnt == 0) { ALOGE("closeMixer_l() mMixerOpenCnt == 0"); return; } if (--mMixerOpenCnt == 0) { TRACE_DRIVER_IN(DRV_MIXER_CLOSE) mixer_close(mMixer); TRACE_DRIVER_OUT mMixer = NULL; } } const char *AudioHardware::getOutputRouteFromDevice(uint32_t device) { switch (device) { case AudioSystem::DEVICE_OUT_EARPIECE: return "RCV"; case AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET: if (mMode == AudioSystem::MODE_RINGTONE) return "RING_SPK"; else return "EXTRA_DOCK_SPEAKER"; case AudioSystem::DEVICE_OUT_SPEAKER: if (mMode == AudioSystem::MODE_RINGTONE) return "RING_SPK"; else return "SPK"; case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: if (mMode == AudioSystem::MODE_RINGTONE) return "RING_NO_MIC"; else return "HP_NO_MIC"; case AudioSystem::DEVICE_OUT_WIRED_HEADSET: if (mMode == AudioSystem::MODE_RINGTONE) return "RING_HP"; else return "HP"; case (AudioSystem::DEVICE_OUT_SPEAKER|AudioSystem::DEVICE_OUT_WIRED_HEADPHONE): case (AudioSystem::DEVICE_OUT_SPEAKER|AudioSystem::DEVICE_OUT_WIRED_HEADSET): case (AudioSystem::DEVICE_OUT_SPEAKER|AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET): if (mMode == AudioSystem::MODE_RINGTONE) return "RING_SPK_HP"; else return "SPK_HP"; case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: return "BT"; default: return "OFF"; } } const char *AudioHardware::getVoiceRouteFromDevice(uint32_t device) { switch (device) { case AudioSystem::DEVICE_OUT_EARPIECE: return "RCV"; case AudioSystem::DEVICE_OUT_SPEAKER: case AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET: return "SPK"; case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: case AudioSystem::DEVICE_OUT_WIRED_HEADSET: switch (mTTYMode) { case TTY_MODE_VCO: return "TTY_VCO"; case TTY_MODE_HCO: return "TTY_HCO"; case TTY_MODE_FULL: return "TTY_FULL"; case TTY_MODE_OFF: default: if (device == AudioSystem::DEVICE_OUT_WIRED_HEADPHONE) { return "HP_NO_MIC"; } else { return "HP"; } } case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO: case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET: case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT: return "BT"; default: return "OFF"; } } const char *AudioHardware::getInputRouteFromDevice(uint32_t device) { if (mMicMute) { return "MIC OFF"; } switch (device) { case AudioSystem::DEVICE_IN_BUILTIN_MIC: return "Main Mic"; case AudioSystem::DEVICE_IN_WIRED_HEADSET: return "Hands Free Mic"; case AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET: return "BT Sco Mic"; #ifdef HAVE_FM_RADIO case AudioSystem::DEVICE_IN_FM_RX: return "FM Radio"; case AudioSystem::DEVICE_IN_FM_RX_A2DP: return "FM Radio A2DP"; #endif default: return "MIC OFF"; } } uint32_t AudioHardware::getInputSampleRate(uint32_t sampleRate) { size_t i; uint32_t prevDelta; uint32_t delta; size_t size = sizeof(inputConfigTable)/sizeof(uint32_t)/INPUT_CONFIG_CNT; for (i = 0, prevDelta = 0xFFFFFFFF; i < size; i++, prevDelta = delta) { delta = abs(sampleRate - inputConfigTable[i][INPUT_CONFIG_SAMPLE_RATE]); if (delta > prevDelta) break; } // i is always > 0 here return inputConfigTable[i-1][INPUT_CONFIG_SAMPLE_RATE]; } // getActiveInput_l() must be called with mLock held sp AudioHardware::getActiveInput_l() { sp< AudioHardware::AudioStreamInALSA> spIn; for (size_t i = 0; i < mInputs.size(); i++) { // return first input found not being in standby mode // as only one input can be in this state if (!mInputs[i]->checkStandby()) { spIn = mInputs[i]; break; } } return spIn; } status_t AudioHardware::setInputSource_l(audio_source source) { ALOGV("setInputSource_l(%d)", source); if (source != mInputSource) { if ((source == AUDIO_SOURCE_DEFAULT) || (mMode != AudioSystem::MODE_IN_CALL)) { if (mMixer) { TRACE_DRIVER_IN(DRV_MIXER_GET) struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer, "Input Source"); TRACE_DRIVER_OUT if (ctl == NULL) { return NO_INIT; } const char* sourceName; switch (source) { case AUDIO_SOURCE_DEFAULT: // intended fall-through case AUDIO_SOURCE_MIC: case AUDIO_SOURCE_CAMCORDER: sourceName = inputPathNameCamcorder; break; case AUDIO_SOURCE_VOICE_COMMUNICATION: sourceName = inputPathNameVoiceCommunication; break; case AUDIO_SOURCE_VOICE_RECOGNITION: sourceName = inputPathNameVoiceRecognition; break; case AUDIO_SOURCE_VOICE_UPLINK: // intended fall-through case AUDIO_SOURCE_VOICE_DOWNLINK: // intended fall-through case AUDIO_SOURCE_VOICE_CALL: // intended fall-through default: return NO_INIT; } ALOGV("mixer_ctl_set_enum_by_string, Input Source, (%s)", sourceName); TRACE_DRIVER_IN(DRV_MIXER_SEL) mixer_ctl_set_enum_by_string(ctl, sourceName); TRACE_DRIVER_OUT } } mInputSource = source; } return NO_ERROR; } struct echo_reference_itfe *AudioHardware::getEchoReference(audio_format_t format, uint32_t channelCount, uint32_t samplingRate) { ALOGV("AudioHardware::getEchoReference %p", mEchoReference); releaseEchoReference(mEchoReference); if (mOutput != NULL) { uint32_t wrChannelCount = popcount(mOutput->channels()); uint32_t wrSampleRate = mOutput->sampleRate(); int status = create_echo_reference(AUDIO_FORMAT_PCM_16_BIT, channelCount, samplingRate, AUDIO_FORMAT_PCM_16_BIT, wrChannelCount, wrSampleRate, &mEchoReference); if (status == 0) { mOutput->addEchoReference(mEchoReference); } } return mEchoReference; } void AudioHardware::releaseEchoReference(struct echo_reference_itfe *reference) { ALOGV("AudioHardware::releaseEchoReference %p", mEchoReference); if (mEchoReference != NULL && reference == mEchoReference) { if (mOutput != NULL) { mOutput->removeEchoReference(reference); } release_echo_reference(mEchoReference); mEchoReference = NULL; } } //------------------------------------------------------------------------------ // AudioStreamOutALSA //------------------------------------------------------------------------------ AudioHardware::AudioStreamOutALSA::AudioStreamOutALSA() : mHardware(0), mPcm(0), mMixer(0), mRouteCtl(0), mStandby(true), mDevices(0), mChannels(AUDIO_HW_OUT_CHANNELS), mSampleRate(AUDIO_HW_OUT_SAMPLERATE), mBufferSize(AUDIO_HW_OUT_PERIOD_BYTES), mDriverOp(DRV_NONE), mStandbyCnt(0), mSleepReq(false), mEchoReference(NULL) { } status_t AudioHardware::AudioStreamOutALSA::set( AudioHardware* hw, uint32_t devices, int *pFormat, uint32_t *pChannels, uint32_t *pRate) { int lFormat = pFormat ? *pFormat : 0; uint32_t lChannels = pChannels ? *pChannels : 0; uint32_t lRate = pRate ? *pRate : 0; mHardware = hw; mDevices = devices; // fix up defaults if (lFormat == 0) lFormat = format(); if (lChannels == 0) lChannels = channels(); if (lRate == 0) lRate = sampleRate(); // check values if ((lFormat != format()) || (lChannels != channels()) || (lRate != sampleRate())) { if (pFormat) *pFormat = format(); if (pChannels) *pChannels = channels(); if (pRate) *pRate = sampleRate(); return BAD_VALUE; } if (pFormat) *pFormat = lFormat; if (pChannels) *pChannels = lChannels; if (pRate) *pRate = lRate; mChannels = lChannels; mSampleRate = lRate; mBufferSize = AUDIO_HW_OUT_PERIOD_BYTES; return NO_ERROR; } AudioHardware::AudioStreamOutALSA::~AudioStreamOutALSA() { standby(); } int AudioHardware::AudioStreamOutALSA::getPlaybackDelay(size_t frames, struct echo_reference_buffer *buffer) { size_t kernelFr; int rc = pcm_get_htimestamp(mPcm, &kernelFr, &buffer->time_stamp); if (rc < 0) { buffer->time_stamp.tv_sec = 0; buffer->time_stamp.tv_nsec = 0; buffer->delay_ns = 0; ALOGV("getPlaybackDelay(): pcm_get_htimestamp error, setting playbackTimestamp to 0"); return rc; } kernelFr = pcm_get_buffer_size(mPcm) - kernelFr; // adjust render time stamp with delay added by current driver buffer. // Add the duration of current frame as we want the render time of the last // sample being written. long delayNs = (long)(((int64_t)(kernelFr + frames)* 1000000000) /AUDIO_HW_OUT_SAMPLERATE); ALOGV("AudioStreamOutALSA::getPlaybackDelay delayNs: [%ld], "\ "kernelFr:[%d], frames:[%d], buffSize:[%d], time_stamp:[%ld].[%ld]", delayNs, (int)kernelFr, (int)frames, pcm_get_buffer_size(mPcm), (long)buffer->time_stamp.tv_sec, buffer->time_stamp.tv_nsec); buffer->delay_ns = delayNs; return 0; } ssize_t AudioHardware::AudioStreamOutALSA::write(const void* buffer, size_t bytes) { //ALOGV("-----AudioStreamInALSA::write(%p, %d) START", buffer, (int)bytes); status_t status = NO_INIT; const uint8_t* p = static_cast(buffer); int ret; if (mHardware == NULL) return NO_INIT; if (mSleepReq) { // 10ms are always shorter than the time to reconfigure the audio path // which is the only condition when mSleepReq would be true. usleep(10000); } { // scope for the lock AutoMutex lock(mLock); if (mStandby) { AutoMutex hwLock(mHardware->lock()); ALOGD("AudioHardware pcm playback is exiting standby."); acquire_wake_lock(PARTIAL_WAKE_LOCK, "AudioOutLock"); sp spIn = mHardware->getActiveInput_l(); while (spIn != 0) { int cnt = spIn->prepareLock(); mHardware->lock().unlock(); // Mutex acquisition order is always out -> in -> hw spIn->lock(); mHardware->lock().lock(); // make sure that another thread did not change input state // while the mutex is released if ((spIn == mHardware->getActiveInput_l()) && (cnt == spIn->standbyCnt())) { ALOGV("AudioStreamOutALSA::write() force input standby"); spIn->close_l(); break; } spIn->unlock(); spIn = mHardware->getActiveInput_l(); } // spIn is not 0 here only if the input was active and has been // closed above // open output before input open_l(); if (spIn != 0) { if (spIn->open_l() != NO_ERROR) { spIn->doStandby_l(); } spIn->unlock(); } if (mPcm == NULL) { release_wake_lock("AudioOutLock"); goto Error; } mStandby = false; } if (mEchoReference != NULL) { struct echo_reference_buffer b; b.raw = (void *)buffer; b.frame_count = bytes / frameSize(); getPlaybackDelay(bytes / frameSize(), &b); mEchoReference->write(mEchoReference, &b); } TRACE_DRIVER_IN(DRV_PCM_WRITE) ret = pcm_write(mPcm,(void*) p, bytes); TRACE_DRIVER_OUT if (ret == 0) { //ALOGV("-----AudioStreamInALSA::write(%p, %d) END", buffer, (int)bytes); return bytes; } ALOGW("write error: %d", errno); status = -errno; } Error: standby(); // Simulate audio output timing in case of error usleep((((bytes * 1000) / frameSize()) * 1000) / sampleRate()); ALOGE("AudioStreamOutALSA::write END WITH ERROR !!!!!!!!!(%p, %u)", buffer, bytes); return status; } status_t AudioHardware::AudioStreamOutALSA::standby() { if (mHardware == NULL) return NO_INIT; mSleepReq = true; { AutoMutex lock(mLock); mSleepReq = false; { // scope for the AudioHardware lock AutoMutex hwLock(mHardware->lock()); doStandby_l(); } } return NO_ERROR; } void AudioHardware::AudioStreamOutALSA::doStandby_l() { mStandbyCnt++; if (!mStandby) { ALOGD("AudioHardware pcm playback is going to standby."); // stop echo reference capture if (mEchoReference != NULL) { mEchoReference->write(mEchoReference, NULL); } release_wake_lock("AudioOutLock"); mStandby = true; } close_l(); } void AudioHardware::AudioStreamOutALSA::close_l() { if (mMixer) { mHardware->closeMixer_l(); mMixer = NULL; mRouteCtl = NULL; } if (mPcm) { mHardware->closePcmOut_l(); mPcm = NULL; } } status_t AudioHardware::AudioStreamOutALSA::open_l() { ALOGV("open pcm_out driver"); mPcm = mHardware->openPcmOut_l(); if (mPcm == NULL) { return NO_INIT; } mMixer = mHardware->openMixer_l(); if (mMixer) { ALOGV("open playback normal"); TRACE_DRIVER_IN(DRV_MIXER_GET) mRouteCtl = mixer_get_ctl_by_name(mMixer, "Playback Path"); TRACE_DRIVER_OUT } if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { const char *route = mHardware->getOutputRouteFromDevice(mDevices); ALOGV("write() wakeup setting route %s", route); if (mRouteCtl) { TRACE_DRIVER_IN(DRV_MIXER_SEL) mixer_ctl_set_enum_by_string(mRouteCtl, route); TRACE_DRIVER_OUT } } return NO_ERROR; } status_t AudioHardware::AudioStreamOutALSA::dump(int fd, const Vector& args) { const size_t SIZE = 256; char buffer[SIZE]; String8 result; bool locked = tryLock(mLock); if (!locked) { snprintf(buffer, SIZE, "\n\t\tAudioStreamOutALSA maybe deadlocked\n"); } else { mLock.unlock(); } snprintf(buffer, SIZE, "\t\tmHardware: %p\n", mHardware); result.append(buffer); snprintf(buffer, SIZE, "\t\tmPcm: %p\n", mPcm); result.append(buffer); snprintf(buffer, SIZE, "\t\tmMixer: %p\n", mMixer); result.append(buffer); snprintf(buffer, SIZE, "\t\tmRouteCtl: %p\n", mRouteCtl); result.append(buffer); snprintf(buffer, SIZE, "\t\tStandby %s\n", (mStandby) ? "ON" : "OFF"); result.append(buffer); snprintf(buffer, SIZE, "\t\tmDevices: 0x%08x\n", mDevices); result.append(buffer); snprintf(buffer, SIZE, "\t\tmChannels: 0x%08x\n", mChannels); result.append(buffer); snprintf(buffer, SIZE, "\t\tmSampleRate: %d\n", mSampleRate); result.append(buffer); snprintf(buffer, SIZE, "\t\tmBufferSize: %d\n", mBufferSize); result.append(buffer); snprintf(buffer, SIZE, "\t\tmDriverOp: %d\n", mDriverOp); result.append(buffer); ::write(fd, result.string(), result.size()); return NO_ERROR; } bool AudioHardware::AudioStreamOutALSA::checkStandby() { return mStandby; } status_t AudioHardware::AudioStreamOutALSA::setParameters(const String8& keyValuePairs) { AudioParameter param = AudioParameter(keyValuePairs); status_t status = NO_ERROR; int device; ALOGD("AudioStreamOutALSA::setParameters() %s", keyValuePairs.string()); if (mHardware == NULL) return NO_INIT; mSleepReq = true; { AutoMutex lock(mLock); mSleepReq = false; if (param.getInt(String8(AudioParameter::keyRouting), device) == NO_ERROR) { if (device != 0) { AutoMutex hwLock(mHardware->lock()); if (mDevices != (uint32_t)device) { mDevices = (uint32_t)device; if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { doStandby_l(); } } if (mHardware->mode() == AudioSystem::MODE_IN_CALL) { mHardware->setIncallPath_l(device); } } param.remove(String8(AudioParameter::keyRouting)); } } if (param.size()) { status = BAD_VALUE; } return status; } String8 AudioHardware::AudioStreamOutALSA::getParameters(const String8& keys) { AudioParameter param = AudioParameter(keys); String8 value; String8 key = String8(AudioParameter::keyRouting); if (param.get(key, value) == NO_ERROR) { param.addInt(key, (int)mDevices); } ALOGV("AudioStreamOutALSA::getParameters() %s", param.toString().string()); return param.toString(); } status_t AudioHardware::AudioStreamOutALSA::getRenderPosition(uint32_t *dspFrames) { //TODO return INVALID_OPERATION; } int AudioHardware::AudioStreamOutALSA::prepareLock() { // request sleep next time write() is called so that caller can acquire // mLock mSleepReq = true; return mStandbyCnt; } void AudioHardware::AudioStreamOutALSA::lock() { mLock.lock(); mSleepReq = false; } void AudioHardware::AudioStreamOutALSA::unlock() { mLock.unlock(); } void AudioHardware::AudioStreamOutALSA::addEchoReference(struct echo_reference_itfe *reference) { ALOGV("AudioStreamOutALSA::addEchoReference %p", mEchoReference); if (mEchoReference == NULL) { mEchoReference = reference; } } void AudioHardware::AudioStreamOutALSA::removeEchoReference(struct echo_reference_itfe *reference) { ALOGV("AudioStreamOutALSA::removeEchoReference %p", mEchoReference); if (mEchoReference == reference) { mEchoReference->write(mEchoReference, NULL); mEchoReference = NULL; } } //------------------------------------------------------------------------------ // AudioStreamInALSA //------------------------------------------------------------------------------ AudioHardware::AudioStreamInALSA::AudioStreamInALSA() : mHardware(0), mPcm(0), mMixer(0), mRouteCtl(0), mStandby(true), mDevices(0), mChannels(AUDIO_HW_IN_CHANNELS), mChannelCount(1), mSampleRate(AUDIO_HW_IN_SAMPLERATE), mBufferSize(AUDIO_HW_IN_PERIOD_BYTES), mDownSampler(NULL), mReadStatus(NO_ERROR), mInputBuf(NULL), mDriverOp(DRV_NONE), mStandbyCnt(0), mSleepReq(false), mProcBuf(NULL), mProcBufSize(0), mRefBuf(NULL), mRefBufSize(0), mEchoReference(NULL), mNeedEchoReference(false) { } status_t AudioHardware::AudioStreamInALSA::set( AudioHardware* hw, uint32_t devices, int *pFormat, uint32_t *pChannels, uint32_t *pRate, AudioSystem::audio_in_acoustics acoustics) { if (pFormat == 0 || *pFormat != AUDIO_HW_IN_FORMAT) { *pFormat = AUDIO_HW_IN_FORMAT; return BAD_VALUE; } if (pRate == 0) { return BAD_VALUE; } uint32_t rate = AudioHardware::getInputSampleRate(*pRate); if (rate != *pRate) { *pRate = rate; return BAD_VALUE; } if (pChannels == 0 || (*pChannels != AudioSystem::CHANNEL_IN_MONO && *pChannels != AudioSystem::CHANNEL_IN_STEREO)) { *pChannels = AUDIO_HW_IN_CHANNELS; return BAD_VALUE; } mHardware = hw; ALOGV("AudioStreamInALSA::set(%d, %d, %u)", *pFormat, *pChannels, *pRate); mBufferSize = getBufferSize(*pRate, AudioSystem::popCount(*pChannels)); mDevices = devices; mChannels = *pChannels; mChannelCount = AudioSystem::popCount(mChannels); mSampleRate = rate; if (mSampleRate != AUDIO_HW_OUT_SAMPLERATE) { mBufferProvider.mProvider.get_next_buffer = getNextBufferStatic; mBufferProvider.mProvider.release_buffer = releaseBufferStatic; mBufferProvider.mInputStream = this; int status = create_resampler(AUDIO_HW_OUT_SAMPLERATE, mSampleRate, mChannelCount, RESAMPLER_QUALITY_VOIP, &mBufferProvider.mProvider, &mDownSampler); if (status != 0) { ALOGW("AudioStreamInALSA::set() downsampler init failed: %d", status); mDownSampler = NULL; return status; } } mInputBuf = new int16_t[AUDIO_HW_IN_PERIOD_SZ * mChannelCount]; return NO_ERROR; } AudioHardware::AudioStreamInALSA::~AudioStreamInALSA() { standby(); if (mDownSampler != NULL) { release_resampler(mDownSampler); } delete[] mInputBuf; delete[] mProcBuf; } // readFrames() reads frames from kernel driver, down samples to capture rate if necessary // and output the number of frames requested to the buffer specified ssize_t AudioHardware::AudioStreamInALSA::readFrames(void* buffer, ssize_t frames) { ssize_t framesWr = 0; while (framesWr < frames) { size_t framesRd = frames - framesWr; if (mDownSampler != NULL) { mDownSampler->resample_from_provider(mDownSampler, (int16_t *)((char *)buffer + framesWr * frameSize()), &framesRd); } else { struct resampler_buffer buf = { { raw : NULL, }, frame_count : framesRd, }; getNextBuffer(&buf); if (buf.raw != NULL) { memcpy((char *)buffer + framesWr * frameSize(), buf.raw, buf.frame_count * frameSize()); framesRd = buf.frame_count; } releaseBuffer(&buf); } // mReadStatus is updated by getNextBuffer() also called by // mDownSampler->resample_from_provider() if (mReadStatus != 0) { return mReadStatus; } framesWr += framesRd; } return framesWr; } // processFrames() reads frames from kernel driver (via readFrames()), calls the active // audio pre processings and output the number of frames requested to the buffer specified ssize_t AudioHardware::AudioStreamInALSA::processFrames(void* buffer, ssize_t frames) { ssize_t framesWr = 0; while (framesWr < frames) { // first reload enough frames at the end of process input buffer if (mProcFramesIn < (size_t)frames) { // expand process input buffer if necessary if (mProcBufSize < (size_t)frames) { mProcBufSize = (size_t)frames; mProcBuf = (int16_t *)realloc(mProcBuf, mProcBufSize * mChannelCount * sizeof(int16_t)); ALOGV("processFrames(): mProcBuf %p size extended to %d frames", mProcBuf, mProcBufSize); } ssize_t framesRd = readFrames(mProcBuf + mProcFramesIn * mChannelCount, frames - mProcFramesIn); if (framesRd < 0) { framesWr = framesRd; break; } mProcFramesIn += framesRd; } if (mEchoReference != NULL) { pushEchoReference(mProcFramesIn); } //inBuf.frameCount and outBuf.frameCount indicate respectively the maximum number of frames //to be consumed and produced by process() audio_buffer_t inBuf = { mProcFramesIn, {mProcBuf} }; audio_buffer_t outBuf = { frames - framesWr, {(int16_t *)buffer + framesWr * mChannelCount} }; for (size_t i = 0; i < mPreprocessors.size(); i++) { (*mPreprocessors[i])->process(mPreprocessors[i], &inBuf, &outBuf); } // process() has updated the number of frames consumed and produced in // inBuf.frameCount and outBuf.frameCount respectively // move remaining frames to the beginning of mProcBuf mProcFramesIn -= inBuf.frameCount; if (mProcFramesIn) { memcpy(mProcBuf, mProcBuf + inBuf.frameCount * mChannelCount, mProcFramesIn * mChannelCount * sizeof(int16_t)); } // if not enough frames were passed to process(), read more and retry. if (outBuf.frameCount == 0) { continue; } framesWr += outBuf.frameCount; } return framesWr; } int32_t AudioHardware::AudioStreamInALSA::updateEchoReference(size_t frames) { struct echo_reference_buffer b; b.delay_ns = 0; ALOGV("updateEchoReference1 START, frames = [%d], mRefFramesIn = [%d], b.frame_count = [%d]", frames, mRefFramesIn, frames - mRefFramesIn); if (mRefFramesIn < frames) { if (mRefBufSize < frames) { mRefBufSize = frames; mRefBuf = (int16_t *)realloc(mRefBuf, mRefBufSize * mChannelCount * sizeof(int16_t)); } b.frame_count = frames - mRefFramesIn; b.raw = (void *)(mRefBuf + mRefFramesIn * mChannelCount); getCaptureDelay(frames, &b); if (mEchoReference->read(mEchoReference, &b) == NO_ERROR) { mRefFramesIn += b.frame_count; ALOGV("updateEchoReference2: mRefFramesIn:[%d], mRefBufSize:[%d], "\ "frames:[%d], b.frame_count:[%d]", mRefFramesIn, mRefBufSize,frames,b.frame_count); } }else{ ALOGV("updateEchoReference3: NOT enough frames to read ref buffer"); } return b.delay_ns; } void AudioHardware::AudioStreamInALSA::pushEchoReference(size_t frames) { // read frames from echo reference buffer and update echo delay // mRefFramesIn is updated with frames available in mRefBuf int32_t delayUs = (int32_t)(updateEchoReference(frames)/1000); if (mRefFramesIn < frames) { frames = mRefFramesIn; } audio_buffer_t refBuf = { frames, {mRefBuf} }; for (size_t i = 0; i < mPreprocessors.size(); i++) { if ((*mPreprocessors[i])->process_reverse == NULL) { continue; } (*mPreprocessors[i])->process_reverse(mPreprocessors[i], &refBuf, NULL); setPreProcessorEchoDelay(mPreprocessors[i], delayUs); } mRefFramesIn -= refBuf.frameCount; if (mRefFramesIn) { ALOGV("pushEchoReference5: shifting mRefBuf down by = %d frames", mRefFramesIn); memcpy(mRefBuf, mRefBuf + refBuf.frameCount * mChannelCount, mRefFramesIn * mChannelCount * sizeof(int16_t)); } } status_t AudioHardware::AudioStreamInALSA::setPreProcessorEchoDelay(effect_handle_t handle, int32_t delayUs) { uint32_t buf[sizeof(effect_param_t) / sizeof(uint32_t) + 2]; effect_param_t *param = (effect_param_t *)buf; param->psize = sizeof(uint32_t); param->vsize = sizeof(uint32_t); *(uint32_t *)param->data = AEC_PARAM_ECHO_DELAY; *((int32_t *)param->data + 1) = delayUs; ALOGV("setPreProcessorEchoDelay: %d us", delayUs); return setPreprocessorParam(handle, param); } status_t AudioHardware::AudioStreamInALSA::setPreprocessorParam(effect_handle_t handle, effect_param_t *param) { uint32_t size = sizeof(int); uint32_t psize = ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + param->vsize; status_t status = (*handle)->command(handle, EFFECT_CMD_SET_PARAM, sizeof (effect_param_t) + psize, param, &size, ¶m->status); if (status == NO_ERROR) { status = param->status; } return status; } void AudioHardware::AudioStreamInALSA::getCaptureDelay(size_t frames, struct echo_reference_buffer *buffer) { // read frames available in kernel driver buffer size_t kernelFr; struct timespec tstamp; if (pcm_get_htimestamp(mPcm, &kernelFr, &tstamp) < 0) { buffer->time_stamp.tv_sec = 0; buffer->time_stamp.tv_nsec = 0; buffer->delay_ns = 0; ALOGW("read getCaptureDelay(): pcm_htimestamp error"); return; } // read frames available in audio HAL input buffer // add number of frames being read as we want the capture time of first sample in current // buffer long bufDelay = (long)(((int64_t)(mInputFramesIn + mProcFramesIn) * 1000000000) / AUDIO_HW_IN_SAMPLERATE); // add delay introduced by resampler long rsmpDelay = 0; if (mDownSampler) { rsmpDelay = mDownSampler->delay_ns(mDownSampler); } long kernelDelay = (long)(((int64_t)kernelFr * 1000000000) / AUDIO_HW_IN_SAMPLERATE); // correct capture time stamp long delayNs = kernelDelay + bufDelay + rsmpDelay; buffer->time_stamp = tstamp; buffer->delay_ns = delayNs; ALOGV("AudioStreamInALSA::getCaptureDelay TimeStamp = [%ld].[%ld], delayCaptureNs: [%d],"\ " kernelDelay:[%ld], bufDelay:[%ld], rsmpDelay:[%ld], kernelFr:[%d], "\ "mInputFramesIn:[%d], mProcFramesIn:[%d], frames:[%d]", buffer->time_stamp.tv_sec , buffer->time_stamp.tv_nsec, buffer->delay_ns, kernelDelay, bufDelay, rsmpDelay, kernelFr, mInputFramesIn, mProcFramesIn, frames); } ssize_t AudioHardware::AudioStreamInALSA::read(void* buffer, ssize_t bytes) { //ALOGV("-----AudioStreamInALSA::read(%p, %d) START", buffer, (int)bytes); status_t status = NO_INIT; if (mHardware == NULL) return NO_INIT; if (mSleepReq) { // 10ms are always shorter than the time to reconfigure the audio path // which is the only condition when mSleepReq would be true. usleep(10000); } { // scope for the lock AutoMutex lock(mLock); if (mStandby) { AutoMutex hwLock(mHardware->lock()); ALOGD("AudioHardware pcm capture is exiting standby."); sp spOut = mHardware->output(); while (spOut != 0) { spOut->prepareLock(); mHardware->lock().unlock(); mLock.unlock(); // Mutex acquisition order is always out -> in -> hw spOut->lock(); mLock.lock(); mHardware->lock().lock(); // make sure that another thread did not change output state // while the mutex is released if (spOut == mHardware->output()) { break; } spOut->unlock(); spOut = mHardware->output(); } // open output before input if (spOut != 0) { if (!spOut->checkStandby()) { ALOGV("AudioStreamInALSA::read() force output standby"); spOut->close_l(); if (spOut->open_l() != NO_ERROR) { spOut->doStandby_l(); } } ALOGV("AudioStreamInALSA exit standby mNeedEchoReference %d mEchoReference %p", mNeedEchoReference, mEchoReference); if (mNeedEchoReference && mEchoReference == NULL) { mEchoReference = mHardware->getEchoReference(AUDIO_FORMAT_PCM_16_BIT, mChannelCount, mSampleRate); } spOut->unlock(); } open_l(); if (mPcm == NULL) { goto Error; } mStandby = false; } size_t framesRq = bytes / mChannelCount/sizeof(int16_t); ssize_t framesRd; if (mPreprocessors.size() == 0) { framesRd = readFrames(buffer, framesRq); } else { framesRd = processFrames(buffer, framesRq); } if (framesRd >= 0) { //ALOGV("-----AudioStreamInALSA::read(%p, %d) END", buffer, (int)bytes); return framesRd * mChannelCount * sizeof(int16_t); } ALOGW("read error: %d", (int)framesRd); status = framesRd; } Error: standby(); // Simulate audio output timing in case of error usleep((((bytes * 1000) / frameSize()) * 1000) / sampleRate()); ALOGE("-----AudioStreamInALSA::read(%p, %d) END ERROR", buffer, (int)bytes); return status; } status_t AudioHardware::AudioStreamInALSA::standby() { if (mHardware == NULL) return NO_INIT; mSleepReq = true; { AutoMutex lock(mLock); mSleepReq = false; { // scope for AudioHardware lock AutoMutex hwLock(mHardware->lock()); doStandby_l(); } } return NO_ERROR; } void AudioHardware::AudioStreamInALSA::doStandby_l() { mStandbyCnt++; if (!mStandby) { ALOGD("AudioHardware pcm capture is going to standby."); if (mEchoReference != NULL) { // stop reading from echo reference mEchoReference->read(mEchoReference, NULL); // Mutex acquisition order is always out -> in -> hw sp spOut = mHardware->output(); if (spOut != 0) { spOut->prepareLock(); mHardware->lock().unlock(); mLock.unlock(); spOut->lock(); mLock.lock(); mHardware->lock().lock(); mHardware->releaseEchoReference(mEchoReference); spOut->unlock(); } mEchoReference = NULL; } mStandby = true; } close_l(); } void AudioHardware::AudioStreamInALSA::close_l() { if (mMixer) { mHardware->closeMixer_l(); mMixer = NULL; mRouteCtl = NULL; } if (mPcm) { TRACE_DRIVER_IN(DRV_PCM_CLOSE) pcm_close(mPcm); TRACE_DRIVER_OUT mPcm = NULL; } delete[] mProcBuf; mProcBuf = NULL; mProcBufSize = 0; delete[] mRefBuf; mRefBuf = NULL; mRefBufSize = 0; } status_t AudioHardware::AudioStreamInALSA::open_l() { unsigned flags = PCM_IN; struct pcm_config config = { channels : mChannelCount, rate : AUDIO_HW_IN_SAMPLERATE, period_size : AUDIO_HW_IN_PERIOD_SZ, period_count : AUDIO_HW_IN_PERIOD_CNT, format : PCM_FORMAT_S16_LE, start_threshold : 0, stop_threshold : 0, silence_threshold : 0, }; ALOGV("open pcm_in driver"); TRACE_DRIVER_IN(DRV_PCM_OPEN) mPcm = pcm_open(0, 0, flags, &config); TRACE_DRIVER_OUT if (!pcm_is_ready(mPcm)) { ALOGE("cannot open pcm_in driver: %s\n", pcm_get_error(mPcm)); TRACE_DRIVER_IN(DRV_PCM_CLOSE) pcm_close(mPcm); TRACE_DRIVER_OUT mPcm = NULL; return NO_INIT; } if (mDownSampler != NULL) { mDownSampler->reset(mDownSampler); } mInputFramesIn = 0; mProcBufSize = 0; mProcFramesIn = 0; mRefBufSize = 0; mRefFramesIn = 0; mMixer = mHardware->openMixer_l(); if (mMixer) { TRACE_DRIVER_IN(DRV_MIXER_GET) mRouteCtl = mixer_get_ctl_by_name(mMixer, "Capture MIC Path"); TRACE_DRIVER_OUT } if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { const char *route = mHardware->getInputRouteFromDevice(mDevices); ALOGV("read() wakeup setting route %s", route); if (mRouteCtl) { TRACE_DRIVER_IN(DRV_MIXER_SEL) mixer_ctl_set_enum_by_string(mRouteCtl, route); TRACE_DRIVER_OUT } } return NO_ERROR; } status_t AudioHardware::AudioStreamInALSA::dump(int fd, const Vector& args) { const size_t SIZE = 256; char buffer[SIZE]; String8 result; bool locked = tryLock(mLock); if (!locked) { snprintf(buffer, SIZE, "\n\t\tAudioStreamInALSA maybe deadlocked\n"); } else { mLock.unlock(); } snprintf(buffer, SIZE, "\t\tmHardware: %p\n", mHardware); result.append(buffer); snprintf(buffer, SIZE, "\t\tmPcm: %p\n", mPcm); result.append(buffer); snprintf(buffer, SIZE, "\t\tmMixer: %p\n", mMixer); result.append(buffer); snprintf(buffer, SIZE, "\t\tStandby %s\n", (mStandby) ? "ON" : "OFF"); result.append(buffer); snprintf(buffer, SIZE, "\t\tmDevices: 0x%08x\n", mDevices); result.append(buffer); snprintf(buffer, SIZE, "\t\tmChannels: 0x%08x\n", mChannels); result.append(buffer); snprintf(buffer, SIZE, "\t\tmSampleRate: %d\n", mSampleRate); result.append(buffer); snprintf(buffer, SIZE, "\t\tmBufferSize: %d\n", mBufferSize); result.append(buffer); snprintf(buffer, SIZE, "\t\tmDriverOp: %d\n", mDriverOp); result.append(buffer); write(fd, result.string(), result.size()); return NO_ERROR; } bool AudioHardware::AudioStreamInALSA::checkStandby() { return mStandby; } status_t AudioHardware::AudioStreamInALSA::setParameters(const String8& keyValuePairs) { AudioParameter param = AudioParameter(keyValuePairs); status_t status = NO_ERROR; int value; ALOGD("AudioStreamInALSA::setParameters() %s", keyValuePairs.string()); if (mHardware == NULL) return NO_INIT; mSleepReq = true; { AutoMutex lock(mLock); mSleepReq = false; if (param.getInt(String8(AudioParameter::keyInputSource), value) == NO_ERROR) { AutoMutex hwLock(mHardware->lock()); mHardware->openMixer_l(); mHardware->setInputSource_l((audio_source)value); mHardware->closeMixer_l(); param.remove(String8(AudioParameter::keyInputSource)); } if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) { if (value != 0) { AutoMutex hwLock(mHardware->lock()); if (mDevices != (uint32_t)value) { mDevices = (uint32_t)value; if (mHardware->mode() != AudioSystem::MODE_IN_CALL) { doStandby_l(); } } } param.remove(String8(AudioParameter::keyRouting)); } } if (param.size()) { status = BAD_VALUE; } return status; } String8 AudioHardware::AudioStreamInALSA::getParameters(const String8& keys) { AudioParameter param = AudioParameter(keys); String8 value; String8 key = String8(AudioParameter::keyRouting); if (param.get(key, value) == NO_ERROR) { param.addInt(key, (int)mDevices); } ALOGV("AudioStreamInALSA::getParameters() %s", param.toString().string()); return param.toString(); } status_t AudioHardware::AudioStreamInALSA::addAudioEffect(effect_handle_t effect) { ALOGV("AudioStreamInALSA::addAudioEffect() %p", effect); effect_descriptor_t desc; status_t status = (*effect)->get_descriptor(effect, &desc); if (status == 0) { if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) { ALOGV("AudioStreamInALSA::addAudioEffect() mNeedEchoReference true"); mNeedEchoReference = true; standby(); } ALOGV("AudioStreamInALSA::addAudioEffect() name %s", desc.name); } else { ALOGV("AudioStreamInALSA::addAudioEffect() get_descriptor() error"); } AutoMutex lock(mLock); mPreprocessors.add(effect); return NO_ERROR; } status_t AudioHardware::AudioStreamInALSA::removeAudioEffect(effect_handle_t effect) { status_t status = INVALID_OPERATION; ALOGV("AudioStreamInALSA::removeAudioEffect() %p", effect); { AutoMutex lock(mLock); for (size_t i = 0; i < mPreprocessors.size(); i++) { if (mPreprocessors[i] == effect) { mPreprocessors.removeAt(i); status = NO_ERROR; break; } } } if (status == NO_ERROR) { effect_descriptor_t desc; if ((*effect)->get_descriptor(effect, &desc) == 0) { if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) { ALOGV("AudioStreamInALSA::removeAudioEffect() mNeedEchoReference false"); mNeedEchoReference = false; standby(); } } } return status; } extern "C" { int AudioHardware::AudioStreamInALSA::getNextBufferStatic( struct resampler_buffer_provider *provider, struct resampler_buffer* buffer) { ResamplerBufferProvider *bufferProvider = (ResamplerBufferProvider *)provider; return bufferProvider->mInputStream->getNextBuffer(buffer); } void AudioHardware::AudioStreamInALSA::releaseBufferStatic( struct resampler_buffer_provider *provider, struct resampler_buffer* buffer) { ResamplerBufferProvider *bufferProvider = (ResamplerBufferProvider *)provider; return bufferProvider->mInputStream->releaseBuffer(buffer); } }; // extern "C" status_t AudioHardware::AudioStreamInALSA::getNextBuffer(struct resampler_buffer *buffer) { if (mPcm == NULL) { buffer->raw = NULL; buffer->frame_count = 0; mReadStatus = NO_INIT; return NO_INIT; } if (mInputFramesIn == 0) { TRACE_DRIVER_IN(DRV_PCM_READ) mReadStatus = pcm_read(mPcm,(void*) mInputBuf, AUDIO_HW_IN_PERIOD_SZ * frameSize()); TRACE_DRIVER_OUT if (mReadStatus != 0) { buffer->raw = NULL; buffer->frame_count = 0; return mReadStatus; } mInputFramesIn = AUDIO_HW_IN_PERIOD_SZ; } buffer->frame_count = (buffer->frame_count > mInputFramesIn) ? mInputFramesIn:buffer->frame_count; buffer->i16 = mInputBuf + (AUDIO_HW_IN_PERIOD_SZ - mInputFramesIn) * mChannelCount; return mReadStatus; } void AudioHardware::AudioStreamInALSA::releaseBuffer(struct resampler_buffer *buffer) { mInputFramesIn -= buffer->frame_count; } size_t AudioHardware::AudioStreamInALSA::getBufferSize(uint32_t sampleRate, int channelCount) { size_t i; size_t size = sizeof(inputConfigTable)/sizeof(uint32_t)/INPUT_CONFIG_CNT; for (i = 0; i < size; i++) { if (sampleRate == inputConfigTable[i][INPUT_CONFIG_SAMPLE_RATE]) { return (AUDIO_HW_IN_PERIOD_SZ*channelCount*sizeof(int16_t)) / inputConfigTable[i][INPUT_CONFIG_BUFFER_RATIO]; } } // this should never happen as getBufferSize() is always called after getInputSampleRate() // that checks for valid sampling rates. ALOGE("AudioStreamInALSA::getBufferSize() invalid sampling rate %d", sampleRate); return 0; } int AudioHardware::AudioStreamInALSA::prepareLock() { // request sleep next time read() is called so that caller can acquire // mLock mSleepReq = true; return mStandbyCnt; } void AudioHardware::AudioStreamInALSA::lock() { mLock.lock(); mSleepReq = false; } void AudioHardware::AudioStreamInALSA::unlock() { mLock.unlock(); } //------------------------------------------------------------------------------ // Factory //------------------------------------------------------------------------------ extern "C" AudioHardwareInterface* createAudioHardware(void) { return new AudioHardware(); } }; // namespace android