1 /*
2 ** Copyright 2010, The Android Open-Source Project
3 **
4 ** Licensed under the Apache License, Version 2.0 (the "License");
5 ** you may not use this file except in compliance with the License.
6 ** You may obtain a copy of the License at
7 **
8 ** http://www.apache.org/licenses/LICENSE-2.0
9 **
10 ** Unless required by applicable law or agreed to in writing, software
11 ** distributed under the License is distributed on an "AS IS" BASIS,
12 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 ** See the License for the specific language governing permissions and
14 ** limitations under the License.
15 */
16
17 #include <math.h>
18
19 //#define LOG_NDEBUG 0
20 #define LOG_TAG "AudioHardware"
21
22 #include <utils/Log.h>
23 #include <utils/String8.h>
24
25 #include <stdio.h>
26 #include <unistd.h>
27 #include <sys/ioctl.h>
28 #include <sys/types.h>
29 #include <sys/stat.h>
30 #include <sys/resource.h>
31 #include <dlfcn.h>
32 #include <fcntl.h>
33
34 #include "AudioHardware.h"
35 #include <audio_effects/effect_aec.h>
36
37 extern "C" {
38 #include <tinyalsa/asoundlib.h>
39 }
40
41
42 namespace android_audio_legacy {
43
44 const uint32_t AudioHardware::inputConfigTable[][AudioHardware::INPUT_CONFIG_CNT] = {
45 {8000, 4},
46 {11025, 4},
47 {16000, 2},
48 {22050, 2},
49 {32000, 1},
50 {44100, 1}
51 };
52
53 // trace driver operations for dump
54 //
55 #define DRIVER_TRACE
56
57 enum {
58 DRV_NONE,
59 DRV_PCM_OPEN,
60 DRV_PCM_CLOSE,
61 DRV_PCM_WRITE,
62 DRV_PCM_READ,
63 DRV_MIXER_OPEN,
64 DRV_MIXER_CLOSE,
65 DRV_MIXER_GET,
66 DRV_MIXER_SEL
67 };
68
69 #ifdef DRIVER_TRACE
70 #define TRACE_DRIVER_IN(op) mDriverOp = op;
71 #define TRACE_DRIVER_OUT mDriverOp = DRV_NONE;
72 #else
73 #define TRACE_DRIVER_IN(op)
74 #define TRACE_DRIVER_OUT
75 #endif
76
77 // ----------------------------------------------------------------------------
78
79 const char *AudioHardware::inputPathNameDefault = "Default";
80 const char *AudioHardware::inputPathNameCamcorder = "Camcorder";
81 const char *AudioHardware::inputPathNameVoiceRecognition = "Voice Recognition";
82
AudioHardware()83 AudioHardware::AudioHardware() :
84 mInit(false),
85 mMicMute(false),
86 mPcm(NULL),
87 mMixer(NULL),
88 mPcmOpenCnt(0),
89 mMixerOpenCnt(0),
90 mInCallAudioMode(false),
91 mVoiceVol(1.0f),
92 mInputSource(AUDIO_SOURCE_DEFAULT),
93 mBluetoothNrec(true),
94 mTTYMode(TTY_MODE_OFF),
95 mSecRilLibHandle(NULL),
96 mRilClient(0),
97 mActivatedCP(false),
98 mEchoReference(NULL),
99 mDriverOp(DRV_NONE)
100 {
101 loadRILD();
102 mInit = true;
103 }
104
~AudioHardware()105 AudioHardware::~AudioHardware()
106 {
107 for (size_t index = 0; index < mInputs.size(); index++) {
108 closeInputStream(mInputs[index].get());
109 }
110 mInputs.clear();
111 closeOutputStream((AudioStreamOut*)mOutput.get());
112
113 if (mMixer) {
114 TRACE_DRIVER_IN(DRV_MIXER_CLOSE)
115 mixer_close(mMixer);
116 TRACE_DRIVER_OUT
117 }
118 if (mPcm) {
119 TRACE_DRIVER_IN(DRV_PCM_CLOSE)
120 pcm_close(mPcm);
121 TRACE_DRIVER_OUT
122 }
123
124 if (mSecRilLibHandle) {
125 if (disconnectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS)
126 ALOGE("Disconnect_RILD() error");
127
128 if (closeClientRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS)
129 ALOGE("CloseClient_RILD() error");
130
131 mRilClient = 0;
132
133 dlclose(mSecRilLibHandle);
134 mSecRilLibHandle = NULL;
135 }
136
137 mInit = false;
138 }
139
initCheck()140 status_t AudioHardware::initCheck()
141 {
142 return mInit ? NO_ERROR : NO_INIT;
143 }
144
loadRILD(void)145 void AudioHardware::loadRILD(void)
146 {
147 mSecRilLibHandle = dlopen("libsecril-client.so", RTLD_NOW);
148
149 if (mSecRilLibHandle) {
150 ALOGV("libsecril-client.so is loaded");
151
152 openClientRILD = (HRilClient (*)(void))
153 dlsym(mSecRilLibHandle, "OpenClient_RILD");
154 disconnectRILD = (int (*)(HRilClient))
155 dlsym(mSecRilLibHandle, "Disconnect_RILD");
156 closeClientRILD = (int (*)(HRilClient))
157 dlsym(mSecRilLibHandle, "CloseClient_RILD");
158 isConnectedRILD = (int (*)(HRilClient))
159 dlsym(mSecRilLibHandle, "isConnected_RILD");
160 connectRILD = (int (*)(HRilClient))
161 dlsym(mSecRilLibHandle, "Connect_RILD");
162 setCallVolume = (int (*)(HRilClient, SoundType, int))
163 dlsym(mSecRilLibHandle, "SetCallVolume");
164 setCallAudioPath = (int (*)(HRilClient, AudioPath))
165 dlsym(mSecRilLibHandle, "SetCallAudioPath");
166 setCallClockSync = (int (*)(HRilClient, SoundClockCondition))
167 dlsym(mSecRilLibHandle, "SetCallClockSync");
168
169 if (!openClientRILD || !disconnectRILD || !closeClientRILD ||
170 !isConnectedRILD || !connectRILD ||
171 !setCallVolume || !setCallAudioPath || !setCallClockSync) {
172 ALOGE("Can't load all functions from libsecril-client.so");
173
174 dlclose(mSecRilLibHandle);
175 mSecRilLibHandle = NULL;
176 } else {
177 mRilClient = openClientRILD();
178 if (!mRilClient) {
179 ALOGE("OpenClient_RILD() error");
180
181 dlclose(mSecRilLibHandle);
182 mSecRilLibHandle = NULL;
183 }
184 }
185 } else {
186 ALOGE("Can't load libsecril-client.so");
187 }
188 }
189
connectRILDIfRequired(void)190 status_t AudioHardware::connectRILDIfRequired(void)
191 {
192 if (!mSecRilLibHandle) {
193 ALOGE("connectIfRequired() lib is not loaded");
194 return INVALID_OPERATION;
195 }
196
197 if (isConnectedRILD(mRilClient)) {
198 return OK;
199 }
200
201 if (connectRILD(mRilClient) != RIL_CLIENT_ERR_SUCCESS) {
202 ALOGE("Connect_RILD() error");
203 return INVALID_OPERATION;
204 }
205
206 return OK;
207 }
208
openOutputStream(uint32_t devices,int * format,uint32_t * channels,uint32_t * sampleRate,status_t * status)209 AudioStreamOut* AudioHardware::openOutputStream(
210 uint32_t devices, int *format, uint32_t *channels,
211 uint32_t *sampleRate, status_t *status)
212 {
213 sp <AudioStreamOutALSA> out;
214 status_t rc;
215
216 { // scope for the lock
217 Mutex::Autolock lock(mLock);
218
219 // only one output stream allowed
220 if (mOutput != 0) {
221 if (status) {
222 *status = INVALID_OPERATION;
223 }
224 return NULL;
225 }
226
227 out = new AudioStreamOutALSA();
228
229 rc = out->set(this, devices, format, channels, sampleRate);
230 if (rc == NO_ERROR) {
231 mOutput = out;
232 }
233 }
234
235 if (rc != NO_ERROR) {
236 if (out != 0) {
237 out.clear();
238 }
239 }
240 if (status) {
241 *status = rc;
242 }
243
244 return out.get();
245 }
246
closeOutputStream(AudioStreamOut * out)247 void AudioHardware::closeOutputStream(AudioStreamOut* out) {
248 sp <AudioStreamOutALSA> spOut;
249 sp<AudioStreamInALSA> spIn;
250 {
251 Mutex::Autolock lock(mLock);
252 if (mOutput == 0 || mOutput.get() != out) {
253 ALOGW("Attempt to close invalid output stream");
254 return;
255 }
256 spOut = mOutput;
257 mOutput.clear();
258 if (mEchoReference != NULL) {
259 spIn = getActiveInput_l();
260 }
261 }
262 if (spIn != 0) {
263 // this will safely release the echo reference by calling releaseEchoReference()
264 // after placing the active input in standby
265 spIn->standby();
266 }
267
268 spOut.clear();
269 }
270
openInputStream(uint32_t devices,int * format,uint32_t * channels,uint32_t * sampleRate,status_t * status,AudioSystem::audio_in_acoustics acoustic_flags)271 AudioStreamIn* AudioHardware::openInputStream(
272 uint32_t devices, int *format, uint32_t *channels,
273 uint32_t *sampleRate, status_t *status,
274 AudioSystem::audio_in_acoustics acoustic_flags)
275 {
276 // check for valid input source
277 if (!AudioSystem::isInputDevice((AudioSystem::audio_devices)devices)) {
278 if (status) {
279 *status = BAD_VALUE;
280 }
281 return NULL;
282 }
283
284 status_t rc = NO_ERROR;
285 sp <AudioStreamInALSA> in;
286
287 { // scope for the lock
288 Mutex::Autolock lock(mLock);
289
290 in = new AudioStreamInALSA();
291 rc = in->set(this, devices, format, channels, sampleRate, acoustic_flags);
292 if (rc == NO_ERROR) {
293 mInputs.add(in);
294 }
295 }
296
297 if (rc != NO_ERROR) {
298 if (in != 0) {
299 in.clear();
300 }
301 }
302 if (status) {
303 *status = rc;
304 }
305
306 ALOGV("AudioHardware::openInputStream()%p", in.get());
307 return in.get();
308 }
309
closeInputStream(AudioStreamIn * in)310 void AudioHardware::closeInputStream(AudioStreamIn* in) {
311
312 sp<AudioStreamInALSA> spIn;
313 {
314 Mutex::Autolock lock(mLock);
315
316 ssize_t index = mInputs.indexOf((AudioStreamInALSA *)in);
317 if (index < 0) {
318 ALOGW("Attempt to close invalid input stream");
319 return;
320 }
321 spIn = mInputs[index];
322 mInputs.removeAt(index);
323 }
324 ALOGV("AudioHardware::closeInputStream()%p", in);
325 spIn.clear();
326 }
327
328
setMode(int mode)329 status_t AudioHardware::setMode(int mode)
330 {
331 sp<AudioStreamOutALSA> spOut;
332 sp<AudioStreamInALSA> spIn;
333 status_t status;
334
335 // Mutex acquisition order is always out -> in -> hw
336 AutoMutex lock(mLock);
337
338 spOut = mOutput;
339 while (spOut != 0) {
340 if (!spOut->checkStandby()) {
341 int cnt = spOut->prepareLock();
342 mLock.unlock();
343 spOut->lock();
344 mLock.lock();
345 // make sure that another thread did not change output state while the
346 // mutex is released
347 if ((spOut == mOutput) && (cnt == spOut->standbyCnt())) {
348 break;
349 }
350 spOut->unlock();
351 spOut = mOutput;
352 } else {
353 spOut.clear();
354 }
355 }
356 // spOut is not 0 here only if the output is active
357
358 spIn = getActiveInput_l();
359 while (spIn != 0) {
360 int cnt = spIn->prepareLock();
361 mLock.unlock();
362 spIn->lock();
363 mLock.lock();
364 // make sure that another thread did not change input state while the
365 // mutex is released
366 if ((spIn == getActiveInput_l()) && (cnt == spIn->standbyCnt())) {
367 break;
368 }
369 spIn->unlock();
370 spIn = getActiveInput_l();
371 }
372 // spIn is not 0 here only if the input is active
373
374 int prevMode = mMode;
375 status = AudioHardwareBase::setMode(mode);
376 ALOGV("setMode() : new %d, old %d", mMode, prevMode);
377 if (status == NO_ERROR) {
378 bool modeNeedsCPActive = mMode == AudioSystem::MODE_IN_CALL ||
379 mMode == AudioSystem::MODE_RINGTONE;
380 // activate call clock in radio when entering in call or ringtone mode
381 if (modeNeedsCPActive)
382 {
383 if ((!mActivatedCP) && (mSecRilLibHandle) && (connectRILDIfRequired() == OK)) {
384 setCallClockSync(mRilClient, SOUND_CLOCK_START);
385 mActivatedCP = true;
386 }
387 }
388
389 if (mMode == AudioSystem::MODE_IN_CALL && !mInCallAudioMode) {
390 if (spOut != 0) {
391 ALOGV("setMode() in call force output standby");
392 spOut->doStandby_l();
393 }
394 if (spIn != 0) {
395 ALOGV("setMode() in call force input standby");
396 spIn->doStandby_l();
397 }
398
399 ALOGV("setMode() openPcmOut_l()");
400 openPcmOut_l();
401 openMixer_l();
402 setInputSource_l(AUDIO_SOURCE_DEFAULT);
403 setVoiceVolume_l(mVoiceVol);
404 mInCallAudioMode = true;
405 }
406 if (mMode != AudioSystem::MODE_IN_CALL && mInCallAudioMode) {
407 setInputSource_l(mInputSource);
408 if (mMixer != NULL) {
409 TRACE_DRIVER_IN(DRV_MIXER_GET)
410 struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer, "Playback Path");
411 TRACE_DRIVER_OUT
412 if (ctl != NULL) {
413 ALOGV("setMode() reset Playback Path to RCV");
414 TRACE_DRIVER_IN(DRV_MIXER_SEL)
415 mixer_ctl_set_enum_by_string(ctl, "RCV");
416 TRACE_DRIVER_OUT
417 }
418 }
419 ALOGV("setMode() closePcmOut_l()");
420 closeMixer_l();
421 closePcmOut_l();
422
423 if (spOut != 0) {
424 ALOGV("setMode() off call force output standby");
425 spOut->doStandby_l();
426 }
427 if (spIn != 0) {
428 ALOGV("setMode() off call force input standby");
429 spIn->doStandby_l();
430 }
431
432 mInCallAudioMode = false;
433 }
434
435 if (!modeNeedsCPActive) {
436 if(mActivatedCP)
437 mActivatedCP = false;
438 }
439 }
440
441 if (spIn != 0) {
442 spIn->unlock();
443 }
444 if (spOut != 0) {
445 spOut->unlock();
446 }
447
448 return status;
449 }
450
setMicMute(bool state)451 status_t AudioHardware::setMicMute(bool state)
452 {
453 ALOGV("setMicMute(%d) mMicMute %d", state, mMicMute);
454 sp<AudioStreamInALSA> spIn;
455 {
456 AutoMutex lock(mLock);
457 if (mMicMute != state) {
458 mMicMute = state;
459 // in call mute is handled by RIL
460 if (mMode != AudioSystem::MODE_IN_CALL) {
461 spIn = getActiveInput_l();
462 }
463 }
464 }
465
466 if (spIn != 0) {
467 spIn->standby();
468 }
469
470 return NO_ERROR;
471 }
472
getMicMute(bool * state)473 status_t AudioHardware::getMicMute(bool* state)
474 {
475 *state = mMicMute;
476 return NO_ERROR;
477 }
478
setParameters(const String8 & keyValuePairs)479 status_t AudioHardware::setParameters(const String8& keyValuePairs)
480 {
481 AudioParameter param = AudioParameter(keyValuePairs);
482 String8 value;
483 String8 key;
484 const char BT_NREC_KEY[] = "bt_headset_nrec";
485 const char BT_NREC_VALUE_ON[] = "on";
486 const char TTY_MODE_KEY[] = "tty_mode";
487 const char TTY_MODE_VALUE_OFF[] = "tty_off";
488 const char TTY_MODE_VALUE_VCO[] = "tty_vco";
489 const char TTY_MODE_VALUE_HCO[] = "tty_hco";
490 const char TTY_MODE_VALUE_FULL[] = "tty_full";
491
492 key = String8(BT_NREC_KEY);
493 if (param.get(key, value) == NO_ERROR) {
494 if (value == BT_NREC_VALUE_ON) {
495 mBluetoothNrec = true;
496 } else {
497 mBluetoothNrec = false;
498 ALOGD("Turning noise reduction and echo cancellation off for BT "
499 "headset");
500 }
501 param.remove(String8(BT_NREC_KEY));
502 }
503
504 key = String8(TTY_MODE_KEY);
505 if (param.get(key, value) == NO_ERROR) {
506 int ttyMode;
507 if (value == TTY_MODE_VALUE_OFF) {
508 ttyMode = TTY_MODE_OFF;
509 } else if (value == TTY_MODE_VALUE_VCO) {
510 ttyMode = TTY_MODE_VCO;
511 } else if (value == TTY_MODE_VALUE_HCO) {
512 ttyMode = TTY_MODE_HCO;
513 } else if (value == TTY_MODE_VALUE_FULL) {
514 ttyMode = TTY_MODE_FULL;
515 } else {
516 return BAD_VALUE;
517 }
518
519 if (ttyMode != mTTYMode) {
520 ALOGV("new tty mode %d", ttyMode);
521 mTTYMode = ttyMode;
522 if (mOutput != 0 && mMode == AudioSystem::MODE_IN_CALL) {
523 setIncallPath_l(mOutput->device());
524 }
525 }
526 param.remove(String8(TTY_MODE_KEY));
527 }
528
529 return NO_ERROR;
530 }
531
getParameters(const String8 & keys)532 String8 AudioHardware::getParameters(const String8& keys)
533 {
534 AudioParameter request = AudioParameter(keys);
535 AudioParameter reply = AudioParameter();
536
537 ALOGV("getParameters() %s", keys.string());
538
539 return reply.toString();
540 }
541
getInputBufferSize(uint32_t sampleRate,int format,int channelCount)542 size_t AudioHardware::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
543 {
544 if (format != AudioSystem::PCM_16_BIT) {
545 ALOGW("getInputBufferSize bad format: %d", format);
546 return 0;
547 }
548 if (channelCount < 1 || channelCount > 2) {
549 ALOGW("getInputBufferSize bad channel count: %d", channelCount);
550 return 0;
551 }
552
553 if (sampleRate != getInputSampleRate(sampleRate)) {
554 ALOGW("getInputBufferSize bad sample rate: %d", sampleRate);
555 return 0;
556 }
557
558 return AudioStreamInALSA::getBufferSize(sampleRate, channelCount);
559 }
560
setVoiceVolume(float volume)561 status_t AudioHardware::setVoiceVolume(float volume)
562 {
563 AutoMutex lock(mLock);
564
565 setVoiceVolume_l(volume);
566
567 return NO_ERROR;
568 }
569
setVoiceVolume_l(float volume)570 void AudioHardware::setVoiceVolume_l(float volume)
571 {
572 ALOGD("### setVoiceVolume_l");
573
574 mVoiceVol = volume;
575
576 if ( (AudioSystem::MODE_IN_CALL == mMode) && (mSecRilLibHandle) &&
577 (connectRILDIfRequired() == OK) ) {
578
579 uint32_t device = AudioSystem::DEVICE_OUT_EARPIECE;
580 if (mOutput != 0) {
581 device = mOutput->device();
582 }
583 int int_volume = (int)(volume * 5);
584 SoundType type;
585
586 ALOGD("### route(%d) call volume(%f)", device, volume);
587 switch (device) {
588 case AudioSystem::DEVICE_OUT_EARPIECE:
589 ALOGD("### earpiece call volume");
590 type = SOUND_TYPE_VOICE;
591 break;
592
593 case AudioSystem::DEVICE_OUT_SPEAKER:
594 ALOGD("### speaker call volume");
595 type = SOUND_TYPE_SPEAKER;
596 break;
597
598 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO:
599 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET:
600 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT:
601 ALOGD("### bluetooth call volume");
602 type = SOUND_TYPE_BTVOICE;
603 break;
604
605 case AudioSystem::DEVICE_OUT_WIRED_HEADSET:
606 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE: // Use receive path with 3 pole headset.
607 ALOGD("### headset call volume");
608 type = SOUND_TYPE_HEADSET;
609 break;
610
611 default:
612 ALOGW("### Call volume setting error!!!0x%08x \n", device);
613 type = SOUND_TYPE_VOICE;
614 break;
615 }
616 setCallVolume(mRilClient, type, int_volume);
617 }
618
619 }
620
setMasterVolume(float volume)621 status_t AudioHardware::setMasterVolume(float volume)
622 {
623 ALOGV("Set master volume to %f.\n", volume);
624 // We return an error code here to let the audioflinger do in-software
625 // volume on top of the maximum volume that we set through the SND API.
626 // return error - software mixer will handle it
627 return -1;
628 }
629
630 static const int kDumpLockRetries = 50;
631 static const int kDumpLockSleep = 20000;
632
tryLock(Mutex & mutex)633 static bool tryLock(Mutex& mutex)
634 {
635 bool locked = false;
636 for (int i = 0; i < kDumpLockRetries; ++i) {
637 if (mutex.tryLock() == NO_ERROR) {
638 locked = true;
639 break;
640 }
641 usleep(kDumpLockSleep);
642 }
643 return locked;
644 }
645
dump(int fd,const Vector<String16> & args)646 status_t AudioHardware::dump(int fd, const Vector<String16>& args)
647 {
648 const size_t SIZE = 256;
649 char buffer[SIZE];
650 String8 result;
651
652 bool locked = tryLock(mLock);
653 if (!locked) {
654 snprintf(buffer, SIZE, "\n\tAudioHardware maybe deadlocked\n");
655 } else {
656 mLock.unlock();
657 }
658
659 snprintf(buffer, SIZE, "\tInit %s\n", (mInit) ? "OK" : "Failed");
660 result.append(buffer);
661 snprintf(buffer, SIZE, "\tMic Mute %s\n", (mMicMute) ? "ON" : "OFF");
662 result.append(buffer);
663 snprintf(buffer, SIZE, "\tmPcm: %p\n", mPcm);
664 result.append(buffer);
665 snprintf(buffer, SIZE, "\tmPcmOpenCnt: %d\n", mPcmOpenCnt);
666 result.append(buffer);
667 snprintf(buffer, SIZE, "\tmMixer: %p\n", mMixer);
668 result.append(buffer);
669 snprintf(buffer, SIZE, "\tmMixerOpenCnt: %d\n", mMixerOpenCnt);
670 result.append(buffer);
671 snprintf(buffer, SIZE, "\tIn Call Audio Mode %s\n",
672 (mInCallAudioMode) ? "ON" : "OFF");
673 result.append(buffer);
674 snprintf(buffer, SIZE, "\tInput source %d\n", mInputSource);
675 result.append(buffer);
676 snprintf(buffer, SIZE, "\tmSecRilLibHandle: %p\n", mSecRilLibHandle);
677 result.append(buffer);
678 snprintf(buffer, SIZE, "\tmRilClient: %p\n", mRilClient);
679 result.append(buffer);
680 snprintf(buffer, SIZE, "\tCP %s\n",
681 (mActivatedCP) ? "Activated" : "Deactivated");
682 result.append(buffer);
683 snprintf(buffer, SIZE, "\tmDriverOp: %d\n", mDriverOp);
684 result.append(buffer);
685
686 snprintf(buffer, SIZE, "\n\tmOutput %p dump:\n", mOutput.get());
687 result.append(buffer);
688 write(fd, result.string(), result.size());
689 if (mOutput != 0) {
690 mOutput->dump(fd, args);
691 }
692
693 snprintf(buffer, SIZE, "\n\t%d inputs opened:\n", mInputs.size());
694 write(fd, buffer, strlen(buffer));
695 for (size_t i = 0; i < mInputs.size(); i++) {
696 snprintf(buffer, SIZE, "\t- input %d dump:\n", i);
697 write(fd, buffer, strlen(buffer));
698 mInputs[i]->dump(fd, args);
699 }
700
701 return NO_ERROR;
702 }
703
setIncallPath_l(uint32_t device)704 status_t AudioHardware::setIncallPath_l(uint32_t device)
705 {
706 ALOGV("setIncallPath_l: device %x", device);
707
708 // Setup sound path for CP clocking
709 if ((mSecRilLibHandle) &&
710 (connectRILDIfRequired() == OK)) {
711
712 if (mMode == AudioSystem::MODE_IN_CALL) {
713 ALOGD("### incall mode route (%d)", device);
714 AudioPath path;
715 switch(device){
716 case AudioSystem::DEVICE_OUT_EARPIECE:
717 ALOGD("### incall mode earpiece route");
718 path = SOUND_AUDIO_PATH_HANDSET;
719 break;
720
721 case AudioSystem::DEVICE_OUT_SPEAKER:
722 ALOGD("### incall mode speaker route");
723 path = SOUND_AUDIO_PATH_SPEAKER;
724 break;
725
726 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO:
727 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET:
728 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT:
729 ALOGD("### incall mode bluetooth route %s NR", mBluetoothNrec ? "" : "NO");
730 if (mBluetoothNrec) {
731 path = SOUND_AUDIO_PATH_BLUETOOTH;
732 } else {
733 path = SOUND_AUDIO_PATH_BLUETOOTH_NO_NR;
734 }
735 break;
736
737 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE :
738 ALOGD("### incall mode headphone route");
739 path = SOUND_AUDIO_PATH_HEADPHONE;
740 break;
741 case AudioSystem::DEVICE_OUT_WIRED_HEADSET :
742 ALOGD("### incall mode headset route");
743 path = SOUND_AUDIO_PATH_HEADSET;
744 break;
745 default:
746 ALOGW("### incall mode Error!! route = [%d]", device);
747 path = SOUND_AUDIO_PATH_HANDSET;
748 break;
749 }
750
751 setCallAudioPath(mRilClient, path);
752
753 if (mMixer != NULL) {
754 TRACE_DRIVER_IN(DRV_MIXER_GET)
755 struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer, "Voice Call Path");
756 TRACE_DRIVER_OUT
757 ALOGE_IF(ctl == NULL, "setIncallPath_l() could not get mixer ctl");
758 if (ctl != NULL) {
759 ALOGV("setIncallPath_l() Voice Call Path, (%x)", device);
760 TRACE_DRIVER_IN(DRV_MIXER_SEL)
761 mixer_ctl_set_enum_by_string(ctl, getVoiceRouteFromDevice(device));
762 TRACE_DRIVER_OUT
763 }
764 }
765 }
766 }
767 return NO_ERROR;
768 }
769
openPcmOut_l()770 struct pcm *AudioHardware::openPcmOut_l()
771 {
772 ALOGD("openPcmOut_l() mPcmOpenCnt: %d", mPcmOpenCnt);
773 if (mPcmOpenCnt++ == 0) {
774 if (mPcm != NULL) {
775 ALOGE("openPcmOut_l() mPcmOpenCnt == 0 and mPcm == %p\n", mPcm);
776 mPcmOpenCnt--;
777 return NULL;
778 }
779 unsigned flags = PCM_OUT;
780
781 struct pcm_config config = {
782 channels : 2,
783 rate : AUDIO_HW_OUT_SAMPLERATE,
784 period_size : AUDIO_HW_OUT_PERIOD_SZ,
785 period_count : AUDIO_HW_OUT_PERIOD_CNT,
786 format : PCM_FORMAT_S16_LE,
787 start_threshold : 0,
788 stop_threshold : 0,
789 silence_threshold : 0,
790 avail_min : 0,
791 };
792
793 TRACE_DRIVER_IN(DRV_PCM_OPEN)
794 mPcm = pcm_open(0, 0, flags, &config);
795 TRACE_DRIVER_OUT
796 if (!pcm_is_ready(mPcm)) {
797 ALOGE("openPcmOut_l() cannot open pcm_out driver: %s\n", pcm_get_error(mPcm));
798 TRACE_DRIVER_IN(DRV_PCM_CLOSE)
799 pcm_close(mPcm);
800 TRACE_DRIVER_OUT
801 mPcmOpenCnt--;
802 mPcm = NULL;
803 }
804 }
805 return mPcm;
806 }
807
closePcmOut_l()808 void AudioHardware::closePcmOut_l()
809 {
810 ALOGD("closePcmOut_l() mPcmOpenCnt: %d", mPcmOpenCnt);
811 if (mPcmOpenCnt == 0) {
812 ALOGE("closePcmOut_l() mPcmOpenCnt == 0");
813 return;
814 }
815
816 if (--mPcmOpenCnt == 0) {
817 TRACE_DRIVER_IN(DRV_PCM_CLOSE)
818 pcm_close(mPcm);
819 TRACE_DRIVER_OUT
820 mPcm = NULL;
821 }
822 }
823
openMixer_l()824 struct mixer *AudioHardware::openMixer_l()
825 {
826 ALOGV("openMixer_l() mMixerOpenCnt: %d", mMixerOpenCnt);
827 if (mMixerOpenCnt++ == 0) {
828 if (mMixer != NULL) {
829 ALOGE("openMixer_l() mMixerOpenCnt == 0 and mMixer == %p\n", mMixer);
830 mMixerOpenCnt--;
831 return NULL;
832 }
833 TRACE_DRIVER_IN(DRV_MIXER_OPEN)
834 mMixer = mixer_open(0);
835 TRACE_DRIVER_OUT
836 if (mMixer == NULL) {
837 ALOGE("openMixer_l() cannot open mixer");
838 mMixerOpenCnt--;
839 return NULL;
840 }
841 }
842 return mMixer;
843 }
844
closeMixer_l()845 void AudioHardware::closeMixer_l()
846 {
847 ALOGV("closeMixer_l() mMixerOpenCnt: %d", mMixerOpenCnt);
848 if (mMixerOpenCnt == 0) {
849 ALOGE("closeMixer_l() mMixerOpenCnt == 0");
850 return;
851 }
852
853 if (--mMixerOpenCnt == 0) {
854 TRACE_DRIVER_IN(DRV_MIXER_CLOSE)
855 mixer_close(mMixer);
856 TRACE_DRIVER_OUT
857 mMixer = NULL;
858 }
859 }
860
getOutputRouteFromDevice(uint32_t device)861 const char *AudioHardware::getOutputRouteFromDevice(uint32_t device)
862 {
863 switch (device) {
864 case AudioSystem::DEVICE_OUT_EARPIECE:
865 return "RCV";
866 case AudioSystem::DEVICE_OUT_SPEAKER:
867 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_SPK";
868 else return "SPK";
869 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE:
870 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_NO_MIC";
871 else return "HP_NO_MIC";
872 case AudioSystem::DEVICE_OUT_WIRED_HEADSET:
873 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_HP";
874 else return "HP";
875 case (AudioSystem::DEVICE_OUT_SPEAKER|AudioSystem::DEVICE_OUT_WIRED_HEADPHONE):
876 case (AudioSystem::DEVICE_OUT_SPEAKER|AudioSystem::DEVICE_OUT_WIRED_HEADSET):
877 if (mMode == AudioSystem::MODE_RINGTONE) return "RING_SPK_HP";
878 else return "SPK_HP";
879 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO:
880 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET:
881 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT:
882 return "BT";
883 default:
884 return "OFF";
885 }
886 }
887
getVoiceRouteFromDevice(uint32_t device)888 const char *AudioHardware::getVoiceRouteFromDevice(uint32_t device)
889 {
890 switch (device) {
891 case AudioSystem::DEVICE_OUT_EARPIECE:
892 return "RCV";
893 case AudioSystem::DEVICE_OUT_SPEAKER:
894 return "SPK";
895 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE:
896 case AudioSystem::DEVICE_OUT_WIRED_HEADSET:
897 switch (mTTYMode) {
898 case TTY_MODE_VCO:
899 return "TTY_VCO";
900 case TTY_MODE_HCO:
901 return "TTY_HCO";
902 case TTY_MODE_FULL:
903 return "TTY_FULL";
904 case TTY_MODE_OFF:
905 default:
906 if (device == AudioSystem::DEVICE_OUT_WIRED_HEADPHONE) {
907 return "HP_NO_MIC";
908 } else {
909 return "HP";
910 }
911 }
912 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO:
913 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET:
914 case AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT:
915 return "BT";
916 default:
917 return "OFF";
918 }
919 }
920
getInputRouteFromDevice(uint32_t device)921 const char *AudioHardware::getInputRouteFromDevice(uint32_t device)
922 {
923 if (mMicMute) {
924 return "MIC OFF";
925 }
926
927 switch (device) {
928 case AudioSystem::DEVICE_IN_BUILTIN_MIC:
929 return "Main Mic";
930 case AudioSystem::DEVICE_IN_WIRED_HEADSET:
931 return "Hands Free Mic";
932 case AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET:
933 return "BT Sco Mic";
934 default:
935 return "MIC OFF";
936 }
937 }
938
getInputSampleRate(uint32_t sampleRate)939 uint32_t AudioHardware::getInputSampleRate(uint32_t sampleRate)
940 {
941 size_t i;
942 uint32_t prevDelta;
943 uint32_t delta;
944 size_t size = sizeof(inputConfigTable)/sizeof(uint32_t)/INPUT_CONFIG_CNT;
945
946 for (i = 0, prevDelta = 0xFFFFFFFF; i < size; i++, prevDelta = delta) {
947 delta = abs(sampleRate - inputConfigTable[i][INPUT_CONFIG_SAMPLE_RATE]);
948 if (delta > prevDelta) break;
949 }
950 // i is always > 0 here
951 return inputConfigTable[i-1][INPUT_CONFIG_SAMPLE_RATE];
952 }
953
954 // getActiveInput_l() must be called with mLock held
getActiveInput_l()955 sp <AudioHardware::AudioStreamInALSA> AudioHardware::getActiveInput_l()
956 {
957 sp< AudioHardware::AudioStreamInALSA> spIn;
958
959 for (size_t i = 0; i < mInputs.size(); i++) {
960 // return first input found not being in standby mode
961 // as only one input can be in this state
962 if (!mInputs[i]->checkStandby()) {
963 spIn = mInputs[i];
964 break;
965 }
966 }
967
968 return spIn;
969 }
970
setInputSource_l(audio_source source)971 status_t AudioHardware::setInputSource_l(audio_source source)
972 {
973 ALOGV("setInputSource_l(%d)", source);
974 if (source != mInputSource) {
975 if ((source == AUDIO_SOURCE_DEFAULT) || (mMode != AudioSystem::MODE_IN_CALL)) {
976 if (mMixer) {
977 TRACE_DRIVER_IN(DRV_MIXER_GET)
978 struct mixer_ctl *ctl= mixer_get_ctl_by_name(mMixer, "Input Source");
979 TRACE_DRIVER_OUT
980 if (ctl == NULL) {
981 return NO_INIT;
982 }
983 const char* sourceName;
984 switch (source) {
985 case AUDIO_SOURCE_DEFAULT: // intended fall-through
986 case AUDIO_SOURCE_MIC: // intended fall-through
987 case AUDIO_SOURCE_VOICE_COMMUNICATION:
988 sourceName = inputPathNameDefault;
989 break;
990 case AUDIO_SOURCE_CAMCORDER:
991 sourceName = inputPathNameCamcorder;
992 break;
993 case AUDIO_SOURCE_VOICE_RECOGNITION:
994 sourceName = inputPathNameVoiceRecognition;
995 break;
996 case AUDIO_SOURCE_VOICE_UPLINK: // intended fall-through
997 case AUDIO_SOURCE_VOICE_DOWNLINK: // intended fall-through
998 case AUDIO_SOURCE_VOICE_CALL: // intended fall-through
999 default:
1000 return NO_INIT;
1001 }
1002 ALOGV("mixer_ctl_set_enum_by_string, Input Source, (%s)", sourceName);
1003 TRACE_DRIVER_IN(DRV_MIXER_SEL)
1004 mixer_ctl_set_enum_by_string(ctl, sourceName);
1005 TRACE_DRIVER_OUT
1006 }
1007 }
1008 mInputSource = source;
1009 }
1010
1011 return NO_ERROR;
1012 }
1013
getEchoReference(audio_format_t format,uint32_t channelCount,uint32_t samplingRate)1014 struct echo_reference_itfe *AudioHardware::getEchoReference(audio_format_t format,
1015 uint32_t channelCount,
1016 uint32_t samplingRate)
1017 {
1018 ALOGV("AudioHardware::getEchoReference %p", mEchoReference);
1019 releaseEchoReference(mEchoReference);
1020 if (mOutput != NULL) {
1021 uint32_t wrChannelCount = popcount(mOutput->channels());
1022 uint32_t wrSampleRate = mOutput->sampleRate();
1023
1024 int status = create_echo_reference(AUDIO_FORMAT_PCM_16_BIT,
1025 channelCount,
1026 samplingRate,
1027 AUDIO_FORMAT_PCM_16_BIT,
1028 wrChannelCount,
1029 wrSampleRate,
1030 &mEchoReference);
1031 if (status == 0) {
1032 mOutput->addEchoReference(mEchoReference);
1033 }
1034 }
1035 return mEchoReference;
1036 }
1037
releaseEchoReference(struct echo_reference_itfe * reference)1038 void AudioHardware::releaseEchoReference(struct echo_reference_itfe *reference)
1039 {
1040 ALOGV("AudioHardware::releaseEchoReference %p", mEchoReference);
1041 if (mEchoReference != NULL && reference == mEchoReference) {
1042 if (mOutput != NULL) {
1043 mOutput->removeEchoReference(reference);
1044 }
1045 release_echo_reference(mEchoReference);
1046 mEchoReference = NULL;
1047 }
1048 }
1049
1050
1051 //------------------------------------------------------------------------------
1052 // AudioStreamOutALSA
1053 //------------------------------------------------------------------------------
1054
AudioStreamOutALSA()1055 AudioHardware::AudioStreamOutALSA::AudioStreamOutALSA() :
1056 mHardware(0), mPcm(0), mMixer(0), mRouteCtl(0),
1057 mStandby(true), mDevices(0), mChannels(AUDIO_HW_OUT_CHANNELS),
1058 mSampleRate(AUDIO_HW_OUT_SAMPLERATE), mBufferSize(AUDIO_HW_OUT_PERIOD_BYTES),
1059 mDriverOp(DRV_NONE), mStandbyCnt(0), mSleepReq(false), mEchoReference(NULL)
1060 {
1061 }
1062
set(AudioHardware * hw,uint32_t devices,int * pFormat,uint32_t * pChannels,uint32_t * pRate)1063 status_t AudioHardware::AudioStreamOutALSA::set(
1064 AudioHardware* hw, uint32_t devices, int *pFormat,
1065 uint32_t *pChannels, uint32_t *pRate)
1066 {
1067 int lFormat = pFormat ? *pFormat : 0;
1068 uint32_t lChannels = pChannels ? *pChannels : 0;
1069 uint32_t lRate = pRate ? *pRate : 0;
1070
1071 mHardware = hw;
1072 mDevices = devices;
1073
1074 // fix up defaults
1075 if (lFormat == 0) lFormat = format();
1076 if (lChannels == 0) lChannels = channels();
1077 if (lRate == 0) lRate = sampleRate();
1078
1079 // check values
1080 if ((lFormat != format()) ||
1081 (lChannels != channels()) ||
1082 (lRate != sampleRate())) {
1083 if (pFormat) *pFormat = format();
1084 if (pChannels) *pChannels = channels();
1085 if (pRate) *pRate = sampleRate();
1086 return BAD_VALUE;
1087 }
1088
1089 if (pFormat) *pFormat = lFormat;
1090 if (pChannels) *pChannels = lChannels;
1091 if (pRate) *pRate = lRate;
1092
1093 mChannels = lChannels;
1094 mSampleRate = lRate;
1095 mBufferSize = AUDIO_HW_OUT_PERIOD_BYTES;
1096
1097 return NO_ERROR;
1098 }
1099
~AudioStreamOutALSA()1100 AudioHardware::AudioStreamOutALSA::~AudioStreamOutALSA()
1101 {
1102 standby();
1103 }
1104
getPlaybackDelay(size_t frames,struct echo_reference_buffer * buffer)1105 int AudioHardware::AudioStreamOutALSA::getPlaybackDelay(size_t frames,
1106 struct echo_reference_buffer *buffer)
1107 {
1108 size_t kernelFr;
1109
1110 int rc = pcm_get_htimestamp(mPcm, &kernelFr, &buffer->time_stamp);
1111 if (rc < 0) {
1112 buffer->time_stamp.tv_sec = 0;
1113 buffer->time_stamp.tv_nsec = 0;
1114 buffer->delay_ns = 0;
1115 ALOGV("getPlaybackDelay(): pcm_get_htimestamp error, setting playbackTimestamp to 0");
1116 return rc;
1117 }
1118
1119 kernelFr = pcm_get_buffer_size(mPcm) - kernelFr;
1120
1121 // adjust render time stamp with delay added by current driver buffer.
1122 // Add the duration of current frame as we want the render time of the last
1123 // sample being written.
1124 long delayNs = (long)(((int64_t)(kernelFr + frames)* 1000000000) /AUDIO_HW_OUT_SAMPLERATE);
1125
1126 ALOGV("AudioStreamOutALSA::getPlaybackDelay delayNs: [%ld], "\
1127 "kernelFr:[%d], frames:[%d], buffSize:[%d], time_stamp:[%ld].[%ld]",
1128 delayNs, (int)kernelFr, (int)frames, pcm_get_buffer_size(mPcm),
1129 (long)buffer->time_stamp.tv_sec, buffer->time_stamp.tv_nsec);
1130
1131 buffer->delay_ns = delayNs;
1132
1133 return 0;
1134 }
1135
write(const void * buffer,size_t bytes)1136 ssize_t AudioHardware::AudioStreamOutALSA::write(const void* buffer, size_t bytes)
1137 {
1138 ALOGV("-----AudioStreamInALSA::write(%p, %d) START", buffer, (int)bytes);
1139 status_t status = NO_INIT;
1140 const uint8_t* p = static_cast<const uint8_t*>(buffer);
1141 int ret;
1142
1143 if (mHardware == NULL) return NO_INIT;
1144
1145 if (mSleepReq) {
1146 // 10ms are always shorter than the time to reconfigure the audio path
1147 // which is the only condition when mSleepReq would be true.
1148 usleep(10000);
1149 }
1150
1151 { // scope for the lock
1152
1153 AutoMutex lock(mLock);
1154
1155 if (mStandby) {
1156 AutoMutex hwLock(mHardware->lock());
1157
1158 ALOGD("AudioHardware pcm playback is exiting standby.");
1159 sp<AudioStreamInALSA> spIn = mHardware->getActiveInput_l();
1160 while (spIn != 0) {
1161 int cnt = spIn->prepareLock();
1162 mHardware->lock().unlock();
1163 // Mutex acquisition order is always out -> in -> hw
1164 spIn->lock();
1165 mHardware->lock().lock();
1166 // make sure that another thread did not change input state
1167 // while the mutex is released
1168 if ((spIn == mHardware->getActiveInput_l()) &&
1169 (cnt == spIn->standbyCnt())) {
1170 ALOGV("AudioStreamOutALSA::write() force input standby");
1171 spIn->close_l();
1172 break;
1173 }
1174 spIn->unlock();
1175 spIn = mHardware->getActiveInput_l();
1176 }
1177 // spIn is not 0 here only if the input was active and has been
1178 // closed above
1179
1180 // open output before input
1181 open_l();
1182
1183 if (spIn != 0) {
1184 if (spIn->open_l() != NO_ERROR) {
1185 spIn->doStandby_l();
1186 }
1187 spIn->unlock();
1188 }
1189 if (mPcm == NULL) {
1190 goto Error;
1191 }
1192 mStandby = false;
1193 }
1194
1195 if (mEchoReference != NULL) {
1196 struct echo_reference_buffer b;
1197 b.raw = (void *)buffer;
1198 b.frame_count = bytes / frameSize();
1199
1200 getPlaybackDelay(bytes / frameSize(), &b);
1201 mEchoReference->write(mEchoReference, &b);
1202 }
1203
1204 TRACE_DRIVER_IN(DRV_PCM_WRITE)
1205 ret = pcm_write(mPcm,(void*) p, bytes);
1206 TRACE_DRIVER_OUT
1207
1208 if (ret == 0) {
1209 ALOGV("-----AudioStreamInALSA::write(%p, %d) END", buffer, (int)bytes);
1210 return bytes;
1211 }
1212 ALOGW("write error: %d", errno);
1213 status = -errno;
1214 }
1215 Error:
1216 standby();
1217
1218 // Simulate audio output timing in case of error
1219 usleep((((bytes * 1000) / frameSize()) * 1000) / sampleRate());
1220 ALOGE("AudioStreamOutALSA::write END WITH ERROR !!!!!!!!!(%p, %u)", buffer, bytes);
1221 return status;
1222 }
1223
standby()1224 status_t AudioHardware::AudioStreamOutALSA::standby()
1225 {
1226 if (mHardware == NULL) return NO_INIT;
1227
1228 mSleepReq = true;
1229 {
1230 AutoMutex lock(mLock);
1231 mSleepReq = false;
1232
1233 { // scope for the AudioHardware lock
1234 AutoMutex hwLock(mHardware->lock());
1235
1236 doStandby_l();
1237 }
1238 }
1239
1240 return NO_ERROR;
1241 }
1242
doStandby_l()1243 void AudioHardware::AudioStreamOutALSA::doStandby_l()
1244 {
1245 mStandbyCnt++;
1246
1247 if (!mStandby) {
1248 ALOGD("AudioHardware pcm playback is going to standby.");
1249 // stop echo reference capture
1250 if (mEchoReference != NULL) {
1251 mEchoReference->write(mEchoReference, NULL);
1252 }
1253 mStandby = true;
1254 }
1255
1256 close_l();
1257 }
1258
close_l()1259 void AudioHardware::AudioStreamOutALSA::close_l()
1260 {
1261 if (mMixer) {
1262 mHardware->closeMixer_l();
1263 mMixer = NULL;
1264 mRouteCtl = NULL;
1265 }
1266 if (mPcm) {
1267 mHardware->closePcmOut_l();
1268 mPcm = NULL;
1269 }
1270 }
1271
open_l()1272 status_t AudioHardware::AudioStreamOutALSA::open_l()
1273 {
1274 ALOGV("open pcm_out driver");
1275 mPcm = mHardware->openPcmOut_l();
1276 if (mPcm == NULL) {
1277 return NO_INIT;
1278 }
1279
1280 mMixer = mHardware->openMixer_l();
1281 if (mMixer) {
1282 ALOGV("open playback normal");
1283 TRACE_DRIVER_IN(DRV_MIXER_GET)
1284 mRouteCtl = mixer_get_ctl_by_name(mMixer, "Playback Path");
1285 TRACE_DRIVER_OUT
1286 }
1287 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) {
1288 const char *route = mHardware->getOutputRouteFromDevice(mDevices);
1289 ALOGV("write() wakeup setting route %s", route);
1290 if (mRouteCtl) {
1291 TRACE_DRIVER_IN(DRV_MIXER_SEL)
1292 mixer_ctl_set_enum_by_string(mRouteCtl, route);
1293 TRACE_DRIVER_OUT
1294 }
1295 }
1296 return NO_ERROR;
1297 }
1298
dump(int fd,const Vector<String16> & args)1299 status_t AudioHardware::AudioStreamOutALSA::dump(int fd, const Vector<String16>& args)
1300 {
1301 const size_t SIZE = 256;
1302 char buffer[SIZE];
1303 String8 result;
1304
1305 bool locked = tryLock(mLock);
1306 if (!locked) {
1307 snprintf(buffer, SIZE, "\n\t\tAudioStreamOutALSA maybe deadlocked\n");
1308 } else {
1309 mLock.unlock();
1310 }
1311
1312 snprintf(buffer, SIZE, "\t\tmHardware: %p\n", mHardware);
1313 result.append(buffer);
1314 snprintf(buffer, SIZE, "\t\tmPcm: %p\n", mPcm);
1315 result.append(buffer);
1316 snprintf(buffer, SIZE, "\t\tmMixer: %p\n", mMixer);
1317 result.append(buffer);
1318 snprintf(buffer, SIZE, "\t\tmRouteCtl: %p\n", mRouteCtl);
1319 result.append(buffer);
1320 snprintf(buffer, SIZE, "\t\tStandby %s\n", (mStandby) ? "ON" : "OFF");
1321 result.append(buffer);
1322 snprintf(buffer, SIZE, "\t\tmDevices: 0x%08x\n", mDevices);
1323 result.append(buffer);
1324 snprintf(buffer, SIZE, "\t\tmChannels: 0x%08x\n", mChannels);
1325 result.append(buffer);
1326 snprintf(buffer, SIZE, "\t\tmSampleRate: %d\n", mSampleRate);
1327 result.append(buffer);
1328 snprintf(buffer, SIZE, "\t\tmBufferSize: %d\n", mBufferSize);
1329 result.append(buffer);
1330 snprintf(buffer, SIZE, "\t\tmDriverOp: %d\n", mDriverOp);
1331 result.append(buffer);
1332
1333 ::write(fd, result.string(), result.size());
1334
1335 return NO_ERROR;
1336 }
1337
checkStandby()1338 bool AudioHardware::AudioStreamOutALSA::checkStandby()
1339 {
1340 return mStandby;
1341 }
1342
setParameters(const String8 & keyValuePairs)1343 status_t AudioHardware::AudioStreamOutALSA::setParameters(const String8& keyValuePairs)
1344 {
1345 AudioParameter param = AudioParameter(keyValuePairs);
1346 status_t status = NO_ERROR;
1347 int device;
1348 ALOGD("AudioStreamOutALSA::setParameters() %s", keyValuePairs.string());
1349
1350 if (mHardware == NULL) return NO_INIT;
1351
1352 mSleepReq = true;
1353 {
1354 AutoMutex lock(mLock);
1355 mSleepReq = false;
1356 if (param.getInt(String8(AudioParameter::keyRouting), device) == NO_ERROR)
1357 {
1358 if (device != 0) {
1359 AutoMutex hwLock(mHardware->lock());
1360
1361 if (mDevices != (uint32_t)device) {
1362 mDevices = (uint32_t)device;
1363 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) {
1364 doStandby_l();
1365 }
1366 }
1367 if (mHardware->mode() == AudioSystem::MODE_IN_CALL) {
1368 mHardware->setIncallPath_l(device);
1369 }
1370 }
1371 param.remove(String8(AudioParameter::keyRouting));
1372 }
1373 }
1374
1375 if (param.size()) {
1376 status = BAD_VALUE;
1377 }
1378
1379
1380 return status;
1381
1382 }
1383
getParameters(const String8 & keys)1384 String8 AudioHardware::AudioStreamOutALSA::getParameters(const String8& keys)
1385 {
1386 AudioParameter param = AudioParameter(keys);
1387 String8 value;
1388 String8 key = String8(AudioParameter::keyRouting);
1389
1390 if (param.get(key, value) == NO_ERROR) {
1391 param.addInt(key, (int)mDevices);
1392 }
1393
1394 ALOGV("AudioStreamOutALSA::getParameters() %s", param.toString().string());
1395 return param.toString();
1396 }
1397
getRenderPosition(uint32_t * dspFrames)1398 status_t AudioHardware::AudioStreamOutALSA::getRenderPosition(uint32_t *dspFrames)
1399 {
1400 //TODO
1401 return INVALID_OPERATION;
1402 }
1403
prepareLock()1404 int AudioHardware::AudioStreamOutALSA::prepareLock()
1405 {
1406 // request sleep next time write() is called so that caller can acquire
1407 // mLock
1408 mSleepReq = true;
1409 return mStandbyCnt;
1410 }
1411
lock()1412 void AudioHardware::AudioStreamOutALSA::lock()
1413 {
1414 mLock.lock();
1415 mSleepReq = false;
1416 }
1417
unlock()1418 void AudioHardware::AudioStreamOutALSA::unlock() {
1419 mLock.unlock();
1420 }
1421
addEchoReference(struct echo_reference_itfe * reference)1422 void AudioHardware::AudioStreamOutALSA::addEchoReference(struct echo_reference_itfe *reference)
1423 {
1424 ALOGV("AudioStreamOutALSA::addEchoReference %p", mEchoReference);
1425 if (mEchoReference == NULL) {
1426 mEchoReference = reference;
1427 }
1428 }
1429
removeEchoReference(struct echo_reference_itfe * reference)1430 void AudioHardware::AudioStreamOutALSA::removeEchoReference(struct echo_reference_itfe *reference)
1431 {
1432 ALOGV("AudioStreamOutALSA::removeEchoReference %p", mEchoReference);
1433 if (mEchoReference == reference) {
1434 mEchoReference->write(mEchoReference, NULL);
1435 mEchoReference = NULL;
1436 }
1437 }
1438
1439
1440 //------------------------------------------------------------------------------
1441 // AudioStreamInALSA
1442 //------------------------------------------------------------------------------
1443
AudioStreamInALSA()1444 AudioHardware::AudioStreamInALSA::AudioStreamInALSA() :
1445 mHardware(0), mPcm(0), mMixer(0), mRouteCtl(0),
1446 mStandby(true), mDevices(0), mChannels(AUDIO_HW_IN_CHANNELS), mChannelCount(1),
1447 mSampleRate(AUDIO_HW_IN_SAMPLERATE), mBufferSize(AUDIO_HW_IN_PERIOD_BYTES),
1448 mDownSampler(NULL), mReadStatus(NO_ERROR), mInputBuf(NULL),
1449 mDriverOp(DRV_NONE), mStandbyCnt(0), mSleepReq(false),
1450 mProcBuf(NULL), mProcBufSize(0), mRefBuf(NULL), mRefBufSize(0),
1451 mEchoReference(NULL), mNeedEchoReference(false)
1452 {
1453 }
1454
set(AudioHardware * hw,uint32_t devices,int * pFormat,uint32_t * pChannels,uint32_t * pRate,AudioSystem::audio_in_acoustics acoustics)1455 status_t AudioHardware::AudioStreamInALSA::set(
1456 AudioHardware* hw, uint32_t devices, int *pFormat,
1457 uint32_t *pChannels, uint32_t *pRate, AudioSystem::audio_in_acoustics acoustics)
1458 {
1459 if (pFormat == 0 || *pFormat != AUDIO_HW_IN_FORMAT) {
1460 *pFormat = AUDIO_HW_IN_FORMAT;
1461 return BAD_VALUE;
1462 }
1463 if (pRate == 0) {
1464 return BAD_VALUE;
1465 }
1466 uint32_t rate = AudioHardware::getInputSampleRate(*pRate);
1467 if (rate != *pRate) {
1468 *pRate = rate;
1469 return BAD_VALUE;
1470 }
1471
1472 if (pChannels == 0 || (*pChannels != AudioSystem::CHANNEL_IN_MONO &&
1473 *pChannels != AudioSystem::CHANNEL_IN_STEREO)) {
1474 *pChannels = AUDIO_HW_IN_CHANNELS;
1475 return BAD_VALUE;
1476 }
1477
1478 mHardware = hw;
1479
1480 ALOGV("AudioStreamInALSA::set(%d, %d, %u)", *pFormat, *pChannels, *pRate);
1481
1482 mBufferSize = getBufferSize(*pRate, AudioSystem::popCount(*pChannels));
1483 mDevices = devices;
1484 mChannels = *pChannels;
1485 mChannelCount = AudioSystem::popCount(mChannels);
1486 mSampleRate = rate;
1487 if (mSampleRate != AUDIO_HW_OUT_SAMPLERATE) {
1488 mBufferProvider.mProvider.get_next_buffer = getNextBufferStatic;
1489 mBufferProvider.mProvider.release_buffer = releaseBufferStatic;
1490 mBufferProvider.mInputStream = this;
1491 int status = create_resampler(AUDIO_HW_OUT_SAMPLERATE,
1492 mSampleRate,
1493 mChannelCount,
1494 RESAMPLER_QUALITY_VOIP,
1495 &mBufferProvider.mProvider,
1496 &mDownSampler);
1497 if (status != 0) {
1498 ALOGW("AudioStreamInALSA::set() downsampler init failed: %d", status);
1499 mDownSampler = NULL;
1500 return status;
1501 }
1502 }
1503 mInputBuf = new int16_t[AUDIO_HW_IN_PERIOD_SZ * mChannelCount];
1504
1505 return NO_ERROR;
1506 }
1507
~AudioStreamInALSA()1508 AudioHardware::AudioStreamInALSA::~AudioStreamInALSA()
1509 {
1510 standby();
1511
1512 if (mDownSampler != NULL) {
1513 release_resampler(mDownSampler);
1514 }
1515 delete[] mInputBuf;
1516 delete[] mProcBuf;
1517 }
1518
1519 // readFrames() reads frames from kernel driver, down samples to capture rate if necessary
1520 // and output the number of frames requested to the buffer specified
readFrames(void * buffer,ssize_t frames)1521 ssize_t AudioHardware::AudioStreamInALSA::readFrames(void* buffer, ssize_t frames)
1522 {
1523 ssize_t framesWr = 0;
1524 while (framesWr < frames) {
1525 size_t framesRd = frames - framesWr;
1526 if (mDownSampler != NULL) {
1527 mDownSampler->resample_from_provider(mDownSampler,
1528 (int16_t *)((char *)buffer + framesWr * frameSize()),
1529 &framesRd);
1530 } else {
1531 struct resampler_buffer buf = {
1532 { raw : NULL, },
1533 frame_count : framesRd,
1534 };
1535 getNextBuffer(&buf);
1536 if (buf.raw != NULL) {
1537 memcpy((char *)buffer + framesWr * frameSize(),
1538 buf.raw,
1539 buf.frame_count * frameSize());
1540 framesRd = buf.frame_count;
1541 }
1542 releaseBuffer(&buf);
1543 }
1544 // mReadStatus is updated by getNextBuffer() also called by
1545 // mDownSampler->resample_from_provider()
1546 if (mReadStatus != 0) {
1547 return mReadStatus;
1548 }
1549 framesWr += framesRd;
1550 }
1551 return framesWr;
1552 }
1553
1554 // processFrames() reads frames from kernel driver (via readFrames()), calls the active
1555 // audio pre processings and output the number of frames requested to the buffer specified
processFrames(void * buffer,ssize_t frames)1556 ssize_t AudioHardware::AudioStreamInALSA::processFrames(void* buffer, ssize_t frames)
1557 {
1558 ssize_t framesWr = 0;
1559 while (framesWr < frames) {
1560 // first reload enough frames at the end of process input buffer
1561 if (mProcFramesIn < (size_t)frames) {
1562 // expand process input buffer if necessary
1563 if (mProcBufSize < (size_t)frames) {
1564 mProcBufSize = (size_t)frames;
1565 mProcBuf = (int16_t *)realloc(mProcBuf,
1566 mProcBufSize * mChannelCount * sizeof(int16_t));
1567 ALOGV("processFrames(): mProcBuf %p size extended to %d frames",
1568 mProcBuf, mProcBufSize);
1569 }
1570 ssize_t framesRd = readFrames(mProcBuf + mProcFramesIn * mChannelCount,
1571 frames - mProcFramesIn);
1572 if (framesRd < 0) {
1573 framesWr = framesRd;
1574 break;
1575 }
1576 mProcFramesIn += framesRd;
1577 }
1578
1579 if (mEchoReference != NULL) {
1580 pushEchoReference(mProcFramesIn);
1581 }
1582
1583 //inBuf.frameCount and outBuf.frameCount indicate respectively the maximum number of frames
1584 //to be consumed and produced by process()
1585 audio_buffer_t inBuf = {
1586 mProcFramesIn,
1587 {mProcBuf}
1588 };
1589 audio_buffer_t outBuf = {
1590 frames - framesWr,
1591 {(int16_t *)buffer + framesWr * mChannelCount}
1592 };
1593
1594 for (size_t i = 0; i < mPreprocessors.size(); i++) {
1595 (*mPreprocessors[i])->process(mPreprocessors[i],
1596 &inBuf,
1597 &outBuf);
1598 }
1599
1600 // process() has updated the number of frames consumed and produced in
1601 // inBuf.frameCount and outBuf.frameCount respectively
1602 // move remaining frames to the beginning of mProcBuf
1603 mProcFramesIn -= inBuf.frameCount;
1604 if (mProcFramesIn) {
1605 memcpy(mProcBuf,
1606 mProcBuf + inBuf.frameCount * mChannelCount,
1607 mProcFramesIn * mChannelCount * sizeof(int16_t));
1608 }
1609
1610 // if not enough frames were passed to process(), read more and retry.
1611 if (outBuf.frameCount == 0) {
1612 continue;
1613 }
1614 framesWr += outBuf.frameCount;
1615 }
1616 return framesWr;
1617 }
1618
updateEchoReference(size_t frames)1619 int32_t AudioHardware::AudioStreamInALSA::updateEchoReference(size_t frames)
1620 {
1621 struct echo_reference_buffer b;
1622 b.delay_ns = 0;
1623
1624 ALOGV("updateEchoReference1 START, frames = [%d], mRefFramesIn = [%d], b.frame_count = [%d]",
1625 frames, mRefFramesIn, frames - mRefFramesIn);
1626 if (mRefFramesIn < frames) {
1627 if (mRefBufSize < frames) {
1628 mRefBufSize = frames;
1629 mRefBuf = (int16_t *)realloc(mRefBuf,
1630 mRefBufSize * mChannelCount * sizeof(int16_t));
1631 }
1632
1633 b.frame_count = frames - mRefFramesIn;
1634 b.raw = (void *)(mRefBuf + mRefFramesIn * mChannelCount);
1635
1636 getCaptureDelay(frames, &b);
1637
1638 if (mEchoReference->read(mEchoReference, &b) == NO_ERROR)
1639 {
1640 mRefFramesIn += b.frame_count;
1641 ALOGV("updateEchoReference2: mRefFramesIn:[%d], mRefBufSize:[%d], "\
1642 "frames:[%d], b.frame_count:[%d]", mRefFramesIn, mRefBufSize,frames,b.frame_count);
1643 }
1644
1645 }else{
1646 ALOGV("updateEchoReference3: NOT enough frames to read ref buffer");
1647 }
1648 return b.delay_ns;
1649 }
1650
pushEchoReference(size_t frames)1651 void AudioHardware::AudioStreamInALSA::pushEchoReference(size_t frames)
1652 {
1653 // read frames from echo reference buffer and update echo delay
1654 // mRefFramesIn is updated with frames available in mRefBuf
1655 int32_t delayUs = (int32_t)(updateEchoReference(frames)/1000);
1656
1657 if (mRefFramesIn < frames) {
1658 frames = mRefFramesIn;
1659 }
1660
1661 audio_buffer_t refBuf = {
1662 frames,
1663 {mRefBuf}
1664 };
1665
1666 for (size_t i = 0; i < mPreprocessors.size(); i++) {
1667 if ((*mPreprocessors[i])->process_reverse == NULL) {
1668 continue;
1669 }
1670 (*mPreprocessors[i])->process_reverse(mPreprocessors[i],
1671 &refBuf,
1672 NULL);
1673 setPreProcessorEchoDelay(mPreprocessors[i], delayUs);
1674 }
1675
1676 mRefFramesIn -= refBuf.frameCount;
1677 if (mRefFramesIn) {
1678 ALOGV("pushEchoReference5: shifting mRefBuf down by = %d frames", mRefFramesIn);
1679 memcpy(mRefBuf,
1680 mRefBuf + refBuf.frameCount * mChannelCount,
1681 mRefFramesIn * mChannelCount * sizeof(int16_t));
1682 }
1683 }
1684
setPreProcessorEchoDelay(effect_handle_t handle,int32_t delayUs)1685 status_t AudioHardware::AudioStreamInALSA::setPreProcessorEchoDelay(effect_handle_t handle,
1686 int32_t delayUs)
1687 {
1688 uint32_t buf[sizeof(effect_param_t) / sizeof(uint32_t) + 2];
1689 effect_param_t *param = (effect_param_t *)buf;
1690
1691 param->psize = sizeof(uint32_t);
1692 param->vsize = sizeof(uint32_t);
1693 *(uint32_t *)param->data = AEC_PARAM_ECHO_DELAY;
1694 *((int32_t *)param->data + 1) = delayUs;
1695
1696 ALOGV("setPreProcessorEchoDelay: %d us", delayUs);
1697
1698 return setPreprocessorParam(handle, param);
1699 }
1700
setPreprocessorParam(effect_handle_t handle,effect_param_t * param)1701 status_t AudioHardware::AudioStreamInALSA::setPreprocessorParam(effect_handle_t handle,
1702 effect_param_t *param)
1703 {
1704 uint32_t size = sizeof(int);
1705 uint32_t psize = ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) + param->vsize;
1706
1707 status_t status = (*handle)->command(handle,
1708 EFFECT_CMD_SET_PARAM,
1709 sizeof (effect_param_t) + psize,
1710 param,
1711 &size,
1712 ¶m->status);
1713 if (status == NO_ERROR) {
1714 status = param->status;
1715 }
1716 return status;
1717 }
1718
getCaptureDelay(size_t frames,struct echo_reference_buffer * buffer)1719 void AudioHardware::AudioStreamInALSA::getCaptureDelay(size_t frames,
1720 struct echo_reference_buffer *buffer)
1721 {
1722
1723 // read frames available in kernel driver buffer
1724 size_t kernelFr;
1725 struct timespec tstamp;
1726
1727 if (pcm_get_htimestamp(mPcm, &kernelFr, &tstamp) < 0) {
1728 buffer->time_stamp.tv_sec = 0;
1729 buffer->time_stamp.tv_nsec = 0;
1730 buffer->delay_ns = 0;
1731 ALOGW("read getCaptureDelay(): pcm_htimestamp error");
1732 return;
1733 }
1734
1735 // read frames available in audio HAL input buffer
1736 // add number of frames being read as we want the capture time of first sample in current
1737 // buffer
1738 long bufDelay = (long)(((int64_t)(mInputFramesIn + mProcFramesIn) * 1000000000)
1739 / AUDIO_HW_IN_SAMPLERATE);
1740 // add delay introduced by resampler
1741 long rsmpDelay = 0;
1742 if (mDownSampler) {
1743 rsmpDelay = mDownSampler->delay_ns(mDownSampler);
1744 }
1745
1746 long kernelDelay = (long)(((int64_t)kernelFr * 1000000000) / AUDIO_HW_IN_SAMPLERATE);
1747
1748 // correct capture time stamp
1749 long delayNs = kernelDelay + bufDelay + rsmpDelay;
1750
1751 buffer->time_stamp = tstamp;
1752 buffer->delay_ns = delayNs;
1753 ALOGV("AudioStreamInALSA::getCaptureDelay TimeStamp = [%ld].[%ld], delayCaptureNs: [%d],"\
1754 " kernelDelay:[%ld], bufDelay:[%ld], rsmpDelay:[%ld], kernelFr:[%d], "\
1755 "mInputFramesIn:[%d], mProcFramesIn:[%d], frames:[%d]",
1756 buffer->time_stamp.tv_sec , buffer->time_stamp.tv_nsec, buffer->delay_ns,
1757 kernelDelay, bufDelay, rsmpDelay, kernelFr, mInputFramesIn, mProcFramesIn, frames);
1758
1759 }
1760
read(void * buffer,ssize_t bytes)1761 ssize_t AudioHardware::AudioStreamInALSA::read(void* buffer, ssize_t bytes)
1762 {
1763 ALOGV("-----AudioStreamInALSA::read(%p, %d) START", buffer, (int)bytes);
1764 status_t status = NO_INIT;
1765
1766 if (mHardware == NULL) return NO_INIT;
1767
1768 if (mSleepReq) {
1769 // 10ms are always shorter than the time to reconfigure the audio path
1770 // which is the only condition when mSleepReq would be true.
1771 usleep(10000);
1772 }
1773
1774 { // scope for the lock
1775 AutoMutex lock(mLock);
1776
1777 if (mStandby) {
1778 AutoMutex hwLock(mHardware->lock());
1779
1780 ALOGD("AudioHardware pcm capture is exiting standby.");
1781 sp<AudioStreamOutALSA> spOut = mHardware->output();
1782 while (spOut != 0) {
1783 spOut->prepareLock();
1784 mHardware->lock().unlock();
1785 mLock.unlock();
1786 // Mutex acquisition order is always out -> in -> hw
1787 spOut->lock();
1788 mLock.lock();
1789 mHardware->lock().lock();
1790 // make sure that another thread did not change output state
1791 // while the mutex is released
1792 if (spOut == mHardware->output()) {
1793 break;
1794 }
1795 spOut->unlock();
1796 spOut = mHardware->output();
1797 }
1798 // open output before input
1799 if (spOut != 0) {
1800 if (!spOut->checkStandby()) {
1801 ALOGV("AudioStreamInALSA::read() force output standby");
1802 spOut->close_l();
1803 if (spOut->open_l() != NO_ERROR) {
1804 spOut->doStandby_l();
1805 }
1806 }
1807 ALOGV("AudioStreamInALSA exit standby mNeedEchoReference %d mEchoReference %p",
1808 mNeedEchoReference, mEchoReference);
1809 if (mNeedEchoReference && mEchoReference == NULL) {
1810 mEchoReference = mHardware->getEchoReference(AUDIO_FORMAT_PCM_16_BIT,
1811 mChannelCount,
1812 mSampleRate);
1813 }
1814 spOut->unlock();
1815 }
1816
1817 open_l();
1818
1819 if (mPcm == NULL) {
1820 goto Error;
1821 }
1822 mStandby = false;
1823 }
1824
1825 size_t framesRq = bytes / mChannelCount/sizeof(int16_t);
1826 ssize_t framesRd;
1827
1828 if (mPreprocessors.size() == 0) {
1829 framesRd = readFrames(buffer, framesRq);
1830 } else {
1831 framesRd = processFrames(buffer, framesRq);
1832 }
1833
1834 if (framesRd >= 0) {
1835 ALOGV("-----AudioStreamInALSA::read(%p, %d) END", buffer, (int)bytes);
1836 return framesRd * mChannelCount * sizeof(int16_t);
1837 }
1838
1839 ALOGW("read error: %d", (int)framesRd);
1840 status = framesRd;
1841 }
1842
1843 Error:
1844
1845 standby();
1846
1847 // Simulate audio output timing in case of error
1848 usleep((((bytes * 1000) / frameSize()) * 1000) / sampleRate());
1849 ALOGE("-----AudioStreamInALSA::read(%p, %d) END ERROR", buffer, (int)bytes);
1850 return status;
1851 }
1852
standby()1853 status_t AudioHardware::AudioStreamInALSA::standby()
1854 {
1855 if (mHardware == NULL) return NO_INIT;
1856
1857 mSleepReq = true;
1858 {
1859 AutoMutex lock(mLock);
1860 mSleepReq = false;
1861
1862 { // scope for AudioHardware lock
1863 AutoMutex hwLock(mHardware->lock());
1864
1865 doStandby_l();
1866 }
1867 }
1868 return NO_ERROR;
1869 }
1870
doStandby_l()1871 void AudioHardware::AudioStreamInALSA::doStandby_l()
1872 {
1873 mStandbyCnt++;
1874
1875 if (!mStandby) {
1876 ALOGD("AudioHardware pcm capture is going to standby.");
1877 if (mEchoReference != NULL) {
1878 // stop reading from echo reference
1879 mEchoReference->read(mEchoReference, NULL);
1880 // Mutex acquisition order is always out -> in -> hw
1881 sp<AudioStreamOutALSA> spOut = mHardware->output();
1882 if (spOut != 0) {
1883 spOut->prepareLock();
1884 mHardware->lock().unlock();
1885 mLock.unlock();
1886 spOut->lock();
1887 mLock.lock();
1888 mHardware->lock().lock();
1889 mHardware->releaseEchoReference(mEchoReference);
1890 spOut->unlock();
1891 }
1892 mEchoReference = NULL;
1893 }
1894
1895 mStandby = true;
1896 }
1897 close_l();
1898 }
1899
close_l()1900 void AudioHardware::AudioStreamInALSA::close_l()
1901 {
1902 if (mMixer) {
1903 mHardware->closeMixer_l();
1904 mMixer = NULL;
1905 mRouteCtl = NULL;
1906 }
1907
1908 if (mPcm) {
1909 TRACE_DRIVER_IN(DRV_PCM_CLOSE)
1910 pcm_close(mPcm);
1911 TRACE_DRIVER_OUT
1912 mPcm = NULL;
1913 }
1914
1915 delete[] mProcBuf;
1916 mProcBuf = NULL;
1917 mProcBufSize = 0;
1918 delete[] mRefBuf;
1919 mRefBuf = NULL;
1920 mRefBufSize = 0;
1921 }
1922
open_l()1923 status_t AudioHardware::AudioStreamInALSA::open_l()
1924 {
1925 unsigned flags = PCM_IN;
1926
1927 struct pcm_config config = {
1928 channels : mChannelCount,
1929 rate : AUDIO_HW_IN_SAMPLERATE,
1930 period_size : AUDIO_HW_IN_PERIOD_SZ,
1931 period_count : AUDIO_HW_IN_PERIOD_CNT,
1932 format : PCM_FORMAT_S16_LE,
1933 start_threshold : 0,
1934 stop_threshold : 0,
1935 silence_threshold : 0,
1936 avail_min : 0,
1937 };
1938
1939 ALOGV("open pcm_in driver");
1940 TRACE_DRIVER_IN(DRV_PCM_OPEN)
1941 mPcm = pcm_open(0, 0, flags, &config);
1942 TRACE_DRIVER_OUT
1943 if (!pcm_is_ready(mPcm)) {
1944 ALOGE("cannot open pcm_in driver: %s\n", pcm_get_error(mPcm));
1945 TRACE_DRIVER_IN(DRV_PCM_CLOSE)
1946 pcm_close(mPcm);
1947 TRACE_DRIVER_OUT
1948 mPcm = NULL;
1949 return NO_INIT;
1950 }
1951
1952 if (mDownSampler != NULL) {
1953 mDownSampler->reset(mDownSampler);
1954 }
1955 mInputFramesIn = 0;
1956
1957 mProcBufSize = 0;
1958 mProcFramesIn = 0;
1959 mRefBufSize = 0;
1960 mRefFramesIn = 0;
1961
1962 mMixer = mHardware->openMixer_l();
1963 if (mMixer) {
1964 TRACE_DRIVER_IN(DRV_MIXER_GET)
1965 mRouteCtl = mixer_get_ctl_by_name(mMixer, "Capture MIC Path");
1966 TRACE_DRIVER_OUT
1967 }
1968
1969 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) {
1970 const char *route = mHardware->getInputRouteFromDevice(mDevices);
1971 ALOGV("read() wakeup setting route %s", route);
1972 if (mRouteCtl) {
1973 TRACE_DRIVER_IN(DRV_MIXER_SEL)
1974 mixer_ctl_set_enum_by_string(mRouteCtl, route);
1975 TRACE_DRIVER_OUT
1976 }
1977 }
1978
1979 return NO_ERROR;
1980 }
1981
dump(int fd,const Vector<String16> & args)1982 status_t AudioHardware::AudioStreamInALSA::dump(int fd, const Vector<String16>& args)
1983 {
1984 const size_t SIZE = 256;
1985 char buffer[SIZE];
1986 String8 result;
1987
1988 bool locked = tryLock(mLock);
1989 if (!locked) {
1990 snprintf(buffer, SIZE, "\n\t\tAudioStreamInALSA maybe deadlocked\n");
1991 } else {
1992 mLock.unlock();
1993 }
1994
1995 snprintf(buffer, SIZE, "\t\tmHardware: %p\n", mHardware);
1996 result.append(buffer);
1997 snprintf(buffer, SIZE, "\t\tmPcm: %p\n", mPcm);
1998 result.append(buffer);
1999 snprintf(buffer, SIZE, "\t\tmMixer: %p\n", mMixer);
2000 result.append(buffer);
2001 snprintf(buffer, SIZE, "\t\tStandby %s\n", (mStandby) ? "ON" : "OFF");
2002 result.append(buffer);
2003 snprintf(buffer, SIZE, "\t\tmDevices: 0x%08x\n", mDevices);
2004 result.append(buffer);
2005 snprintf(buffer, SIZE, "\t\tmChannels: 0x%08x\n", mChannels);
2006 result.append(buffer);
2007 snprintf(buffer, SIZE, "\t\tmSampleRate: %d\n", mSampleRate);
2008 result.append(buffer);
2009 snprintf(buffer, SIZE, "\t\tmBufferSize: %d\n", mBufferSize);
2010 result.append(buffer);
2011 snprintf(buffer, SIZE, "\t\tmDriverOp: %d\n", mDriverOp);
2012 result.append(buffer);
2013 write(fd, result.string(), result.size());
2014
2015 return NO_ERROR;
2016 }
2017
checkStandby()2018 bool AudioHardware::AudioStreamInALSA::checkStandby()
2019 {
2020 return mStandby;
2021 }
2022
setParameters(const String8 & keyValuePairs)2023 status_t AudioHardware::AudioStreamInALSA::setParameters(const String8& keyValuePairs)
2024 {
2025 AudioParameter param = AudioParameter(keyValuePairs);
2026 status_t status = NO_ERROR;
2027 int value;
2028
2029 ALOGD("AudioStreamInALSA::setParameters() %s", keyValuePairs.string());
2030
2031 if (mHardware == NULL) return NO_INIT;
2032
2033 mSleepReq = true;
2034 {
2035 AutoMutex lock(mLock);
2036 mSleepReq = false;
2037
2038 if (param.getInt(String8(AudioParameter::keyInputSource), value) == NO_ERROR) {
2039 AutoMutex hwLock(mHardware->lock());
2040
2041 mHardware->openMixer_l();
2042 mHardware->setInputSource_l((audio_source)value);
2043 mHardware->closeMixer_l();
2044
2045 param.remove(String8(AudioParameter::keyInputSource));
2046 }
2047
2048 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR)
2049 {
2050 if (value != 0) {
2051 AutoMutex hwLock(mHardware->lock());
2052
2053 if (mDevices != (uint32_t)value) {
2054 mDevices = (uint32_t)value;
2055 if (mHardware->mode() != AudioSystem::MODE_IN_CALL) {
2056 doStandby_l();
2057 }
2058 }
2059 }
2060 param.remove(String8(AudioParameter::keyRouting));
2061 }
2062 }
2063
2064
2065 if (param.size()) {
2066 status = BAD_VALUE;
2067 }
2068
2069 return status;
2070
2071 }
2072
getParameters(const String8 & keys)2073 String8 AudioHardware::AudioStreamInALSA::getParameters(const String8& keys)
2074 {
2075 AudioParameter param = AudioParameter(keys);
2076 String8 value;
2077 String8 key = String8(AudioParameter::keyRouting);
2078
2079 if (param.get(key, value) == NO_ERROR) {
2080 param.addInt(key, (int)mDevices);
2081 }
2082
2083 ALOGV("AudioStreamInALSA::getParameters() %s", param.toString().string());
2084 return param.toString();
2085 }
2086
addAudioEffect(effect_handle_t effect)2087 status_t AudioHardware::AudioStreamInALSA::addAudioEffect(effect_handle_t effect)
2088 {
2089 ALOGV("AudioStreamInALSA::addAudioEffect() %p", effect);
2090
2091 effect_descriptor_t desc;
2092 status_t status = (*effect)->get_descriptor(effect, &desc);
2093 if (status == 0) {
2094 if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) {
2095 ALOGV("AudioStreamInALSA::addAudioEffect() mNeedEchoReference true");
2096 mNeedEchoReference = true;
2097 standby();
2098 }
2099 ALOGV("AudioStreamInALSA::addAudioEffect() name %s", desc.name);
2100 } else {
2101 ALOGV("AudioStreamInALSA::addAudioEffect() get_descriptor() error");
2102 }
2103
2104 AutoMutex lock(mLock);
2105 mPreprocessors.add(effect);
2106 return NO_ERROR;
2107 }
2108
removeAudioEffect(effect_handle_t effect)2109 status_t AudioHardware::AudioStreamInALSA::removeAudioEffect(effect_handle_t effect)
2110 {
2111 status_t status = INVALID_OPERATION;
2112 ALOGV("AudioStreamInALSA::removeAudioEffect() %p", effect);
2113 {
2114 AutoMutex lock(mLock);
2115 for (size_t i = 0; i < mPreprocessors.size(); i++) {
2116 if (mPreprocessors[i] == effect) {
2117 mPreprocessors.removeAt(i);
2118 status = NO_ERROR;
2119 break;
2120 }
2121 }
2122 }
2123
2124 if (status == NO_ERROR) {
2125 effect_descriptor_t desc;
2126 if ((*effect)->get_descriptor(effect, &desc) == 0) {
2127 if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) {
2128 ALOGV("AudioStreamInALSA::removeAudioEffect() mNeedEchoReference false");
2129 mNeedEchoReference = false;
2130 standby();
2131 }
2132 }
2133 }
2134
2135 return status;
2136 }
2137
2138 extern "C" {
getNextBufferStatic(struct resampler_buffer_provider * provider,struct resampler_buffer * buffer)2139 int AudioHardware::AudioStreamInALSA::getNextBufferStatic(
2140 struct resampler_buffer_provider *provider,
2141 struct resampler_buffer* buffer)
2142 {
2143 ResamplerBufferProvider *bufferProvider = (ResamplerBufferProvider *)provider;
2144 return bufferProvider->mInputStream->getNextBuffer(buffer);
2145 }
2146
releaseBufferStatic(struct resampler_buffer_provider * provider,struct resampler_buffer * buffer)2147 void AudioHardware::AudioStreamInALSA::releaseBufferStatic(
2148 struct resampler_buffer_provider *provider,
2149 struct resampler_buffer* buffer)
2150 {
2151 ResamplerBufferProvider *bufferProvider = (ResamplerBufferProvider *)provider;
2152 return bufferProvider->mInputStream->releaseBuffer(buffer);
2153 }
2154
2155 }; // extern "C"
2156
getNextBuffer(struct resampler_buffer * buffer)2157 status_t AudioHardware::AudioStreamInALSA::getNextBuffer(struct resampler_buffer *buffer)
2158 {
2159 if (mPcm == NULL) {
2160 buffer->raw = NULL;
2161 buffer->frame_count = 0;
2162 mReadStatus = NO_INIT;
2163 return NO_INIT;
2164 }
2165
2166 if (mInputFramesIn == 0) {
2167 TRACE_DRIVER_IN(DRV_PCM_READ)
2168 mReadStatus = pcm_read(mPcm,(void*) mInputBuf, AUDIO_HW_IN_PERIOD_SZ * frameSize());
2169 TRACE_DRIVER_OUT
2170 if (mReadStatus != 0) {
2171 buffer->raw = NULL;
2172 buffer->frame_count = 0;
2173 return mReadStatus;
2174 }
2175 mInputFramesIn = AUDIO_HW_IN_PERIOD_SZ;
2176 }
2177
2178 buffer->frame_count = (buffer->frame_count > mInputFramesIn) ? mInputFramesIn:buffer->frame_count;
2179 buffer->i16 = mInputBuf + (AUDIO_HW_IN_PERIOD_SZ - mInputFramesIn) * mChannelCount;
2180
2181 return mReadStatus;
2182 }
2183
releaseBuffer(struct resampler_buffer * buffer)2184 void AudioHardware::AudioStreamInALSA::releaseBuffer(struct resampler_buffer *buffer)
2185 {
2186 mInputFramesIn -= buffer->frame_count;
2187 }
2188
getBufferSize(uint32_t sampleRate,int channelCount)2189 size_t AudioHardware::AudioStreamInALSA::getBufferSize(uint32_t sampleRate, int channelCount)
2190 {
2191 size_t i;
2192 size_t size = sizeof(inputConfigTable)/sizeof(uint32_t)/INPUT_CONFIG_CNT;
2193
2194 for (i = 0; i < size; i++) {
2195 if (sampleRate == inputConfigTable[i][INPUT_CONFIG_SAMPLE_RATE]) {
2196 return (AUDIO_HW_IN_PERIOD_SZ*channelCount*sizeof(int16_t)) /
2197 inputConfigTable[i][INPUT_CONFIG_BUFFER_RATIO];
2198 }
2199 }
2200 // this should never happen as getBufferSize() is always called after getInputSampleRate()
2201 // that checks for valid sampling rates.
2202 ALOGE("AudioStreamInALSA::getBufferSize() invalid sampling rate %d", sampleRate);
2203 return 0;
2204 }
2205
prepareLock()2206 int AudioHardware::AudioStreamInALSA::prepareLock()
2207 {
2208 // request sleep next time read() is called so that caller can acquire
2209 // mLock
2210 mSleepReq = true;
2211 return mStandbyCnt;
2212 }
2213
lock()2214 void AudioHardware::AudioStreamInALSA::lock()
2215 {
2216 mLock.lock();
2217 mSleepReq = false;
2218 }
2219
unlock()2220 void AudioHardware::AudioStreamInALSA::unlock() {
2221 mLock.unlock();
2222 }
2223
2224 //------------------------------------------------------------------------------
2225 // Factory
2226 //------------------------------------------------------------------------------
2227
createAudioHardware(void)2228 extern "C" AudioHardwareInterface* createAudioHardware(void) {
2229 return new AudioHardware();
2230 }
2231
2232 }; // namespace android
2233